static async Task Main(string[] args) { var delayOption = new Option <int>("--delay"); var messageOption = new Option <string>("--message"); var rootCommand = new RootCommand("Middleware example"); rootCommand.Add(delayOption); rootCommand.Add(messageOption); rootCommand.SetHandler((int delayOptionValue, string messageOptionValue) => { DoRootCommand(delayOptionValue, messageOptionValue); }, delayOption, messageOption); // <middleware> var commandLineBuilder = new CommandLineBuilder(rootCommand); commandLineBuilder.AddMiddleware(async(context, next) => { if (context.ParseResult.Directives.Contains("just-say-hi")) { context.Console.WriteLine("Hi!"); } else { await next(context); } }); commandLineBuilder.UseDefaults(); var parser = commandLineBuilder.Build(); await parser.InvokeAsync("[just-say-hi] --delay 42 --message \"Hello world!\""); // </middleware> }
static int Main(string[] args) { // Create a root command with some options var rootCommand = new RootCommand { new Option( "--int-option", "An option whose argument is parsed as an int") { Argument = new Argument <int>(defaultValue: () => 42) }, new Option( "--bool-option", "An option whose argument is parsed as a bool") { Argument = new Argument <bool>() }, new Option( "--file-option", "An option whose argument is parsed as a FileInfo") { Argument = new Argument <FileInfo>() } }; rootCommand.Description = "My sample app"; rootCommand.Handler = CommandHandler.Create <int, bool, FileInfo>((intOption, boolOption, fileOption) => { Console.WriteLine($"The value for --int-option is: {intOption}"); Console.WriteLine($"The value for --bool-option is: {boolOption}"); Console.WriteLine($"The value for --file-option is: {fileOption?.FullName ?? "null"}"); }); // Parse the incoming args and invoke the handler return(rootCommand.InvokeAsync(args).Result); }
public static void Main(string[] args) { var rootCommand = new RootCommand { new Option("--list", "List all audio devices"), new Option <string>("--set", "Set device"), new Option <string>("--set-comm", "Set communication device") }; rootCommand.Description = "AudioDeviceSelector"; // Note that the parameters of the handler method are matched according to the names of the options rootCommand.Handler = CommandHandler.Create <string, string>( (set, setComm) => { var controller = new CoreAudioController(); var devices = controller.GetDevices(); if (args.Count() < 1) { Console.WriteLine($"{Assembly.GetExecutingAssembly().GetName().Name}.exe --help"); } if (args.Any(x => x.ToString().ToLower() == "--list")) { devices .OrderBy(d => d.DeviceType) .ToList() .ForEach(d => Console.WriteLine($"DeviceType: {d.DeviceType}, Id: {d.Id}, InterfaceName: {d.InterfaceName}, Name: {d.Name}")); } _ = set != null && controller.SetDeviceByName(set); _ = setComm != null && controller.SetCommDeviceByName(setComm); }); rootCommand.Invoke(args); }
public void An_option_can_have_multiple_parents_with_the_same_name() { var option = new Option <string>("--the-option"); var sprocket = new Command("sprocket") { new Command("add") { option } }; var widget = new Command("widget") { new Command("add") { option } }; var root = new RootCommand { sprocket, widget }; option.Parents .Select(p => p.Name) .Should() .BeEquivalentTo("add", "add"); option.Parents .SelectMany(p => p.Parents) .Select(p => p.Name) .Should() .BeEquivalentTo("sprocket", "widget"); }
public void When_option_is_not_respecified_and_limit_is_reached_then_the_following_token_is_unmatched() { var animalsOption = new Option(new[] { "-a", "--animals" }) { AllowMultipleArgumentsPerToken = true, Arity = ArgumentArity.ZeroOrOne }; var vegetablesOption = new Option(new[] { "-v", "--vegetables" }) { Arity = ArgumentArity.ZeroOrMore }; var command = new RootCommand { animalsOption, vegetablesOption }; var result = command.Parse("-a cat some-arg -v carrot"); result.FindResultFor(animalsOption) .Tokens .Select(t => t.Value) .Should() .BeEquivalentTo("cat"); result.FindResultFor(vegetablesOption) .Tokens .Select(t => t.Value) .Should() .BeEquivalentTo("carrot"); result .UnmatchedTokens .Should() .BeEquivalentTo("some-arg"); }
private static Task <int> Main(string[] args) { var toolDirectory = AppDomain.CurrentDomain.BaseDirectory; var workingDirectory = Directory.GetCurrentDirectory(); var version = Assembly.GetExecutingAssembly().GetName().Version; Console.WriteLine($@" {asciiart} tool directory: { toolDirectory } work directory: { workingDirectory } tool version : {version.Major}.{version.Minor}.{version.Build} "); var service = GetService(workingDirectory); var rootCommand = new RootCommand { new Option("--config-file") { Argument = new Argument <string>() } }; rootCommand.Description = "larnaca mssql collector"; rootCommand.Handler = CommandHandler.Create <string>(async(configFile) => { var resp = await service.WriteDatabaseMetaToFile(workingDirectory); Console.WriteLine(resp.StatusMessage); if (resp.Fail()) { Environment.Exit(resp.StatusCode); } }); // Parse the incoming args and invoke the handler return(rootCommand.InvokeAsync(args)); }
private static int Main(string[] args) { System.Console.WriteLine("===================================================="); System.Console.WriteLine($"{SokoSolveApp.Name} :: v{SokoSolveApp.Version}"); System.Console.WriteLine(DevHelper.FullDevelopmentContext()); System.Console.WriteLine("----------------------------------------------------"); System.Console.WriteLine(); var root = new RootCommand(); root.AddCommand(BenchmarkCommand.GetCommand()); //------------------------------------------------------------------------------------------------------------ var play = new Command("play", "Play SokoSolve game in the console") { Handler = CommandHandler.Create(PlayCommand.Run) }; root.AddCommand(play); //------------------------------------------------------------------------------------------------------------ var micro = new Command("micro", "Micro Benchmarks (BenchmarkDotNet)") { new Argument <string>(() => "BaseLineSolvers") { Name = "target", Description = "Target Type" }, }; micro.Handler = CommandHandler.Create <string>(MicroCommand.Run); root.AddCommand(micro); //------------------------------------------------------------------------------------------------------------ root.Add(AnalyseCommand.GetCommand()); return(root.Invoke(args)); }
public static Task <int> Main(string[] args) { var command = new RootCommand() { Description = "Developer tools and publishing for microservices.", }; command.AddCommand(CreateInitCommand()); command.AddCommand(CreateGenerateCommand()); command.AddCommand(CreateRunCommand(args)); command.AddCommand(CreateBuildCommand()); command.AddCommand(CreatePushCommand()); command.AddCommand(CreateDeployCommand()); command.AddCommand(CreateUndeployCommand()); // Show commandline help unless a subcommand was used. command.Handler = CommandHandler.Create <IHelpBuilder>(help => { help.Write(command); return(1); }); var builder = new CommandLineBuilder(command); builder.UseHelp(); builder.UseVersionOption(); builder.UseDebugDirective(); builder.UseParseErrorReporting(); builder.ParseResponseFileAs(ResponseFileHandling.ParseArgsAsSpaceSeparated); builder.CancelOnProcessTermination(); builder.UseExceptionHandler(HandleException); var parser = builder.Build(); return(parser.InvokeAsync(args)); }
public void All_custom_validators_are_called(string commandLine) { var commandValidatorWasCalled = false; var optionValidatorWasCalled = false; var argumentValidatorWasCalled = false; var option = new Option <string>("-o"); option.AddValidator(_ => { optionValidatorWasCalled = true; }); var argument = new Argument <string>("the-arg"); argument.AddValidator(_ => { argumentValidatorWasCalled = true; }); var rootCommand = new RootCommand { option, argument }; rootCommand.AddValidator(_ => { commandValidatorWasCalled = true; }); rootCommand.Invoke(commandLine); commandValidatorWasCalled.Should().BeTrue(); optionValidatorWasCalled.Should().BeTrue(); argumentValidatorWasCalled.Should().BeTrue(); }
public void Batch_Query_UpdateFail(string batchMethod, string settingsFile) { string overrideFile = Path.GetFullPath("TestConfig/databasetargets.cfg"); string outputFile = Path.GetFullPath($"{Guid.NewGuid().ToString()}.csv"); string updatequery = Path.GetFullPath("updatequery.sql"); if (!File.Exists(updatequery)) { File.WriteAllText(updatequery, Properties.Resources.updatequery); } //get the size of the log file before we start int startingLine = LogFileCurrentLineCount(); settingsFile = Path.GetFullPath(settingsFile); var args = new string[] { "batch", batchMethod, "--settingsfile", settingsFile, "--settingsfilekey", this.settingsFileKeyPath, "--override", overrideFile, "--outputfile", outputFile, "--queryfile", updatequery, "--silent" }; RootCommand rootCommand = CommandLineBuilder.SetUp(); var val = rootCommand.InvokeAsync(args); val.Wait(); var result = val.Result; ; var logFileContents = ReleventLogFileContents(startingLine); Assert.AreEqual(5, result, StandardExecutionErrorMessage(logFileContents)); //Assert.IsTrue(logFileContents.Contains("An INSERT, UPDATE or DELETE keyword was found"), "An UPDATE statement should have been found"); }
static async Task FileSystemInfoExample(string[] args) { // <filesysteminfo> var fileOrDirectoryOption = new Option <FileSystemInfo>("--file-or-directory"); var command = new RootCommand(); command.Add(fileOrDirectoryOption); command.SetHandler( (FileSystemInfo? fileSystemInfo) => { switch (fileSystemInfo) { case FileInfo file: Console.WriteLine($"File name: {file.FullName}"); break; case DirectoryInfo directory: Console.WriteLine($"Directory name: {directory.FullName}"); break; default: Console.WriteLine("Not a valid file or directory name."); break; } }, fileOrDirectoryOption); await command.InvokeAsync(args); // </filesysteminfo> await command.InvokeAsync("--file-or-directory scl.runtimeconfig.json"); await command.InvokeAsync("--file-or-directory ../net6.0"); await command.InvokeAsync("--file-or-directory newfile.json"); }
static void Main(string[] args) { System.Diagnostics.Process.GetCurrentProcess().PriorityClass = System.Diagnostics.ProcessPriorityClass.High; var rootCommand = new RootCommand("Benchmarks scatter/gather") { TreatUnmatchedTokensAsErrors = true, }; var remoteCommand = new Command("r", "Runs the remote host."); remoteCommand.AddOption(new Option <string>("--ip", "The IP to bind to.")); remoteCommand.AddOption(new Option <int>("--port", "The port to bind to.")); remoteCommand.Handler = CommandHandler.Create <string, int>((ip, port) => { if (ip == null) { ip = "::1"; } RunRemoteHost(ip, port); }); var benchmarkCommand = new Command("b", "Runs the benchmark."); benchmarkCommand.AddOption(new Option <string>("--host", "The host to connect to.") { IsRequired = true }); benchmarkCommand.Handler = CommandHandler.Create <string>(host => { new Program().RunBenchmarkAsync(host).AsTask().GetAwaiter().GetResult(); }); rootCommand.AddCommand(remoteCommand); rootCommand.AddCommand(benchmarkCommand); rootCommand.Invoke(args); }
public void When_response_file_parse_as_space_separated_returns_expected_values(string input) { var responseFile = ResponseFile(input); var rootCommand = new RootCommand { new Option("--flag") { Argument = new Argument <string>() }, new Option("--flag2") { Argument = new Argument <int>() } }; var parser = new CommandLineBuilder(rootCommand) .ParseResponseFileAs(ResponseFileHandling.ParseArgsAsSpaceSeparated) .Build(); var result = parser.Parse($"@{responseFile}"); result.ValueForOption("--flag").Should().Be("first value"); result.ValueForOption("--flag2").Should().Be(123); }
public static int Main(string[] args) { RootCommand rootCommand = CommandLineUtilities.GenerateRootCommand(); rootCommand.Handler = CommandHandler.Create <Configuration>((config) => { BenchmarkCoordinator.Config = config; var mode = config.Benchmark; if (mode == BenchmarkMode.Custom) { Console.Write(config.ToFormattedString()); RunCustomBenchmark(); return(0); } Console.Write(config.ExecutionEnvironmentToString()); RunPredefinedBenchmarks(mode); return(0); }); return(rootCommand.Invoke(args)); }
public void Parser_options_can_supply_context_sensitive_matches() { var parser = new RootCommand { new Option("--bread", arity: ArgumentArity.ExactlyOne) .FromAmong("wheat", "sourdough", "rye"), new Option("--cheese", arity: ArgumentArity.ExactlyOne) .FromAmong("provolone", "cheddar", "cream cheese") }; var commandLine = "--bread"; var result = parser.Parse(commandLine); result.GetSuggestions(commandLine.Length + 1) .Should() .BeEquivalentTo("rye", "sourdough", "wheat"); commandLine = "--bread wheat --cheese "; result = parser.Parse(commandLine); result.GetSuggestions(commandLine.Length + 1) .Should() .BeEquivalentTo("cheddar", "cream cheese", "provolone"); }
public static RootCommand RootCommand() { RootCommand command = new RootCommand(); command.AddOption(new Option <FileInfo[]>(new[] { "--in", "-i" }, "Input file(s) to dump. Expects them to by ReadyToRun images")); command.AddOption(new Option <FileInfo>(new[] { "--out", "-o" }, "Output file path. Dumps everything to the specified file except for help message and exception messages")); command.AddOption(new Option <bool>(new[] { "--raw" }, "Dump the raw bytes of each section or runtime function")); command.AddOption(new Option <bool>(new[] { "--header" }, "Dump R2R header")); command.AddOption(new Option <bool>(new[] { "--disasm", "-d" }, "Show disassembly of methods or runtime functions")); command.AddOption(new Option <bool>(new[] { "--naked" }, "Naked dump suppresses most compilation details like placement addresses")); command.AddOption(new Option <bool>(new[] { "--hide-offsets", "--ho" }, "Hide offsets in naked disassembly")); command.AddOption(new Option <string[]>(new[] { "--query", "-q" }, "Query method by exact name, signature, row ID or token")); command.AddOption(new Option <string[]>(new[] { "--keyword", "-k" }, "Search method by keyword")); command.AddOption(new Option <string[]>(new[] { "--runtimefunction", "-f" }, "Get one runtime function by id or relative virtual address")); command.AddOption(new Option <string[]>(new[] { "--section", "-s" }, "Get section by keyword")); command.AddOption(new Option <bool>(new[] { "--unwind" }, "Dump unwindInfo")); command.AddOption(new Option <bool>(new[] { "--gc" }, "Dump gcInfo and slot table")); command.AddOption(new Option <bool>(new[] { "--pgo" }, "Dump embedded pgo instrumentation data")); command.AddOption(new Option <bool>(new[] { "--sectionContents", "--sc" }, "Dump section contents")); command.AddOption(new Option <bool>(new[] { "--entrypoints", "-e" }, "Dump list of method / instance entrypoints in the R2R file")); command.AddOption(new Option <bool>(new[] { "--normalize", "-n" }, "Normalize dump by sorting the various tables and methods (default = unsorted i.e. file order)")); command.AddOption(new Option <bool>(new[] { "--hide-transitions", "--ht" }, "Don't include GC transitions in disassembly output")); command.AddOption(new Option <bool>(new[] { "--verbose", "-v" }, "Dump disassembly, unwindInfo, gcInfo and sectionContents")); command.AddOption(new Option <bool>(new[] { "--diff" }, "Compare two R2R images")); command.AddOption(new Option <bool>(new[] { "--diff-hide-same-disasm" }, "In matching method diff dump, hide functions with identical disassembly")); command.AddOption(new Option <FileInfo[]>(new[] { "--reference", "-r" }, "Explicit reference assembly files")); command.AddOption(new Option <DirectoryInfo[]>(new[] { "--referencePath", "--rp" }, "Search paths for reference assemblies")); command.AddOption(new Option <bool>(new[] { "--inlineSignatureBinary", "--isb" }, "Embed binary signature into its textual representation")); command.AddOption(new Option <bool>(new[] { "--signatureBinary", "--sb" }, "Append signature binary to its textual representation")); command.AddOption(new Option <bool>(new[] { "--create-pdb" }, "Create PDB")); command.AddOption(new Option <string>(new[] { "--pdb-path" }, "PDB output path for --create-pdb")); command.AddOption(new Option <bool>(new[] { "--create-perfmap" }, "Create PerfMap")); command.AddOption(new Option <string>(new[] { "--perfmap-path" }, "PerfMap output path for --create-perfmap")); command.AddOption(new Option <int>(new[] { "--perfmap-format-version" }, "PerfMap format version for --create-perfmap")); return(command); }
internal static async Task <int> MultipleArgs() { #region MultipleArgs var command = new RootCommand { new Option <string>("--a-string"), new Option <int>("--an-int") }; command.Handler = CommandHandler.Create( (string aString, int anInt) => { Console.WriteLine($"{aString}"); Console.WriteLine($"{anInt}"); } ); await command.InvokeAsync("--an-int 123 --a-string \"Hello world!\" "); #endregion return(0); }
public void When_a_subcommand_has_been_specified_then_its_sibling_commands_will_not_be_suggested() { var rootCommand = new RootCommand { new Command("apple") { new Option("--cortland") }, new Command("banana") { new Option("--cavendish") }, new Command("cherry") { new Option("--rainier") } }; var result = rootCommand.Parse("cherry "); result.GetSuggestions() .Should() .NotContain(new[] { "apple", "banana", "cherry" }); }
public static void UseHost_binds_parsed_arguments_to_options() { const int myValue = 4224; string commandLine = $"-{nameof(MyOptions.MyArgument)} {myValue}"; MyOptions options = null; var rootCmd = new RootCommand(); rootCmd.AddOption( new Option($"-{nameof(MyOptions.MyArgument)}") { Argument = new Argument <int>() } ); rootCmd.Handler = CommandHandler.Create((IHost host) => { options = host.Services .GetRequiredService <IOptions <MyOptions> >() .Value; }); int result = new CommandLineBuilder(rootCmd) .UseHost(host => { host.ConfigureServices(services => { services.AddOptions <MyOptions>().BindCommandLine(); }); }) .Build() .Invoke(commandLine); Assert.Equal(0, result); Assert.NotNull(options); Assert.Equal(myValue, options.MyArgument); }
public void Default_values_from_options_with_the_same_type_are_bound_and_use_their_own_defaults() { int first = 0, second = 0; var rootCommand = new RootCommand { new Option <int>("one", () => 1), new Option <int>("two", () => 2) }; rootCommand.Handler = CommandHandler.Create <int, int>((one, two) => { first = one; second = two; }); var parser = new CommandLineBuilder(rootCommand) .Build(); parser.Invoke(""); first.Should().Be(1); second.Should().Be(2); }
public static int Main(string[] args) { var rootcmd = new RootCommand("Audiobookbuilder") { new Option <DirectoryInfo>("--d", () => new DirectoryInfo(Directory.GetCurrentDirectory()), "directory"), new Option <bool>("--r", "Create audiobooks recursivly") }; rootcmd.Handler = CommandHandler.Create <DirectoryInfo, bool>((d, r) => { var folders = new List <DirectoryInfo>(); if (r) { folders.AddRange(d.EnumerateDirectories("*", SearchOption.AllDirectories)); } else { folders.Add(d); } Parallel.ForEach(folders, folder => { Console.WriteLine($"Begin Convert {folder.Name}"); var result = AudioConverter.Convert(folder); if (result == null) { Console.WriteLine($"Nothing to do for folder: {folder.Name}"); } else { Console.WriteLine($"Convert Done for: {folder.Name} Created File {result.Name}"); } }); }); return(rootcmd.InvokeAsync(args).Result); }
/// <summary> /// Some useful tools for writers /// /// </summary> public static int Main(string[] args) { var rootOption = new Option("--root", "The location of the project folder. Defaults to current directory.") { Argument = new Argument <string>(getDefaultValue: () => Directory.GetCurrentDirectory()) }; var verboseOption = new Option("--verbose", "wtk tries to be silent unless you're in verbose mode.") { Argument = new Argument <bool>(getDefaultValue: () => false) }; var rootCommand = new RootCommand("A bunch of useful writing tools"); rootCommand.AddOption(rootOption); rootCommand.AddOption(verboseOption); rootCommand.AddCommand(Init()); rootCommand.AddCommand(Count()); rootCommand.AddCommand(Compile()); rootCommand.AddCommand(Status()); rootCommand.AddCommand(Todo()); rootCommand.AddCommand(Config()); return(rootCommand.InvokeAsync(args).Result); }
/// <summary> /// Build the RootCommand for parsing /// </summary> /// <returns>RootCommand</returns> public static RootCommand BuildRootCommand() { RootCommand root = new RootCommand { Name = "helium", Description = "helium-csharp web app", TreatUnmatchedTokensAsErrors = true, }; // add options Option optKv = new Option <string>(new string[] { "-k", "--keyvault-name" }, "The name or URL of the Azure Keyvault") { Argument = new Argument <string>(), IsRequired = true, }; optKv.AddValidator(v => { if (v.Tokens == null || v.Tokens.Count != 1 || !KeyVaultHelper.ValidateName(v.Tokens[0].Value)) { return("--keyvault-name must be 3-20 characters [a-z][0-9]"); } return(string.Empty); }); // add the options root.AddOption(optKv); root.AddOption(new Option <AuthenticationType>(new string[] { "-a", "--auth-type" }, "Authentication type (Release builds require MI; Debug builds support all 3 options)")); root.AddOption(new Option <LogLevel>(new string[] { "-l", "--log-level" }, "Log Level")); root.AddOption(new Option(new string[] { "-d", "--dry-run" }, "Validates configuration")); return(root); }
public static int Main(string[] args) { RootCommand rootCommand = new RootCommand(); Command build = new Command("build", "Builds a generic package with or without shortcuts from a directory") { new Option <string>("--binDir", "Directory to package"), new Option <string>("--mainBin", () => "FIND_BIN", "The applications main binary"), new Option <string>("--packageFile", "Directory to package"), new Option <string>("--postInstall", () => "", "Command(s) to run after installing the package (This will be pasted into the .bat AND .sh file)"), new Option <string>("--postRemove", () => "", "Command(s) to run after removing the package (This will be pasted into the .bat AND .sh file)"), new Option <bool>("--noLogo", "Disables the logo"), new Option <bool>("--noShortcuts", "When this is enabled the scripts will not generate a start-menu item"), new Option <bool>("--noWine", "This indicates that your program supports multiple platforms natively and doesn't require WINE") }; build.Handler = CommandHandler.Create((Action <string, string, string, string, string, bool, bool, bool>)Build); rootCommand.AddCommand(build); return(rootCommand.InvokeAsync(args).Result); }
public static CommandLineOptions Parse(string[] args) { var options = new CommandLineOptions(); var configurationReader = new ConfigurationReader(); var config = configurationReader.GetConfiguration(); options.Endpoint = config.Endpoint; options.LoginToken = config.LoginToken; var app = new CommandLineApplication { Name = "apollo", FullName = "Apollo CommandLine Interface" }; app.HelpOption("-h|--help"); var verboseSwitch = app.Option("--verbose", "Verbose Output", CommandOptionType.NoValue); var requestSwitch = app.Option("--showRequest", "Write request object to stdout", CommandOptionType.NoValue); var fullResultSwitch = app.Option("--fullResults", "Display full result object and not just command result", CommandOptionType.NoValue); RootCommand.Configure(app, options); var result = app.Execute(args); if (result != 0) { return(null); } options.Verbose = verboseSwitch.HasValue(); options.ShowRequest = requestSwitch.HasValue(); options.FullResults = fullResultSwitch.HasValue(); return(options); }
public void Parser_root_Options_can_be_specified_multiple_times_and_their_arguments_are_collated() { var animalsOption = new Option <string[]>(new[] { "-a", "--animals" }); var vegetablesOption = new Option <string[]>(new[] { "-v", "--vegetables" }); var parser = new RootCommand { animalsOption, vegetablesOption }; var result = parser.Parse("-a cat -v carrot -a dog"); result.FindResultFor(animalsOption) .Tokens .Select(t => t.Value) .Should() .BeEquivalentTo("cat", "dog"); result.FindResultFor(vegetablesOption) .Tokens .Select(t => t.Value) .Should() .BeEquivalentTo("carrot"); }
public static void Register(RootCommand rootCommand, string commandText, string className) { Command command = new(commandText); MethodInfo[] methods = Assembly.GetExecutingAssembly() .GetTypes() .Single(t => t.Name == className) .GetMethods() .Where(m => m.IsPublic && m.IsStatic) .ToArray(); foreach (var method in methods) { Command featureCommand = new(method.Name.ToLower()); featureCommand.SetHandler(() => { MethodInfo m = method; m.Invoke(null, null); }); command.AddCommand(featureCommand); } rootCommand.AddCommand(command); }
public Task <int> ExecuteAsync(string[] args) { var command = new RootCommand { new Option(new[] { "--str", "-s" }) { Argument = new Argument <string?>() }, new Option(new[] { "--int", "-i" }) { Argument = new Argument <int>() }, new Option(new[] { "--bool", "-b" }) { Argument = new Argument <bool>() } }; command.Handler = CommandHandler.Create( typeof(SystemCommandLineCommand).GetMethod(nameof(ExecuteHandler)) ! ); return(command.InvokeAsync(args)); }
public static void Main(string[] args) { if (!Oodle.Load()) { Console.Error.WriteLine("Failed to load any oodle libraries. Aborting"); return; } var rootCommand = new RootCommand { new ArchiveCommand(), new UnbundleCommand(), new UncookCommand(), new ImportCommand(), new PackCommand(), new ExportCommand(), new DumpCommand(), new CR2WCommand(), new HashCommand(), new OodleCommand(), new TweakCommand(), new SettingsCommand(), }; var parser = new CommandLineBuilder(rootCommand) .UseDefaults() .UseHost(GenericHost.CreateHostBuilder) .Build(); parser.Invoke(args); }
public void Should_three_full_line_string() { //Arrange var consoleManager = new FakeConsoleManager(); var console = new TestConsole(consoleManager); var command = new RootCommand(console); var commandEngine = new CommandEngine(command); Task.Run(() => { commandEngine.Start(new string[] { }); }).Wait(100); console.Output(new WriteEventArgs(new string('A', console.BufferWidth * (console.BufferHeight - 2)))); //Act console.Output(new WriteEventArgs(new string('B', 3 * console.BufferWidth))); //Assert Assert.That(consoleManager.LineOutput[0], Is.EqualTo(new string('A', consoleManager.BufferWidth))); Assert.That(consoleManager.LineOutput[consoleManager.BufferHeight - 5], Is.EqualTo(new string('A', consoleManager.BufferWidth))); Assert.That(consoleManager.LineOutput[consoleManager.BufferHeight - 4], Is.EqualTo(new string('B', console.BufferWidth))); Assert.That(consoleManager.LineOutput[consoleManager.BufferHeight - 3], Is.EqualTo(new string('B', console.BufferWidth))); Assert.That(consoleManager.LineOutput[consoleManager.BufferHeight - 2], Is.EqualTo(new string('B', console.BufferWidth))); //TODO: Fix on build server! Assert.That(consoleManager.LineOutput[consoleManager.BufferHeight - 1], Is.EqualTo("> ")); //TODO: Fix on build server! Assert.That(consoleManager.CursorTop, Is.EqualTo(consoleManager.BufferHeight - 1)); //TODO: Fix on build server! Assert.That(consoleManager.CursorLeft, Is.EqualTo(2)); }
private static void Main(string[] args) { var cmd = new RootCommand(new HelixCommand()); cmd.Execute(args); }