/// <summary>
/// Adds environment variables that allow the program to make calls back to Zero Install.
/// </summary>
public static IEnvironmentBuilder SetCallbackEnvironmentVariables(this IEnvironmentBuilder builder)
{
void TryAdd(string envName, ProcessStartInfo?startInfo)
{
if (startInfo == null)
{
return;
}
try
{
builder.SetEnvironmentVariable(envName, startInfo.ToCommandLine());
}
catch (FileNotFoundException)
{
// Zero Install may be embedded as a library rather than called as an executable
}
}
TryAdd(ZeroInstallEnvironment.CliName, ProgramUtils.CliStartInfo());
TryAdd(ZeroInstallEnvironment.GuiName, ProgramUtils.GuiStartInfo());
TryAdd(ZeroInstallEnvironment.ExternalFetcherName, ProgramUtils.CliStartInfo(Fetch.Name));
return(builder);
}
/// <summary>
/// Sets the current active log level for the configured logger
/// </summary>
/// <param name="configuration"></param>
/// <param name="level">the log level to set</param>
/// <returns></returns>
public static IEnvironmentBuilder WithLogLevel(this IEnvironmentBuilder configuration,
LogLevel level)
{
if (configuration.Configuration.HasValue(typeof(ILoggerFacade).FullName))
{
if (configuration.Configuration.GetValue <ILoggerFacade>(typeof(ILoggerFacade).FullName) is ILoggerFacade facade)
{
facade.LogLevel = level;
}
}
return(configuration);
}
/// <summary>
/// Adds the xml file to the pipe
/// </summary>
/// <param name="builder"></param>
/// <param name="xPath">the xpath to retrieve</param>
/// <param name="file">the optional file to use</param>
/// <returns></returns>
public static IEnvironmentBuilder WithXml(this IEnvironmentBuilder builder, string xPath, string file = null)
{
return(builder.WithSource(cfg =>
{
if (!cfg.HasValue(typeof(XmlFileParser).FullName))
{
return null;//no xml file parser was registered
}
var reqType = cfg.GetBuildType();
var parser = cfg.GetValue <XmlFileParser>(typeof(XmlFileParser).FullName);
return parser.Value(xPath, reqType, file);
}, cfg => cfg.WithTrace(xPath, "xml")));
}
/// <summary>
/// Adds the json file to the pipeline
/// </summary>
/// <param name="builder"></param>
/// <param name="jPath">the json path to extract</param>
/// <returns></returns>
public static IEnvironmentBuilder WithJson(this IEnvironmentBuilder builder, string jPath)
{
//next line wil trigger an exception on malformed syntax
var expr = JSegment.Parse(jPath).ToList();
return(builder.WithSource(cfg =>
{
if (!cfg.HasValue(typeof(JsonFileParser).FullName))
{
return null;//no json file parser was registered
}
var reqType = cfg.GetBuildType();
var parser = cfg.GetValue <JsonFileParser>(typeof(JsonFileParser).FullName);
return parser.Value(expr, reqType);
}, cfg => cfg.WithTrace(jPath, "json")));
}
// this method will be used to get the next randomly incremented number
public static IEnvironmentBuilder Random(this IEnvironmentBuilder builder)
{
if (!builder.Configuration.HasValue(SaverKey))
{
builder.WithConfiguration(cfg => cfg.SetValue(SaverKey, new NumberSaver()));
}
return(builder.WithSource(config =>
{
//just a simple logic to increment and save values
var nextValue = config.GetFactoryValue <int>(RngKey);
var saver = config.GetValue <NumberSaver>(SaverKey);
var oldKey = saver.Prev;
saver.Prev += nextValue;
return oldKey;
}, config => config.WithTrace("my random value", "my random source")));
}
/// <summary>
/// Gets the formatted string containing the descriptions of the bundles and the utility.
/// </summary>
/// <param name="builder"></param>
/// <returns>the formatted help string</returns>
public static string GetHelp(this IEnvironmentBuilder builder)
{
var help = $"{{0}}{Environment.NewLine}{Environment.NewLine}{{1}}";
var parameter0 = builder.GetDescription();
bool parameter0valid = !string.IsNullOrEmpty(parameter0?.Trim());
string tabFormat = "\t";
var descriptions = builder.Bundles.GetDescriptions().ToArray();
var traces = builder.Bundles.Select(x => x.Sources.Select(y => y.GetTrace()).ToArray()).ToArray();
var range = Math.Max(descriptions.Length, traces.Length);
var combined = Enumerable.Range(0, range)
.Select(x =>
{
StringBuilder sb = new StringBuilder();
if (x < traces.Length)
{
sb.AppendLine($"- {(string.Join(", ", traces[x]))}");
}
else
{
sb.AppendLine($"- [unknown]");
}
if (x < descriptions.Length)
{
sb.AppendLine(tabFormat + descriptions[x]);
}
else
{
sb.AppendLine();
}
return(sb.ToString());
}).ToArray();
var parameter1 = string.Join(string.Empty, combined);
//var parameter1 = string.Join(Environment.NewLine ,
// builder.Bundles.GetDescriptions()
// .Select(x=>$"{(parameter0valid?tabFormat:string.Empty)}{x??string.Empty}").ToArray()
//);
return(parameter0valid ? string.Format(help, parameter0, parameter1) : parameter1);
}
/// <summary>
/// Adds the environment variable source to te pipe
/// </summary>
/// <param name="builder"></param>
/// <param name="name">the name of the variable</param>
/// <param name="configuration">the scoped configuration to add</param>
/// <returns></returns>
public static IEnvironmentBuilder WithEnvironmentVariable(this IEnvironmentBuilder builder, string name, Action <IEnvironmentConfiguration> configuration = null)
{
if (!builder.Configuration.HasValue(typeof(EnvironmentVariableParser).FullName))
{
builder.WithConfiguration(cfg => cfg.SetValue(typeof(EnvironmentVariableParser).FullName,
new EnvironmentVariableParser()));
}
return(builder.WithSource(cfg =>
{
var parser = cfg.GetValue <EnvironmentVariableParser>(typeof(EnvironmentVariableParser).FullName);
var requiredType = cfg.GetBuildType();
var target = cfg.GetEnvironmentTarget();
var prefix = cfg.GetEnvironmentVariablePrefix();
return parser.Value(name, requiredType, target, prefix);
}, cfg =>
{
configuration?.Invoke(cfg);
cfg.WithTrace(name, "environment");
}));
}
public static Resolvable <T> When <T, TR>(this IEnvironmentBuilder bundle, TR match, Func <T> segment)
{
var wrapper = bundle.Bundle();
return(new Resolvable <T>(() =>
{
var resolvedValue = wrapper.Build <TR>();
if ((resolvedValue != null && resolvedValue.Equals(match)) ||
(match != null && match.Equals(resolvedValue)))
{
return segment == null
? default
: segment.Invoke();
}
return default;
})
{
Scope = new FlowScope
{
PreviousState = wrapper
}
});
/// <summary>
/// Adds the default value source to the pipe
/// </summary>
/// <typeparam name="T">the type of value</typeparam>
/// <param name="builder"></param>
/// <param name="value">the value to add</param>
/// <returns></returns>
public static IEnvironmentBuilder WithDefaultValue <T>(this IEnvironmentBuilder builder, T value)
{
return(builder.WithSource(_ => value, cfg => cfg.WithTrace(value?.ToString(), "default")));
}
/// <summary>
/// Gets the global description or null if none exist
/// </summary>
/// <param name="builder">the builder</param>
/// <returns>the description</returns>
public static string GetDescription(this IEnvironmentBuilder builder)
{
return(builder.Configuration.GetValue(Constants.GlobalDescriptionValueKey));
}
/// <summary>
/// Sets the scoped description for the current bundle. This value will be used to print out the info for the current bundle.
/// </summary>
/// <param name="builder"></param>
/// <param name="description"></param>
/// <returns></returns>
public static IEnvironmentBuilder WithDescription(this IEnvironmentBuilder builder, string description)
{
return(builder.WithConfiguration(config =>
config.SetValue(Constants.SourceDescriptionValueKey, description)));
}
private Flow(IEnvironmentBuilder builder)
{
_builder = builder;
}
/// <summary>
/// This is a shorthand for the "WithXml"
/// </summary>
/// <param name="builder"></param>
/// <param name="xPath">the xpath to retrieve</param>
/// <param name="file">the optional file to use</param>
/// <returns></returns>
public static IEnvironmentBuilder Xml(this IEnvironmentBuilder builder, string xPath, string file = null)
{
return(builder.WithXml(xPath, file));
}
/// <summary>
/// Shorthand alias for "WithArgument" using the common key set beforehand
/// See also "CommonExtensions.WithCommonKey"
/// </summary>
/// <param name="builder"></param>
/// <returns></returns>
public static IEnvironmentBuilder Arg(this IEnvironmentBuilder builder)
{
return(builder.WithArgument(builder.Configuration.GetCommonKey()));
}
/// <summary>
/// This is a shorthand for <see cref="WithCommonKey"/>
/// </summary>
/// <param name="builder"></param>
/// <param name="key">the key name</param>
/// <returns></returns>
public static IEnvironmentBuilder With(this IEnvironmentBuilder builder, string key)
{
return(builder.WithCommonKey(key));
}
/// <summary>
/// Shorthand alias for <see cref="WithException"/>
/// </summary>
/// <param name="builder"></param>
/// <param name="message">the message to throw</param>
/// <returns></returns>
public static IEnvironmentBuilder Throw(this IEnvironmentBuilder builder, string message = null)
{
return(builder.WithException(message));
}
/// <summary>
/// Logs the fatal message to the logger
/// </summary>
/// <param name="configuration"></param>
/// <param name="message">the message to log</param>
public static void LogFatal(this IEnvironmentBuilder configuration, object message)
{
configuration.WithConfiguration(cfg => cfg.Log(LogLevel.Fatal, message));
}
public static Resolvable <T> As <T>(this IEnvironmentBuilder bundle)
{
return(new Resolvable <T>(bundle.Bundle().Build <T>));
}
/// <summary>
/// Shorthand alias for <see cref="WithDefaultValue{T}"/>
/// </summary>
/// <typeparam name="T">the type of value</typeparam>
/// <param name="builder"></param>
/// <param name="value">the value to add</param>
/// <returns></returns>
public static IEnvironmentBuilder Default <T>(this IEnvironmentBuilder builder, T value)
{
return(builder.WithDefaultValue(value));
}
/// <summary>
/// Shorthand alias for "WithEnvironmentVariable" using the common key set beforehand
/// "CommonExtensions.WithCommonKey"
/// </summary>
/// <param name="builder"></param>
/// <returns></returns>
public static IEnvironmentBuilder Env(this IEnvironmentBuilder builder, Action <IEnvironmentConfiguration> configuration = null)
{
return(builder.WithEnvironmentVariable(builder.Configuration.GetCommonKey(), configuration));
}
/// <summary>
/// Adds the throwable source to the pipe. Throws an ArgumentException if hit
/// </summary>
/// <param name="builder"></param>
/// <param name="message">the message to throw</param>
/// <returns></returns>
public static IEnvironmentBuilder WithException(this IEnvironmentBuilder builder, string message)
{
return(builder.WithSource <object>(_ => throw new ArgumentException(message ?? "Missing required variable"), cfg => cfg.WithTrace(message, "exception")));
}
public EnvironmentBundle(IEnvironmentBuilder builder)
{
this._builder = builder;
}
/// <summary>
/// Adds the common key to the configuration to be consumed by other types
/// </summary>
/// <param name="builder"></param>
/// <param name="key">the key name</param>
/// <returns></returns>
public static IEnvironmentBuilder WithCommonKey(this IEnvironmentBuilder builder, string key)
{
return(builder.WithConfiguration(cfg => cfg.SetValue(Constants.SourceCommonKeyKey, key)));
}
/// <summary>
/// This is a shorthand for the "WithJson"
/// </summary>
/// <param name="builder"></param>
/// <param name="jPath">the json path to extract</param>
/// <returns></returns>
public static IEnvironmentBuilder Json(this IEnvironmentBuilder builder, string jPath)
{
return(builder.WithJson(jPath));
}
private void GenerateEnvironment(IEnvironment env, ITexturePack textures)
{
IEnvironmentBuilder dungeonBuilder = GetComponent <EnvironmentBuilder> ();
dungeonBuilder.Generate(env, textures);
}
/// <summary>
/// Shorthand for "WithEnvironmentVariable"
/// </summary>
/// <param name="builder"></param>
/// <param name="name">the name of the variable</param>
/// <param name="configuration">the configuration to use</param>
/// <returns></returns>
public static IEnvironmentBuilder Env(this IEnvironmentBuilder builder, string name, Action <IEnvironmentConfiguration> configuration = null)
{
return(builder.WithEnvironmentVariable(name, configuration));
}
