private static void ParseOption(string arg, CakeHostOptions options)
{
if (!IsOption(arg))
{
throw new FrostingException($"Encountered invalid option '{arg}'");
}
string name, value;
var nameIndex = arg.StartsWith("--") ? 2 : 1;
var separatorIndex = arg.IndexOfAny(new[] { '=' });
if (separatorIndex < 0)
{
name = arg.Substring(nameIndex);
value = string.Empty;
}
else
{
name = arg.Substring(nameIndex, separatorIndex - nameIndex);
value = arg.Substring(separatorIndex + 1);
}
ParseOption(name, value.UnQuote(), options);
}
private static void ParseOption(string name, string value, CakeHostOptions options)
{
if (name.Equals("working", StringComparison.OrdinalIgnoreCase) ||
name.Equals("w", StringComparison.OrdinalIgnoreCase))
{
options.WorkingDirectory = new DirectoryPath(value);
}
if (name.Equals("verbosity", StringComparison.OrdinalIgnoreCase) ||
name.Equals("v", StringComparison.OrdinalIgnoreCase))
{
Verbosity verbosity;
if (!VerbosityParser.TryParse(value, out verbosity))
{
throw new CakeException($"The value '{value}' is not a valid verbosity.");
}
options.Verbosity = verbosity;
}
if (name.Equals("target", StringComparison.OrdinalIgnoreCase) ||
name.Equals("t", StringComparison.OrdinalIgnoreCase))
{
options.Target = value;
}
if (name.Equals("help", StringComparison.OrdinalIgnoreCase) ||
name.Equals("h", StringComparison.OrdinalIgnoreCase))
{
if (ParseBooleanValue(value))
{
options.Command = CakeHostCommand.Help;
}
}
if (name.Equals("dryrun", StringComparison.OrdinalIgnoreCase) ||
name.Equals("d", StringComparison.OrdinalIgnoreCase))
{
if (ParseBooleanValue(value))
{
options.Command = CakeHostCommand.DryRun;
}
}
if (name.Equals("version", StringComparison.OrdinalIgnoreCase))
{
if (ParseBooleanValue(value))
{
options.Command = CakeHostCommand.Version;
}
}
if (options.Arguments.ContainsKey(name))
{
throw new CakeException($"More than one argument called '{name}' was encountered.");
}
options.Arguments.Add(name, value);
}
public CakeHostBuilderFixture()
{
Builder = new CakeHostBuilder();
Environment = FakeEnvironment.CreateUnixEnvironment();
FileSystem = new FakeFileSystem(Environment);
Log = Substitute.For <ICakeLog>();
Engine = new CakeEngine(Log);
Options = new CakeHostOptions();
}
public override bool Execute(ICakeEngine engine, CakeHostOptions options)
{
var report = engine.RunTarget(_context, _strategy, options.Target);
if (report != null && !report.IsEmpty)
{
_printer.Write(report);
}
return(true);
}
public void Should_Set_Verbosity_To_Default_Value()
{
// Given
var options = new CakeHostOptions();
// When
var result = options.Verbosity;
// Then
Assert.Equal(Verbosity.Normal, result);
}
public void Should_Set_Target_To_Default_Value()
{
// Given
var options = new CakeHostOptions();
// When
var result = options.Target;
// Then
Assert.Equal("Default", result);
}
public void Should_Set_Command_To_Default_Value()
{
// Given
var options = new CakeHostOptions();
// When
var result = options.Command;
// Then
Assert.Equal(CakeHostCommand.Run, result);
}
public void Should_Set_Arguments_To_Empty_Dictionary()
{
// Given
var options = new CakeHostOptions();
// When
var result = options.Arguments;
// Then
Assert.NotNull(result);
}
public void Should_Set_Working_Directory_To_Default_Value()
{
// Given
var options = new CakeHostOptions();
// When
var result = options.WorkingDirectory;
// Then
Assert.Null(result);
}
public override bool Execute(ICakeEngine engine, CakeHostOptions options)
{
_executionSettings.SetTarget(options.Target);
var report = engine.RunTargetAsync(_context, _strategy, _executionSettings).GetAwaiter().GetResult();
if (report != null && !report.IsEmpty)
{
_printer.Write(report);
}
return(true);
}
public override async Task <bool> ExecuteAsync(ICakeEngine engine, CakeHostOptions options)
{
_executionSettings.SetTarget(options.Target);
var report = await engine.RunTargetAsync(_context, _strategy, _executionSettings).ConfigureAwait(false);
if (report != null && !report.IsEmpty)
{
_printer.Write(report);
}
return(true);
}
public Configuration(
CakeConfigurationProvider provider,
CakeHostOptions options,
ICakeEnvironment environment,
IEnumerable <ConfigurationValue> values)
{
_provider = provider;
_options = options;
_environment = environment;
_values = values;
_lock = new object();
_configuration = null;
}
public CakeHostBuilderFixture()
{
Builder = new CakeHostBuilder();
Environment = FakeEnvironment.CreateUnixEnvironment();
FileSystem = new FakeFileSystem(Environment);
FileSystem.CreateDirectory("/Working");
Log = Substitute.For <ICakeLog>();
Data = Substitute.For <ICakeDataService>();
Engine = new CakeEngine(Data, Log);
Installer = Substitute.For <IToolInstaller>();
Options = new CakeHostOptions();
}
public override bool Execute(ICakeEngine engine, CakeHostOptions options)
{
_log.Information("Performing dry run...");
_log.Information("Target is: {0}", options.Target);
_log.Information(string.Empty);
var strategy = new DryRunExecutionStrategy(_log);
engine.RunTarget(_context, strategy, options.Target);
_log.Information(string.Empty);
_log.Information("This was a dry run.");
_log.Information("No tasks were actually executed.");
return(true);
}
public static CakeHostOptions Parse(IEnumerable<string> args)
{
if (args == null)
{
throw new ArgumentNullException(nameof(args));
}
var options = new CakeHostOptions();
foreach (var argument in args)
{
ParseOption(argument.UnQuote(), options);
}
return options;
}
public override async Task <bool> ExecuteAsync(ICakeEngine engine, CakeHostOptions options)
{
_executionSettings.SetTarget(options.Target);
_log.Information("Performing dry run...");
_log.Information("Target is: {0}", options.Target);
_log.Information(string.Empty);
var strategy = new DryRunExecutionStrategy(_log);
await engine.RunTargetAsync(_context, strategy, _executionSettings).ConfigureAwait(false);
_log.Information(string.Empty);
_log.Information("This was a dry run.");
_log.Information("No tasks were actually executed.");
return(true);
}
public Command GetCommand(CakeHostOptions options)
{
switch (options.Command)
{
case CakeHostCommand.Help:
return(_scope.Resolve <HelpCommand>());
case CakeHostCommand.DryRun:
return(_scope.Resolve <DryRunCommand>());
case CakeHostCommand.Version:
return(_scope.Resolve <VersionCommand>());
case CakeHostCommand.Run:
return(_scope.Resolve <RunCommand>());
default:
return(new ErrorDecoratorCommand(_scope.Resolve <HelpCommand>()));
}
}
public static CakeHostOptions Parse(IEnumerable <string> args)
{
if (args == null)
{
throw new ArgumentNullException(nameof(args));
}
var options = new CakeHostOptions
{
WorkingDirectory = ".",
Target = "Default",
Verbosity = Verbosity.Normal
};
foreach (var argument in args)
{
ParseOption(argument.UnQuote(), options);
}
return(options);
}
public override bool Execute(ICakeEngine engine, CakeHostOptions options)
{
_console.Write("Cake.Frosting (");
_console.ForegroundColor = ConsoleColor.Yellow;
_console.Write(typeof(HelpCommand).GetTypeInfo().Assembly.GetName().Version.ToString(3));
_console.ResetColor();
_console.WriteLine(")");
_console.WriteLine("Usage:");
_console.WriteLine(" dotnet {0}.dll [options]", typeof(HelpCommand).GetTypeInfo().Assembly.GetName().Name);
_console.WriteLine();
_console.WriteLine("Options:");
_console.WriteLine(" --target|-t <TARGET> Sets the build target");
_console.WriteLine(" --working|-w <DIR> Sets the working directory");
_console.WriteLine(" --verbosity|-v <VERBOSITY> Sets the verbosity");
_console.WriteLine(" --dryrun|-r Performs a dry run");
_console.WriteLine(" --version Displays Cake.Frosting version number");
_console.WriteLine(" --help|-h Show help");
_console.WriteLine();
return(true);
}
/// <summary>
/// Initializes a new instance of the <see cref="RawArguments" /> class.
/// </summary>
/// <param name="options">The options.</param>
public RawArguments(CakeHostOptions options)
{
_arguments = new Dictionary <string, string>(
(options ?? new CakeHostOptions()).Arguments ?? new Dictionary <string, string>(),
StringComparer.OrdinalIgnoreCase);
}
public override bool Execute(ICakeEngine engine, CakeHostOptions options)
{
_console.Write(typeof(HelpCommand).GetTypeInfo().Assembly.GetName().Version.ToString(3));
return(true);
}
public override Task <bool> ExecuteAsync(ICakeEngine engine, CakeHostOptions options)
{
_console.Write(typeof(HelpCommand).GetTypeInfo().Assembly.GetName().Version.ToString(3));
return(Task.FromResult(true));
}
public abstract Task <bool> ExecuteAsync(ICakeEngine engine, CakeHostOptions options);
public override bool Execute(ICakeEngine engine, CakeHostOptions options)
{
_command.Execute(engine, options);
return(false);
}
public override async Task <bool> ExecuteAsync(ICakeEngine engine, CakeHostOptions options)
{
await _command.ExecuteAsync(engine, options).ConfigureAwait(false);
return(false);
}
public abstract bool Execute(ICakeEngine engine, CakeHostOptions options);
