public static async Task <int> Main(string[] args) { var command = new RootCommand(); command.Add(ScrapeCommand.Create()); command.Description = "Scrapes test results from AzDO, xUnit files, etc. and stores it in a database."; var builder = new CommandLineBuilder(command); builder.UseHelp(); builder.UseVersionOption(); builder.UseDebugDirective(); builder.UseParseErrorReporting(); builder.ParseResponseFileAs(ResponseFileHandling.ParseArgsAsSpaceSeparated); builder.UsePrefixes(new[] { "-", "--", }); // disable garbage windows conventions builder.CancelOnProcessTermination(); builder.UseExceptionHandler(HandleException); // Allow fancy drawing. builder.UseAnsiTerminalWhenAvailable(); var parser = builder.Build(); return(await parser.InvokeAsync(args)); }
public static Task <int> Main(string[] args) { var command = new RootCommand() { Description = "Developer tool to update the Visual Studio project versions." }; command.AddCommand(ListCommand.Create()); command.AddCommand(MajorCommand.Create()); command.AddCommand(MinorCommand.Create()); command.AddCommand(PatchCommand.Create()); command.AddCommand(BuildCommand.Create()); command.AddCommand(PreCommand.Create()); command.AddCommand(SetCommand.Create()); var builder = new CommandLineBuilder(command) .UseHelp() .UseDefaults() .UseVersionOption() .CancelOnProcessTermination() .UseExceptionHandler(); var parser = builder.Build(); return(parser.InvokeAsync(args)); }
public virtual int ProcessCommandLine() { var buildState = AppHostBuilder.BuildState; var arguments = buildState.ParsableArguments(); var console = Plugins.GetRequiredService <IConsole>(); // Creating & configuring CLI builder CliBuilder = new CommandLineBuilder().UseDefaults(); ConfigureCliBuilder(); // Letting other CLI plugins to kick in CliBuilder.UsePlugins <ICliPlugin>(Plugins); // Building parser & parsing the arguments var cliParser = CliBuilder.Build(); var cliParseResult = cliParser.Parse(arguments); // Invoking commands var exitCode = cliParseResult.Invoke(console); var cliException = buildState.CliException; if (cliException != null) { ExceptionDispatchInfo.Throw(cliException); } return(exitCode); }
public static async Task <int> Main(string[] args) { var command = new RootCommand() { Description = "Developer tools and publishing for microservices.", }; // 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(await parser.InvokeAsync(args)); }
static async Task <int> Main(string[] args) { var builder = new CommandLineBuilder() .UseHost(host => { host.ConfigureServices((context, services) => { // services.AddTransient(typeof(ILoggerFactory), typeof(LoggerFactory)); // services.AddTransient(typeof(ILogger<>), typeof(Logger<>)); services.AddLogging(logging => logging .AddConsole() .AddDebug() .SetMinimumLevel(LogLevel.Trace)); }); }) .UseDebugDirective() .UseHelp() .UseTypoCorrections() .UseAttributedCommands() .UseSuggestDirective(); var parser = builder.Build(); var parseResult = parser.Parse("test -b -a \"parameter a\""); var invoke = await parseResult.InvokeAsync(); return(invoke); }
static CommandLine() { var commandLine = new CommandLineBuilder() .UseParseDirective() .UseHelp() .UseSuggestDirective() .UseParseErrorReporting() .UseExceptionHandler() .AddOption("--file", ".trx file(s) to parse", a => a.ExistingFilesOnly() .ParseArgumentsAs <FileInfo[]>()) .AddOption("--filter", "Only look at tests matching the filter. \"*\" can be used as a wildcard.", args => args.ExactlyOne()) .AddOption("--format", "The format for the output.", args => args.WithDefaultValue(() => OutputFormat.Summary) .ParseArgumentsAs <OutputFormat>()) .AddOption("--path", "Directory or directories to search for .trx files. Only the most recent .trx file in a given directory is used.", a => a.WithDefaultValue(Directory.GetCurrentDirectory) .ParseArgumentsAs <DirectoryInfo[]>()) .AddOption("--show-test-output", "For failed tests, display the output.", a => a.ParseArgumentsAs <bool>()); commandLine.Description = "A command line testing tool for .NET"; commandLine.OnExecute(typeof(CommandLine).GetMethod(nameof(InvokeAsync))); Parser = commandLine.Build(); }
private void StartProcess() { var processStartInfo = new ProcessStartInfo($@"""{Path.Combine(JavaHome.FullName, "bin/java.exe")}""") { UseShellExecute = false, Arguments = _commandLineBuilder.Build(_parameters), WindowStyle = ProcessWindowStyle.Maximized, CreateNoWindow = true, LoadUserProfile = false, WorkingDirectory = ElasticsearchHome.FullName, RedirectStandardError = true, RedirectStandardOutput = true, StandardOutputEncoding = Encoding.ASCII, }; _elasticSearchProcess = Process.Start(processStartInfo); if (null == _elasticSearchProcess) { throw new Exception("Fail to start elasticsearch"); } _elasticSearchProcess.ErrorDataReceived += (sender, eventargs) => Info(eventargs.Data); _elasticSearchProcess.OutputDataReceived += (sender, eventargs) => Info(eventargs.Data); _elasticSearchProcess.BeginOutputReadLine(); }
static async Task <int> Main(string[] args) { var command = new RootCommand(); command.Add(RunCommand(args)); command.Add(NewCommand()); command.Description = "Process manager and orchestrator for microservices."; var builder = new CommandLineBuilder(command); builder.UseHelp(); builder.UseVersionOption(); builder.UseDebugDirective(); builder.UseParseErrorReporting(); builder.ParseResponseFileAs(ResponseFileHandling.ParseArgsAsSpaceSeparated); builder.UsePrefixes(new[] { "-", "--", }); // disable garbage windows conventions builder.CancelOnProcessTermination(); builder.UseExceptionHandler(HandleException); // Allow fancy drawing. builder.UseAnsiTerminalWhenAvailable(); var parser = builder.Build(); return(await parser.InvokeAsync(args)); }
private Parser GetDirectiveParser() { if (_directiveParser == null) { var root = new RootCommand(); foreach (var c in _directiveCommands) { root.Add(c); } var commandLineBuilder = new CommandLineBuilder(root) .ParseResponseFileAs(ResponseFileHandling.Disabled) .UseMiddleware( context => context.BindingContext .AddService( typeof(KernelInvocationContext), () => KernelInvocationContext.Current)); commandLineBuilder.EnableDirectives = false; _directiveParser = commandLineBuilder.Build(); } return(_directiveParser); }
private Parser GetDirectiveParser() { if (_directiveParser == null) { EnsureRootCommandIsInitialized(); var commandLineBuilder = new CommandLineBuilder(_rootCommand) .ParseResponseFileAs(ResponseFileHandling.Disabled) .UseTypoCorrections() .UseHelpBuilder(bc => new HelpBuilderThatOmitsRootCommandName(bc.Console, _rootCommand.Name)) .UseHelp() .UseMiddleware( context => { context.BindingContext .AddService( typeof(KernelInvocationContext), _ => KernelInvocationContext.Current); }); commandLineBuilder.EnableDirectives = false; _directiveParser = commandLineBuilder.Build(); } return(_directiveParser); }
public static async Task <int> Main(string[] args) { var command = new RootCommand { Commands.Deploy.Command(), // ...add more commands here }; command.Name = "clud"; command.Description = "clud deployment tool"; // Show commandline help unless a sub-command was used. command.Handler = CommandHandler.Create <IHelpBuilder>(help => { ConsoleHelpers.PrintLogo(); 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(await parser.InvokeAsync(args)); }
public static async Task <int> Main(string [] args) { var rootCommand = MsIdentityCommand(); var listAadAppsCommand = ListAADAppsCommand(); var listServicePrincipalsCommand = ListServicePrincipalsCommand(); var provisionApplicationCommand = ProvisionApplicationCommand(); listAadAppsCommand.Handler = CommandHandler.Create <ProvisioningToolOptions>(HandleListApps); listServicePrincipalsCommand.Handler = CommandHandler.Create <ProvisioningToolOptions>(HandleListServicePrincipals); provisionApplicationCommand.Handler = CommandHandler.Create <ProvisioningToolOptions>(HandleProvisionApplication); rootCommand.AddCommand(listAadAppsCommand); rootCommand.AddCommand(listServicePrincipalsCommand); rootCommand.AddCommand(provisionApplicationCommand); if (args == null || args.Length == 0) { args = new string[] { "-h" }; } var commandLineBuilder = new CommandLineBuilder(rootCommand); commandLineBuilder.UseDefaults(); var parser = commandLineBuilder.Build(); return(await parser.InvokeAsync(args)); }
/// <summary> /// Create an instance of the command processor; /// </summary> /// <param name="serviceProvider">service provider interface</param> /// <param name="console">console instance</param> /// <param name="assemblies">Optional list of assemblies to look for commands</param> /// <param name="types">Optional list of types to look for commands</param> public CommandProcessor(IServiceProvider serviceProvider, IConsole console, IEnumerable <Assembly> assemblies = null, IEnumerable <Type> types = null) { Debug.Assert(serviceProvider != null); Debug.Assert(assemblies != null); _serviceProvider = serviceProvider; _console = console; var rootBuilder = new CommandLineBuilder(new Command(">")); rootBuilder.UseHelp() .UseHelpBuilder((bindingContext) => GetService <IHelpBuilder>()) .UseParseDirective() .UseSuggestDirective() .UseParseErrorReporting() .UseExceptionHandler(); if (assemblies != null) { BuildCommands(rootBuilder, assemblies); } if (types != null) { BuildCommands(rootBuilder, types); } _rootCommand = rootBuilder.Command; _parser = rootBuilder.Build(); }
public static async Task <int> Main(string[] args) { CommandLineBuilder commandLineBuilder = CreateCommandLineBuilder(); Parser parser = commandLineBuilder.Build(); return(await parser.InvokeAsync(args)); }
private static Parser BuildParser(MethodInfo method, string xmlDocsFilePath, object target) { var builder = new CommandLineBuilder() .ConfigureRootCommandFromMethod(method, target) .ConfigureHelpFromXmlComments(method, xmlDocsFilePath) .UseDefaults() .UseAnsiTerminalWhenAvailable(); return(builder.Build()); }
internal static async Task <int> RunEngine(CommandLineBuilder hostBuilder) { var args = Environment.GetCommandLineArgs(); if (args.Length == 0) { AnsiConsole.MarkupLine("[bold red]Loadit.dev[/]"); } return(await hostBuilder.Build().InvokeAsync(args)); }
public void Can_add_argument() { ////Arrange var builder = new CommandLineBuilder(); ////Act var result = builder.Build(new Example {Argument = "tester"}); ////Assert Assert.That(result, Is.EqualTo(" -Des.index.gateway.type=tester")); }
public void Global_options_are_added_to_the_root_command() { var globalOption = new Option("global"); var builder = new CommandLineBuilder().AddGlobalOption(globalOption); Parser parser = builder.Build(); Command rootCommand = (Command)parser.Configuration.RootCommand; rootCommand.GlobalOptions.Should().Contain(globalOption); }
public static async Task <int> Main(string[] args) { var rootCommand = NupkgInfo(); rootCommand.Handler = CommandHandler.Create <ToolOptions>(HandleNupkgInfo); var commandLineBuilder = new CommandLineBuilder(rootCommand); commandLineBuilder.UseDefaults(); var parser = commandLineBuilder.Build(); return(await parser.InvokeAsync(args)); }
internal static Parser CreateParser(Command command, bool disableHelp = false) { var builder = new CommandLineBuilder(command) .UseParseDirective() .UseSuggestDirective() .EnablePosixBundling(false); if (!disableHelp) { builder = builder.UseHelp(); } return(builder.Build()); }
public static async Task <int> Main(string[] args, IConsole console = null) { var rpCommand = new RootCommand("Interact with Report Portal API"); AddConnectCommand(rpCommand); AddLaunchCommand(rpCommand); var b = new CommandLineBuilder(rpCommand) .UseDefaults(); var parser = b.Build(); return(await parser.InvokeAsync(args, console)); }
/// <summary> /// Create an instance of the command processor; /// </summary> /// <param name="assemblies">The list of assemblies to look for commands</param> public CommandProcessor(IEnumerable <Assembly> assemblies) { var rootBuilder = new CommandLineBuilder(); rootBuilder.UseHelp() .UseParseDirective() .UseSuggestDirective() .UseParseErrorReporting() .UseExceptionHandler(); BuildCommands(rootBuilder, assemblies); _rootCommand = rootBuilder.Command; _parser = rootBuilder.Build(); }
public void Can_add_argument() { ////Arrange var builder = new CommandLineBuilder(); ////Act var result = builder.Build(new Example { Argument = "tester" }); ////Assert Assert.That(result, Is.EqualTo(" -Des.index.gateway.type=tester")); }
public static Task <int> Main(string[] args) { var root = new RootCommand(); root.Handler = CommandHandler.Create <IConsole, IHelpBuilder>((console, help) => { // looks a bit gross but avoids a newline console.Out.Write(@" _____ __ __ _ / ___/_____/ /_ ___ ____ ___ ____ _/ /_(_)____ \__ \/ ___/ __ \/ _ \/ __ `__ \/ __ `/ __/ / ___/ ___/ / /__/ / / / __/ / / / / / /_/ / /_/ / /__ /____/\___/_/ /_/\___/_/ /_/ /_/\__,_/\__/_/\___/ The helpful database schema querying tool. "); help.Write(root); return(1); }); var configFileOption = new Option <FileInfo>( "--config", getDefaultValue: () => new FileInfo( Path.Combine(Directory.GetCurrentDirectory(), "schematic.config.json" )), description: "A path to a configuration file used to retrieve options such as connection strings." ).ExistingOnly(); root.AddGlobalOption(configFileOption); root.AddCommand(new OrmCommand()); root.AddCommand(new LintCommand()); root.AddCommand(new ReportCommand()); root.AddCommand(new TestCommand()); var builder = new CommandLineBuilder(root); 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)); }
/* * dotnet scaffold [generator] [-p|--project] [-n|--nuget-package-dir] [-c|--configuration] [-tfm|--target-framework] [-b|--build-base-path] [--no-build] * * This commands supports the following generators : * Area * Controller * Identity * Razorpage * View * * e.g: dotnet scaffold area <AreaNameToGenerate> * dotnet scaffold identity * dotnet scaffold razorpage * */ public static int Main(string[] args) { var rootCommand = ScaffoldCommand(); rootCommand.AddCommand(ScaffoldAreaCommand()); rootCommand.AddCommand(ScaffoldControllerCommand()); rootCommand.AddCommand(ScaffoldRazorPageCommand()); rootCommand.AddCommand(ScaffoldViewCommand()); rootCommand.AddCommand(ScaffoldIdentityCommand()); rootCommand.Description = "dotnet scaffold [command] [-p|--project] [-n|--nuget-package-dir] [-c|--configuration] [-tfm|--target-framework] [-b|--build-base-path] [--no-build] "; if (args.Length == 0) { args = new string[] { "-h" }; } var commandLineBuilder = new CommandLineBuilder(rootCommand); commandLineBuilder.UseDefaults(); var parser = commandLineBuilder.Build(); int parseExitCode = parser.Invoke(args); if (parseExitCode != 0) { return(parseExitCode); } ParseResult parseResult = parser.Parse(args); string parsedCommandName = parseResult.CommandResult.Command.Name; switch (parsedCommandName) { case AREA_COMMAND: case CONTROLLER_COMMAND: case IDENTITY_COMMAND: case RAZORPAGE_COMMAND: case VIEW_COMMAND: if (parseResult.CommandResult.Children.Count == 1 && string.Equals(parseResult.CommandResult.Children[0].Symbol?.Name, "help", StringComparison.OrdinalIgnoreCase)) { // The help option for the commands are handled by System.Commandline. return(0); } return(VisualStudio.Web.CodeGeneration.Tools.Program.Main(args)); default: // The command is not handled by 'dotnet scaffold'. return(-1); } }
/// <summary> /// Composes the <see cref="IServiceCollection"/> with <see cref="ConfigureServices"/> and /// builds a new <see cref="CommandLineBuilder"/> which is configured by calling all /// <see cref="ConfigureCommandLine"/>. /// </summary> /// <returns>A new <see cref="Parser"/> instance.</returns> public Parser Build() { var services = ComposeServiceCollection(); var builder = new CommandLineBuilder(this._rootCommand) .UseAffectedCli(new StartupData(services)); foreach (var callback in _configureCommandLine) { callback.Invoke(builder); } return(builder.Build()); }
static async Task Main(string[] args) { var command = new RootCommand("Run a .NET Framework website in IIS") { new Argument <DirectoryInfo?>(CLIHelper.ParsePath <DirectoryInfo>) { Arity = ArgumentArity.ExactlyOne, Description = "The relative or absolute path to the .NET Framework project directory", Name = "path", }, new Argument <DirectoryInfo?>(CLIHelper.ParsePath <DirectoryInfo>) { Arity = ArgumentArity.ZeroOrOne, Description = "The relative or absolute path to the solution directory", Name = "solutionPath" }, new Option("--no-build", "Do not build the website before launching it"), new Option("--name", "The name of the website") { Argument = new Argument <string>("name") }, new Option("--port", "The port that the website should listen on") { Argument = new Argument <int>("port") } }; command.Handler = CommandHandler.Create <CommandArguments>(async arg => { if (string.IsNullOrEmpty(arg.Path?.FullName)) { throw new Exception("Argument 'path' is required."); } var environmentVariables = EnvironmentHelper.LoadEnvironmentVariables(); await using var iisHost = new IISHost(environmentVariables); await iisHost.Run(arg.Console, arg, arg.Token); }); var builder = new CommandLineBuilder(command); builder.UseHelp(); builder.UseDebugDirective(); builder.UseExceptionHandler(CLIHelper.HandleException); builder.CancelOnProcessTermination(); var parser = builder.Build(); await parser.InvokeAsync(args); }
public static async Task <int> InvokeMethodAsync( string[] args, IConsole console, MethodInfo method, object @object) { var builder = new CommandLineBuilder() .ConfigureFromMethod(method, @object) .ConfigureHelpFromXmlComments(method) .UseDefaults(); Parser parser = builder.Build(); return(await parser.InvokeAsync(args, console)); }
internal static Parser CreateParser(Command command, bool disableHelp = false) { var builder = new CommandLineBuilder(command) .UseParseErrorReporting() //TODO: decide if it's needed to implement it; and implement if needed //.UseParseDirective() //.UseSuggestDirective() .EnablePosixBundling(false); if (!disableHelp) { builder = builder.UseHelp(); } return(builder.Build()); }
public static async Task <int> InvokeMethodAsync( string[] args, MethodInfo method, object target = null, IConsole console = null) { var builder = new CommandLineBuilder() .ConfigureRootCommandFromMethod(method, target) .ConfigureHelpFromXmlComments(method) .UseDefaults() .UseAnsiTerminalWhenAvailable(); Parser parser = builder.Build(); return(await parser.InvokeAsync(args, console)); }
/// <summary> /// Configures the cli. /// </summary> /// <param name="configurationBuilder">The configuration builder.</param> public void ConfigureCli(IConfigurationBuilder configurationBuilder) { var rocketHostBuilder = RocketHostExtensions.GetConventionalHostBuilder(_hostBuilder); var clb = new CommandLineBuilder( rocketHostBuilder.Scanner, rocketHostBuilder.AssemblyProvider, rocketHostBuilder.AssemblyCandidateFinder, rocketHostBuilder.Logger, rocketHostBuilder.Properties ); _exec = clb.Build().Parse(_args ?? Array.Empty <string>()); _args = _exec.ApplicationState.RemainingArguments ?? Array.Empty <string>(); configurationBuilder.AddApplicationState(_exec.ApplicationState); rocketHostBuilder.Properties.Add(typeof(ICommandLineExecutor), _exec); }