static async Task Main(string[] args) { var services = ConfigureServices(); var options = new CommandLineParserOptions { AppName = "UsersManagementApp.exe" }; var parser = new CommandLineParser <GlobalOptions>(options, services); parser.DiscoverCommands(Assembly.GetExecutingAssembly()); parser.UseFluentValidations(config => { config.AddValidator <RegisterOptions, RegisterValidator>(); }); var result = await parser.ParseAsync(args); if (result.HasErrors) { return; } if (result.Result.Verbose) { Console.WriteLine("Verbose specified!"); } }
static async Task Main(string[] args) { var options = new CommandLineParserOptions { AppName = "cra" }; var parser = new CommandLineParser <ProgramOptions>(); var result = parser.Parse(args); var programOptions = result.Result; projectName = programOptions.Name; Console.WriteLine(projectName); Console.WriteLine("Location:" + location); string repoURL = @"https://github.com/lazyDefender/cra"; CloneRepo($"{repoURL}.git"); Directory.Move($@"{location}/cra", $@"{location}/{projectName}"); RepoRemoveRemote($"origin"); CreateRepo(projectName); string gitUsername = GetGitUsername(); string newUrl = $@"https://github.com/{gitUsername}/{projectName}.git"; RepoSetRemote(newUrl); RepoPush(); }
/// <summary> /// Constructor. /// </summary> /// <param name="argSet">Argument set to create parser for.</param> /// <param name="options">Parser options.</param> public ArgumentSetParser(ArgumentSetDefinition argSet, CommandLineParserOptions options) { if (argSet == null) { throw new ArgumentNullException(nameof(argSet)); } // Clone the argument set definition, as parsing may mutate it. ArgumentSet = argSet.DeepClone(); // Save off the options provided; if none were provided, construct some quiet defaults. _options = options?.DeepClone() ?? CommandLineParserOptions.Quiet(); // If no reporter was provided, use a no-op one. if (_options.Reporter == null) { _options.Reporter = err => { }; } // If no file-system reader was provided, use our default implementation. if (_options.FileSystemReader == null) { _options.FileSystemReader = FileSystemReader.Create(); } }
/// <summary> /// Executes one iteration of the loop. /// </summary> /// <returns>The result of executing.</returns> public CommandResult ExecuteOnce() { Client.DisplayPrompt(); var args = ReadInput(); if (args == null) { return(CommandResult.Terminate); } if (args.Length == 0) { return(CommandResult.Success); } var options = new CommandLineParserOptions { Reporter = error => Client.OnError(error.ToString().TrimEnd()) }; var commandGroup = new CommandGroup <TCommandType>(); if (!CommandLineParser.Parse(args, commandGroup, options)) { Client.OnError(Strings.InvalidUsage); return(CommandResult.UsageError); } return(commandGroup.Execute()); }
public void TestSplitOnPostFixWorksCorrectly() { var settings = new CommandLineParserOptions(); var mockTestOption1 = CreateMock(settings, "test").Object; var mockTestOption2 = CreateMock(settings, "test2", "test2").Object; var mockTestOption3 = CreateMock(settings, "test3").Object; var mockTestOption4 = CreateMock(settings, "blabla", "blabla").Object; var options = new[] { mockTestOption1, mockTestOption2, mockTestOption3, mockTestOption4 }; var input = new[] { "--test=1", "-test2=\"some value\"", "--test3=some value", "-blabla", "third" }; var output = input.SplitOnPostfix(settings, options).ToArray(); Assert.Equal("--test", output[0]); Assert.Equal("1", output[1]); Assert.Equal("-test2", output[2]); Assert.Equal("\"some value\"", output[3]); Assert.Equal("--test3", output[4]); Assert.Equal("some value", output[5]); Assert.Equal("-blabla", output[6]); Assert.Equal("third", output[7]); }
public CommandLineCommand(CommandLineParserOptions parserOptions, IArgumentResolverFactory resolverFactory, IContainerResolver containerResolver, TOption option) { m_parserOptions = parserOptions; m_commandOption = new TCommandOption(); m_containerResolver = containerResolver; m_resolverFactory = resolverFactory; m_baseOption = option; if (m_parserOptions.EnableHelpOption) { var tokens = m_parserOptions.HelpOptionName.Split('|'); if (tokens.Length > 1) { m_helpOptionName = $"{m_parserOptions.PrefixShortOption}{tokens[0]}"; m_helpOptionNameLong = $"{m_parserOptions.PrefixLongOption}{tokens[1]}"; } else { m_helpOptionName = $"{m_parserOptions.PrefixLongOption}{tokens[0]}"; m_helpOptionNameLong = null; } } InitialzeModel(); }
public UsagePrinter(CommandLineParserOptions parserOptions, ICommandLineCommandContainer container, IUsageBuilder builder) { m_parserOptions = parserOptions; m_commandContainer = container; m_usageBuilder = builder; }
private static ExecutionParams GetExecutionParams(string[] args) { var options = new CommandLineParserOptions() { AppName = "Stone Test - Crawler", AutoPrintUsageAndErrors = true, EnableHelpOption = true }; var parser = new CommandLineParser <ExecutionParams>(options); var parameters = parser.Parse(args); if (parameters.HasErrors) { Console.WriteLine($"The command line has {parameters.Errors.Count} erros..."); return(null); } return(parameters.Result); //try //{ // try { parameters.DestinyFilePath = args[0].ToString(); } catch { Console.WriteLine($"The mandatory parameter: \"File path\" has missed.");Console.ReadKey();throw; } // try { parameters.BufferLimit = Convert.ToInt32(args[1]);}catch { return parameters; } // try { parameters.FileSizeLimit = Convert.ToInt32(args[2]); } catch { return parameters; } // try { parameters.HeadLessModeActivated = Convert.ToInt32(args[3]) ==0?false:true; } catch { return parameters; } // return parameters; //} //catch (Exception) //{ // Console.WriteLine("The mandatory file path parameter not specified. Example: \"C:\\temp\""); // Console.ReadKey(); // throw; //} }
public CommandLineOptionBase(CommandLineParserOptions parserOptions, object source, LambdaExpression selector, IArgumentResolverFactory resolver) { m_parserOptions = parserOptions ?? throw new ArgumentNullException(nameof(source)); m_source = source ?? throw new ArgumentNullException(nameof(source)); m_selector = selector ?? throw new ArgumentNullException(nameof(selector)); m_resolverFactory = resolver ?? throw new ArgumentNullException(nameof(resolver)); }
public CommandLineParser(Type commandType, CommandLineParserOptions parserOptions = CommandLineParserOptions.NONE) { _parserOptions = parserOptions; _options = new OptionGroupParser(commandType); _arguments = (from x in from p in commandType.GetProperties() select new { Property = p, Attribute = p.GetCustomAttribute <ArgumentsAttribute>() } where x.Attribute != null select new Arguments(x.Property, x.Attribute)).FirstOrDefault(); _argumentsVerification = (from m in commandType.GetMethods() from a in m.GetCustomAttributes <ArgumentsVerificationAttribute>() select m).SingleOrDefault(); if (_argumentsVerification != null) { // Check the return and parameter types if (_argumentsVerification.ReturnType != typeof(void)) { throw new NotSupportedException("Arguments Verification method does not return void."); } if (_argumentsVerification.GetParameters().Length != 0) { throw new NotSupportedException("Arguments Verification method does not take parameters."); } } }
static int Main(string[] args) { Console.WriteLine("Parsing..."); // Set up help options the way we want them. var helpOptions = new ArgumentSetHelpOptions() .With() .BlankLinesBetweenArguments(1) .ShortNames(ArgumentShortNameHelpMode.IncludeWithLongName) .DefaultValues(ArgumentDefaultValueHelpMode.PrependToDescription) .TwoColumnLayout(); // Wrap help options in general parsing options. var options = new CommandLineParserOptions { HelpOptions = helpOptions }; // Try to parse. if (!CommandLineParser.TryParse(args, options, out ProgramArguments programArgs)) { return(1); } Console.WriteLine("Successfully parsed."); return(0); }
public async Task TestHelpOptionGetsParsedCorrectly(string helpOption, string[] args, bool fires) { bool calledFlag = false; var usagePrinterMock = new Mock <IUsagePrinter>(); usagePrinterMock.Setup(mock => mock.PrintUsage()).Callback(() => calledFlag = true); usagePrinterMock.Setup(mock => mock.PrintCommandUsage(It.IsAny <ICommandLineCommand>())).Callback(() => calledFlag = true); usagePrinterMock.Setup(mock => mock.PrintOptionUsage(It.IsAny <ICommandLineOption>())).Callback(() => calledFlag = true); Services.AddSingleton(usagePrinterMock.Object); var options = new CommandLineParserOptions { HelpOptionName = helpOption }; var parser = new CommandLineParser <Options>(options, Services); var cmd = parser.AddCommand <CommandOptions>() .Name("db") .Description("Database commands"); await parser.ParseAsync(args); Assert.Equal(fires, calledFlag); }
//Function name: ProcessCommandLineArguments //Function parameters => Return type: String[] => Void //Function Purpose: To handle passed in command line arguments public static Dictionary <string, string> ProcessComandLineArguments(string[] args) { Dictionary <string, string> arguments = new Dictionary <string, string>(); bool submittedJSON = false; var options = new CommandLineParserOptions { AppName = "HARPOCRATES", AutoPrintUsageAndErrors = true }; var parser = new CommandLineParser <CLIArgs>(options); var result = parser.Parse(args); if (result.HasErrors) { Console.Error.WriteLine("Error in command line arguments"); System.Environment.Exit(1); } if (result.Result.JSONProfile != null) { submittedJSON = true; if (args.Length > 2) { Console.Error.WriteLine("Too many arguments. If you are uploading a file. Only use -p command."); System.Environment.Exit(2); } } return(HandleJSON(submittedJSON, result.Result, arguments)); }
private static ArgumentDefinition CreateArgumentDescriptor( IMutableMemberInfo member, ArgumentBaseAttribute attribute, object defaultValues, ArgumentSetAttribute setAttribute, CommandLineParserOptions options, object fixedDestination) { if (!member.IsReadable || !member.IsWritable) { var declaringType = member.MemberInfo.DeclaringType; throw new InvalidArgumentSetException(member, string.Format( CultureInfo.CurrentCulture, Strings.MemberNotSupported, member.MemberInfo.Name, declaringType?.Name)); } var defaultFieldValue = (defaultValues != null) ? member.GetValue(defaultValues) : null; return(new ArgumentDefinition(member, attribute, setAttribute, options, defaultFieldValue, fixedDestination: fixedDestination)); }
/// <summary> /// Constructs an argument set from a type with reflection-based argument attributes. /// </summary> /// <param name="type">The type.</param> /// <param name="defaultValues">Optionally provides an object with default values.</param> /// <param name="options">Optionally provides additional options /// controlling how parsing proceeds.</param> public ArgumentSetDefinition(Type type, object defaultValues = null, CommandLineParserOptions options = null) : // Try to grab attributes from type. this(options, type.GetTypeInfo().GetSingleAttribute <ArgumentSetAttribute>()) { // Scan the provided type for argument definitions. AddArgumentsFromTypeWithAttributes(type, defaultValues); }
public static void ParseCommand(string[] args) { var options = new CommandLineParserOptions { AppName = "TCP Tracker", }; var parser = new CommandLineParser <ScriptOptions>(options); var result = parser.Parse(args); if (result.HasErrors) { ParseCommand(Console.ReadLine().Split(" ")); return; } var programOptions = result.Result; //RunCommand(); commandLocation = programOptions.commandLocation; outputLocation = programOptions.outputLocation; ip = programOptions.IpAdress; var timer = new Timer(test, null, 0, programOptions.time * 1000 * 60); Console.Read(); }
public void CommandLineParserUsesCorrectOptions() { var opt = new CommandLineParserOptions(); var parser = new CommandLineParser(opt); Assert.Equal(opt, parser.ParserOptions); }
public void TestThatRequiredPropertiesArePresentInQuietOptions() { var options = CommandLineParserOptions.Quiet(); options.HelpOptions.Should().NotBeNull(); options.Reporter.Should().NotBeNull(); options.FileSystemReader.Should().NotBeNull(); }
public CommandLineOptionBase(CommandLineParserOptions parserOptions, object source, LambdaExpression selector, ICommandLineArgumentResolver resolver, ILogger logger) { m_parserOptions = parserOptions ?? throw new ArgumentNullException(nameof(source)); m_source = source ?? throw new ArgumentNullException(nameof(source)); m_selector = selector ?? throw new ArgumentNullException(nameof(selector)); Resolver = resolver ?? throw new ArgumentNullException(nameof(resolver)); this.logger = logger ?? throw new ArgumentNullException(nameof(logger)); }
/// <summary> /// Primary constructor. /// </summary> /// <param name="member">Field to describe.</param> /// <param name="attribute">Argument attribute on the field.</param> /// <param name="setAttribute">Attribute on the containing argument set.</param> /// <param name="options">Provides parser options.</param> /// <param name="defaultFieldValue">Default value for the field.</param> /// <param name="parentMember">Parent member under which this field sits.</param> /// <param name="fixedDestination">Optionally provides fixed parse destination object.</param> public ArgumentDefinition(IMutableMemberInfo member, ArgumentBaseAttribute attribute, ArgumentSetAttribute setAttribute, CommandLineParserOptions options, object defaultFieldValue = null, IMutableMemberInfo parentMember = null, object fixedDestination = null) { Debug.Assert(attribute != null); Debug.Assert(member != null); Member = member; ParentMember = parentMember; Attribute = attribute; _setAttribute = setAttribute; FixedDestination = fixedDestination; _isPositional = attribute is PositionalArgumentAttribute; _reporter = options?.Reporter ?? (s => { }); ArgumentType = Attribute.GetArgumentType(member.MemberType); _collectionArgType = AsCollectionType(ArgumentType); HasDefaultValue = attribute.ExplicitDefaultValue || attribute.DynamicDefaultValue; _validationAttributes = GetValidationAttributes(ArgumentType, Member); _argumentParseContext = CreateParseContext(attribute, _setAttribute, options); LongName = GetLongName(attribute, setAttribute, member.MemberInfo); ExplicitShortName = HasExplicitShortName(attribute); ShortName = GetShortName(attribute, setAttribute, member.MemberInfo); DefaultValue = GetDefaultValue(attribute, member, defaultFieldValue); var nullableBase = Nullable.GetUnderlyingType(member.MemberType); if (_collectionArgType != null) { _collectionValues = new ArrayList(); _valueType = _collectionArgType.ElementType; } else if (nullableBase != null) { // For nullable arguments, we use the wrapped type (T in // Nullable<T>) as the value type. Parsing an enum or int is the // same as parsing an enum? or int?, for example, since null can // only arise if the value was not provided at all. _valueType = Attribute.GetArgumentType(nullableBase); } else { _valueType = ArgumentType; } Debug.Assert(_valueType != null); if (Unique && !IsCollection) { throw new InvalidArgumentSetException(member, Strings.UniqueUsedOnNonCollectionArgument); } Debug.Assert(!string.IsNullOrEmpty(LongName)); }
public void InvalidOptionsThrowException(string shortOption, string longOption) { var options = new CommandLineParserOptions { PrefixShortOption = shortOption, PrefixLongOption = longOption }; Assert.Throws <ArgumentException>(() => new CommandLineParser(options, Services)); Assert.Throws <ArgumentException>(() => new CommandLineParser <OrderModel>(options, Services)); }
/// <summary> /// Checks if the empty string is a valid value for this argument. /// </summary> /// <param name="parserOptions">Parser options.</param> /// <returns>true if it is valid; false otherwise.</returns> internal bool IsEmptyStringValid(CommandLineParserOptions parserOptions) { var options = parserOptions.DeepClone().With().Quiet().Apply(); var parseState = new ArgumentParser(ContainingSet, this, options, /*destination=*/ null); return(ArgumentType.TryParse(parseState.ParseContext, string.Empty, out object parsedEmptyString) && parseState.TryValidateValue( parsedEmptyString, new ArgumentValidationContext(parseState.ParseContext.FileSystemReader), reportInvalidValue: false)); }
/// <summary> /// Constructs an empty argument set. /// </summary> /// <param name="options">Optionally provides additional options /// controlling how parsing proceeds.</param> /// <param name="setAttribute">Optionally provides attribute information /// describing the attribute set.</param> public ArgumentSetDefinition(CommandLineParserOptions options = null, ArgumentSetAttribute setAttribute = null) { // Save off the options provided; if none were provided, construct some defaults. _options = options?.Clone() ?? new CommandLineParserOptions(); // Save off set attributes; if none were provided, construct some defaults. Attribute = setAttribute ?? new ArgumentSetAttribute(); // Set up private fields dependent on the ArgumentSetAttribute. _namedArgumentsByName = new Dictionary <string, ArgumentDefinition>(StringComparerToUse); }
public void CustomInvokedPrinterWorksCorrectly(string[] args, bool cmdPassed, bool optPassed) { var builderMock = new Mock <IUsageBuilder>(); var parserOptions = new CommandLineParserOptions { AutoPrintUsageAndErrors = false }; Services.AddSingleton(builderMock.Object); Services.AddCommandLineParser <UsagePrinterGetsCalledOptions>(parserOptions); var parser = ResolveParser <UsagePrinterGetsCalledOptions>(); parser.AddCommand <UsagePrinterCommandOptions>() .Name("cmd") .Required(); var result = parser.Parse(args); builderMock.Verify(mock => mock.Build(), Times.Never()); builderMock.Verify(mock => mock.AddCommand(It.IsAny <string>(), It.IsAny <ICommandLineCommandContainer>()), Times.Never()); builderMock.Verify(mock => mock.AddOption(It.IsAny <ICommandLineOption>()), Times.Never()); if (result.HelpRequested) { parser.Printer.PrintUsage(result.HelpRequestedFor); } if (result.HasErrors) { foreach (var err in result.Errors) { if (!(err is BaseParserException baseParserException)) { continue; } parser.Printer.PrintUsage(baseParserException.Argument); } } builderMock.Verify( mock => mock.Build(), ToTimes(result.HelpRequested || result.HasErrors)); builderMock.Verify( mock => mock.AddCommand(It.IsAny <string>(), It.IsAny <ICommandLineCommand>()), ToTimes(cmdPassed)); builderMock.Verify( mock => mock.AddOption(It.IsAny <ICommandLineOption>()), ToTimes(optPassed)); }
static int Main(string[] args) { var cliParserOptions = new CommandLineParserOptions { AppName = "VCDiff.Core.Cli" }; var result = VCDiffResult.NOOP; var parser = new CommandLineParser <ProgramOptions>(); parser.AddCommand <CreateOptions>() .Name("create") .Required(false) .Description("Creates a delta patch from the given input") .OnExecuting((o, opt) => result = Create(opt)); parser.AddCommand <PatchOptions>() .Name("patch") .Required(false) .Description("Appplies the give patch to the file") .OnExecuting((o, opt) => result = Patch(opt)); var parserResult = parser.Parse(args); if (parserResult.HasErrors && !parserResult.HelpRequested) { result = VCDiffResult.Error; } switch (result) { case VCDiffResult.NOOP: parser.Printer.PrintUsage(); break; case VCDiffResult.Succes: default: break; case VCDiffResult.Error: Console.Error.WriteLine("Unexpected error occured"); return(-1); case VCDiffResult.EOD: Console.Error.WriteLine("Unexpected end of data"); return(-2); } return(0); }
public void CommandLinerParserPassesResolverCorreclty() { var resolverMock = new Mock <IArgumentResolverFactory>(); var options = new CommandLineParserOptions(); var parser = new CommandLineParser(resolverMock.Object); Assert.Equal(resolverMock.Object, parser.ArgumentResolverFactory); parser = new CommandLineParser(options, resolverMock.Object); Assert.Equal(resolverMock.Object, parser.ArgumentResolverFactory); Assert.Equal(options, parser.ParserOptions); }
public void CommandLinerParserPassesContainerCorreclty() { var containerResolver = new Mock <IContainerResolver>(); var options = new CommandLineParserOptions(); var parser = new CommandLineParser(containerResolver.Object); Assert.Equal(containerResolver.Object, parser.ContainerResolver); parser = new CommandLineParser(options, containerResolver.Object); Assert.Equal(containerResolver.Object, parser.ContainerResolver); Assert.Equal(options, parser.ParserOptions); }
/// <summary> /// Constructs a new stateful parser for the given argument. /// </summary> /// <param name="argSet">The argument set containing the argument to be parsed.</param> /// <param name="arg">The definition of the argument.</param> /// <param name="options">General options for parsing this argument set.</param> /// <param name="destination">The destination object into which the parsed result should go, /// if so desired; null otherwise to parse without saving results.</param> public ArgumentParser(ArgumentSetDefinition argSet, ArgumentDefinition arg, CommandLineParserOptions options, object destination = null) { ArgumentSet = argSet ?? throw new ArgumentNullException(nameof(argSet)); Argument = arg ?? throw new ArgumentNullException(nameof(arg)); Reporter = options?.Reporter ?? (s => { }); DestinationObject = arg.FixedDestination ?? destination; ParseContext = CreateParseContext(Argument, ArgumentSet.Attribute, options, DestinationObject); if (Argument.IsCollection) { CollectionValues = GenericCollectionFactory.CreateList(Argument.CollectionArgumentType.ElementType.Type); } }
public ArgumentManager(string[] args, CommandLineParserOptions parserOptions, string shortHelpOption, string longHelpOption, ICollection <CommandLineCommandBase> commands, ICollection <ICommandLineOption> options) { resultCache = new Dictionary <IArgument, ArgumentModel>(commands.Count + options.Count); this.parserOptions = parserOptions; this.helpOptionsEnabled = parserOptions.EnableHelpOption; this.shortHelpOption = shortHelpOption; this.longHelpOption = longHelpOption; this.hasPostfixDefined = !string.IsNullOrWhiteSpace(parserOptions.PostfixOption); this.args = new List <ArgumentValueHolder>( args.SplitOnPostfix(parserOptions, GetCommandLineOptions(options, commands)) .Select(arg => new ArgumentValueHolder { Argument = arg })); ParseCommands(commands); ParseOptions(options); CheckHelpCommands(); // pre cache results foreach (var item in this.args) { if (item.ArgModel == null) { continue; } int nextIndex = item.Index + 1; var argValue = nextIndex < this.args.Count ? this.args[nextIndex] : null; var argModel = new ArgumentModel { Key = item.Argument, // this checks if the argument is used in an other command/option. Value = (argValue?.Used ?? true) ? null : argValue.Argument }; if (resultCache.ContainsKey(item.ArgModel)) { continue; } resultCache.Add(item.ArgModel, argModel); } }
public void FileDoesNotExist() { var reader = CreateReaderThatThrows(new FileNotFoundException()); var options = new CommandLineParserOptions { FileSystemReader = reader }; CommandLineParser.Parse( new[] { "@foo" }, new Arguments(), options).Should().BeFalse(); reader.Received().GetLines("foo"); }