private static void PrintOptionsList(TextWriter @out, Options options)
{
GetOptParser.GetOptions(options)
.Where(_ => !_.IsOperands)
.Where(IncludeInHelp)
.Select(_ => new { indent, _.Syntax, _.Description })
.ToTable(header: false)
.Write(@out);
}
public void TestLongSingleInt()
{
var name = "num";
var expected = 12;
var input = $"--{name} {expected}";
var parser = new GetOptParser();
var provider = parser.Parse(input);
Assert.AreEqual(expected, provider.Get <int>(name));
}
public void TestMultipleParameters()
{
var input = "-x 640 -y 480 --num 100 -vdi --no-commit";
var parser = new GetOptParser();
var provider = parser.Parse(input);
Assert.AreEqual(640, provider.Get <int>("x"));
Assert.AreEqual(480, provider.Get <int>("y"));
Assert.AreEqual(100, provider.Get <int>("num"));
Assert.AreEqual(true, provider.Get <bool>("v"));
Assert.AreEqual(true, provider.Get <bool>("d"));
Assert.AreEqual(true, provider.Get <bool>("i"));
Assert.AreEqual(true, provider.Get <bool>("no-commit"));
}
/// <summary>
/// Extract the target to be called and its arguments from command line arguments
/// </summary>
/// <param name="arguments">all command line arguments (required for error display)</param>
/// <param name="options">parsed options</param>
/// <returns></returns>
static (MethodInfo target, string[] arguments) ParseCommandLineTarget(string[] arguments, Options options)
{
var targetAndArguments = options.TargetAndArguments;
var targets = options.Targets;
if (targetAndArguments.Length == 0)
{
try
{
return(GetDefaultTarget(targets), new string[] { });
}
catch (Exception e)
{
throw new ParseException(arguments, -1, e);
}
}
var candidates = HelpText.PublicTargets(targets.GetType());
var targetName = targetAndArguments[0];
var targetArguments = targetAndArguments.Skip(1).ToArray();
try
{
var target = candidates.FindByName(
_ => GetOptParser.GetLongOptionNameForMember(_.Name),
targetName,
"targets"
);
return(target, targetArguments);
}
catch (ArgumentOutOfRangeException e)
{
throw new ParseException(arguments, Array.IndexOf(arguments, targetName), e);
}
}
private static string Syntax(MethodInfo method)
{
return(new[] { GetOptParser.GetLongOptionNameForMember(method.Name), }
.Concat(method.GetParameters().Select(_ => $"<{_.Name}>"))
.Join(" "));
}
public ExitCode Run()
{
try
{
Logger = Log.Logger = new LoggerConfiguration()
.WriteTo.Console(SerilogLogEventLevel(Verbosity.Detailed))
.CreateLogger();
var builder = new DefaultProxyBuilder();
var generator = new ProxyGenerator(builder);
var onceInterceptor = new OnceInterceptor();
var onceProxy = generator.CreateClassProxy(targetsType, new ProxyGenerationOptions
{
Hook = new OnceHook()
},
onceInterceptor);
var options = new Options(onceProxy);
GetOptParser.Parse(commandLineArguments, options);
if (rebuildCheck)
{
if (IsOutOfDate() && !options.IgnoreClean)
{
return(RequireRebuild());
}
}
Logger = Log.Logger = new LoggerConfiguration()
.WriteTo.Console(SerilogLogEventLevel(options.Verbosity),
outputTemplate: "{Timestamp:o}|{Level:u3}|{Message:lj}{NewLine}{Exception}")
.CreateLogger();
if (options.Edit)
{
var cmd = new Tool("cmd").WithArguments("/c", "start");
var buildCsProj = sourceDir.Glob("*.csproj").First();
cmd.Run(buildCsProj).Wait();
return(ExitCode.HelpDisplayed);
}
if ((options.Clean && !options.IgnoreClean))
{
return(RequireRebuild());
}
if (options.Help)
{
HelpText.Print(Console.Out, options);
return(ExitCode.HelpDisplayed);
}
var(target, targetArguments) = ParseCommandLineTarget(commandLineArguments, options);
var amgBuildAssembly = Assembly.GetExecutingAssembly();
Logger.Information("Amg.Build: {assembly} {build}", amgBuildAssembly.Location, amgBuildAssembly.GetCustomAttribute <AssemblyInformationalVersionAttribute>().InformationalVersion);
var startup = GetStartupInvocation();
IEnumerable <InvocationInfo> invocations = new[] { startup };
try
{
RunTarget(options.Targets, target, targetArguments);
}
catch (InvocationFailed)
{
invocations = invocations.Concat(onceInterceptor.Invocations);
if (options.Verbosity > Verbosity.Quiet)
{
Console.WriteLine(Summary.Print(invocations));
}
Console.Error.WriteLine(Summary.Error(invocations));
return(ExitCode.TargetFailed);
}
invocations = invocations.Concat(onceInterceptor.Invocations);
if (options.Verbosity > Verbosity.Quiet)
{
Console.WriteLine(Summary.Print(invocations));
}
return(ExitCode.Success);
}
catch (ParseException ex)
{
Console.Error.WriteLine(ex.Message);
Console.Error.WriteLine();
Console.Error.WriteLine("Run with --help to get help.");
return(ExitCode.CommandLineError);
}
catch (Exception ex)
{
Console.Error.WriteLine(ex.Message);
return(ExitCode.UnknownError);
}
}
private static void RunTarget(object targets, MethodInfo target, string[] arguments)
{
Logger.Information("Run {target}({arguments})", target, arguments);
var result = Wait(GetOptParser.Invoke(targets, target, arguments));
}
