public CommandOption Option( string template, string description, CommandOptionType optionType) { return(this.Option(template, description, optionType, (Action <CommandOption>)(_ => { }), false)); }
internal CommandOptionBuilder(List <CommandOption> parent, CommandOptionType type, string name, string description, IApplicationCommandBuilder builder) { if (string.IsNullOrEmpty(name)) { throw new ArgumentException("Value cannot be null or empty.", nameof(name)); } if (string.IsNullOrEmpty(description)) { throw new ArgumentException("Value cannot be null or empty.", nameof(description)); } if (type == CommandOptionType.SubCommand || type == CommandOptionType.SubCommandGroup) { throw new InvalidApplicationCommandException($"{type} is not allowed to be used here. Valid types are any non command type."); } _option = new CommandOption { Name = name, Description = description, Type = type }; parent.Add(_option); _builder = builder; }
public void RequiredOption_Pass(CommandOptionType type, string[] args, bool allowEmptyStrings) { var app = new CommandLineApplication(new TestConsole(_output)); app.Option("-t", "Test", type).IsRequired(allowEmptyStrings); Assert.Equal(0, app.Execute(args)); }
private static CommandOption AddOption(CommandLineApplication app, string optionName, string description, CommandOptionType optionType) { string argSuffix = optionType == CommandOptionType.MultipleValue ? "..." : null; string argString = optionType == CommandOptionType.BoolValue ? null : $" <arg>{argSuffix}"; return app.Option($"--{optionName}{argString}", description, optionType); }
private void ValidateArgs(string name, CommandOptionType arg, CommandOptionType requested) { if (arg != requested) { throw new Exception($"Attempted to parse {name} {arg} type to: {requested} which is not valid."); } }
public void CanIdentifyArgumentInfoFromMethodsUsingParameterInfo( string parameterName, CommandOptionType commandOptionType, object defaultValue, string typeDisplayName, //string parameterDetails, string annotatedDescription, //string effectiveDescription, string template, Type type //bool showParameterDetails ) { MethodInfo methodInfo = typeof(TestApplication).GetMethod("Execute"); var parameters = methodInfo.GetParameters(); var parameter = parameters.Single(p => p.Name == parameterName); CommandOptionInfo commandParameterInfo = new CommandOptionInfo(parameter, new AppSettings { MethodArgumentMode = ArgumentMode.Option }); commandParameterInfo.CommandOptionType.Should().Be(commandOptionType, nameof(commandOptionType)); commandParameterInfo.DefaultValue.Should().Be(defaultValue, nameof(defaultValue)); commandParameterInfo.TypeDisplayName.Should().Be(typeDisplayName, nameof(typeDisplayName)); // commandParameterInfo.Details.Should().Be(parameterDetails, nameof(parameterDetails)); commandParameterInfo.AnnotatedDescription.Should().Be(annotatedDescription, nameof(annotatedDescription)); // commandParameterInfo.EffectiveDescription.Should().Be(effectiveDescription, nameof(effectiveDescription)); commandParameterInfo.Template.Should().Be(template, nameof(template)); commandParameterInfo.Type.Should().Be(type, nameof(type)); }
public CommandOption Option(string template, string description, CommandOptionType optionType, Action<CommandOption> configuration) { var option = new CommandOption(template, optionType) { Description = description }; Options.Add(option); configuration(option); return option; }
public CommandOption Option(string name, string Description, CommandOptionType multipleValues, params Func <CommandOption, int>[] validators) { var cmd = _config.Option(name, Description, CommandOptionType.SingleValue); Validate(cmd, validators); return(cmd); }
public CommandOption Option( string template, string description, CommandOptionType optionType, Action <CommandOption> configuration) { return(this.Option(template, description, optionType, configuration, false)); }
public CommandOption Option( string template, string description, CommandOptionType optionType, bool inherited) { return(this.Option(template, description, optionType, (Action <CommandOption>)(_ => { }), inherited)); }
/// <summary> /// Adds a command option. /// </summary> /// <param name="type">The type of option. Cannot be SubCommand or SubCommandGroup</param> /// <param name="name">Name of the option</param> /// <param name="description">Description for the option</param> /// <returns><see cref="CommandOptionBuilder"/></returns> public CommandOptionBuilder AddOption(CommandOptionType type, string name, string description) { if (_chosenType.HasValue && (_chosenType.Value == CommandOptionType.SubCommandGroup || _chosenType.Value == CommandOptionType.SubCommand)) { throw new Exception("Cannot mix sub command / sub command groups with command options"); } return(new CommandOptionBuilder(_options, type, name, description, this)); }
public CommandOption Option(string template, string description, CommandOptionType optionType, Action <CommandOption> configuration) { var option = new CommandOption(template, optionType) { Description = description }; Options.Add(option); configuration(option); return(option); }
public void ShouldCreateOptionProperly( string optionName, string description, CommandOptionType optionType ) { var command = new CommandLineApplication(); var option = command.CreateOption(optionName, description, optionType); Assert.Equal(optionName, option.LongName); Assert.Equal(description, option.Description); Assert.Equal(optionType, option.OptionType); }
public IOptionsBuilder Option <T>(string template, string description, CommandOptionType type, bool inherited) { _options.Add(app => { var option = app.Option <T>(template, string.Empty, type); option.Inherited = inherited; option.Description = description ?? _descriptionProvider.Value(CreateResourceKey(option.LongName)); return(option); }); return(this); }
public virtual CommandOption Option(string template, string description, CommandOptionType optionType, Action <CommandOption> configuration, bool inherited) { var option = new CommandOption(template, optionType) { Description = description, Inherited = inherited }; Options.Add(option); configuration(option); return(option); }
public bool TryGetOptionType(Type clrType, out CommandOptionType optionType) { try { optionType = GetOptionType(clrType); return(true); } catch { optionType = default; return(false); } }
public static CommandOption CreateOption( this CommandLineApplication command, string name, string description, CommandOptionType type, string template = DefaultTemplate ) { string optionName = name.Dashrialize(); string formatedTemplate = string.Format(template, optionName); return(command.Option(formatedTemplate, description, type)); }
public CommandOption(string template, CommandOptionType optionType) { Template = template; OptionType = optionType; Values = new List <string?>(); foreach (var part in Template.Split(new[] { ' ', '|' }, StringSplitOptions.RemoveEmptyEntries)) { if (part.StartsWith("--", StringComparison.Ordinal)) { LongName = part.Substring(2); } else if (part.StartsWith("-", StringComparison.Ordinal)) { var optName = part.Substring(1); // If there is only one char and it is not an English letter, it is a symbol option (e.g. "-?") if (optName.Length == 1 && !IsEnglishLetter(optName[0])) { SymbolName = optName; } else { ShortName = optName; } } else if (part.StartsWith("<", StringComparison.Ordinal) && part.EndsWith(">", StringComparison.Ordinal)) { ValueName = part.Substring(1, part.Length - 2); } else if (optionType == CommandOptionType.MultipleValue && part.StartsWith("<", StringComparison.Ordinal) && part.EndsWith(">...", StringComparison.Ordinal)) { ValueName = part.Substring(1, part.Length - 5); } else { throw new ArgumentException(Resources.InvalidTemplatePattern(template), nameof(template)); } } if (string.IsNullOrEmpty(LongName) && string.IsNullOrEmpty(ShortName) && string.IsNullOrEmpty(SymbolName)) { throw new ArgumentException(Resources.InvalidTemplatePattern(template), nameof(template)); } }
public static CommandOption <T> OptionalOption <T>( this CommandLineApplication application, string template, string description, object defaultValue, CommandOptionType optionType ) { return(application.Option <T>( template, $"Optional: {description}, Default: {defaultValue}", optionType )); }
public bool TryGetOptionType( Type clrType, ValueParserProvider valueParsers, out CommandOptionType optionType) { try { optionType = GetOptionType(clrType, valueParsers); return(true); } catch { optionType = default; return(false); } }
public CommandOption Option( string template, string description, CommandOptionType optionType, Action <CommandOption> configuration, bool inherited) { CommandOption commandOption = new CommandOption(template, optionType) { Description = description, Inherited = inherited }; this.Options.Add(commandOption); configuration(commandOption); return(commandOption); }
public CommandOption(string template, CommandOptionType optionType) { Template = template; OptionType = optionType; Values = new List<string>(); foreach (var part in Template.Split(new[] { ' ', '|' }, StringSplitOptions.RemoveEmptyEntries)) { if (part.StartsWith("--")) { LongName = part.Substring(2); } else if (part.StartsWith("-")) { var optName = part.Substring(1); // If there is only one char and it is not an English letter, it is a symbol option (e.g. "-?") if (optName.Length == 1 && !IsEnglishLetter(optName[0])) { SymbolName = optName; } else { ShortName = optName; } } else if (part.StartsWith("<") && part.EndsWith(">")) { ValueName = part.Substring(1, part.Length - 2); } else if (optionType == CommandOptionType.MultipleValue && part.StartsWith("<") && part.EndsWith(">...")) { ValueName = part.Substring(1, part.Length - 5); } else { throw new ArgumentException($"Invalid template pattern '{template}'", nameof(template)); } } if (string.IsNullOrEmpty(LongName) && string.IsNullOrEmpty(ShortName) && string.IsNullOrEmpty(SymbolName)) { throw new ArgumentException($"Invalid template pattern '{template}'", nameof(template)); } }
public CommandOption(string template, CommandOptionType optionType) { #pragma warning disable 618 Template = template; #pragma warning restore 618 OptionType = optionType; var separators = (optionType == CommandOptionType.SingleOrNoValue) ? new[] { ' ', '|', ':', '=', '[', ']' } : new[] { ' ', '|', ':', '=' }; foreach (var part in template.Split(separators, StringSplitOptions.RemoveEmptyEntries)) { if (part.StartsWith("--")) { LongName = part.Substring(2); } else if (part.StartsWith("-")) { var optName = part.Substring(1); // If there is only one char and it is not an English letter, it is a symbol option (e.g. "-?") if (optName.Length == 1 && !IsEnglishLetter(optName[0])) { SymbolName = optName; } else { ShortName = optName; } } else if (part.StartsWith("<") && part.EndsWith(">")) { ValueName = part.Substring(1, part.Length - 2); } else { throw new ArgumentException($"Invalid template pattern '{template}'", nameof(template)); } } if (string.IsNullOrEmpty(LongName) && string.IsNullOrEmpty(ShortName) && string.IsNullOrEmpty(SymbolName)) { throw new ArgumentException($"Invalid template pattern '{template}'", nameof(template)); } }
private static void SetValueInfo(ArgumentInfo argumentInfo, CommandOptionType commandOptionType) { //set value IParameter option = null; switch (argumentInfo) { case CommandOptionInfo optionInfo: option = new CommandOption("--test", commandOptionType); break; case CommandParameterInfo parameterInfo: option = new CommandArgument(); break; } argumentInfo.SetValue(option); }
public void Option(string template, string description, CommandOptionType optionType, Action <CommandOption> callback, Action <CommandOption> configuration = null) { if (callback == null) { throw new ArgumentNullException(nameof(callback)); } CommandOption option; if (configuration != null) { option = _app.Option(template, description, optionType, configuration); } else { option = _app.Option(template, description, optionType); } _callbacks.Add(() => callback(option)); }
public CommandOption(string template, CommandOptionType optionType) { Template = template; OptionType = optionType; Values = new List <string>(); foreach (var part in Template.Split(new[] { ' ', '|' }, StringSplitOptions.RemoveEmptyEntries)) { if (part.StartsWith("--")) { LongName = part.Substring(2); } else if (part.StartsWith("-")) { var optName = part.Substring(1); if (optName.Length == 1 && !IsEnglishLetter(optName[0])) { SymbolName = optName; } else { ShortName = optName; } } else if (part.StartsWith("<") && part.EndsWith(">")) { ValueName = part.Substring(1, part.Length - 2); } else if (optionType == CommandOptionType.MultipleValue && part.StartsWith("<") && part.EndsWith(">...")) { ValueName = part.Substring(1, part.Length - 5); } else { throw new ArgumentException($"Invalid template pattern '{template}'", nameof(template)); } } if (string.IsNullOrEmpty(LongName) && string.IsNullOrEmpty(ShortName) && string.IsNullOrEmpty(SymbolName)) { throw new ArgumentException($"Invalid template pattern '{template}'", nameof(template)); } }
public CommandOption(string template, CommandOptionType optionType) { this.Template = template; this.OptionType = optionType; this.Values = new List <string>(); string template1 = this.Template; char[] separator = new char[2] { ' ', '|' }; foreach (string str1 in template1.Split(separator, StringSplitOptions.RemoveEmptyEntries)) { if (str1.StartsWith("--")) { this.LongName = str1.Substring(2); } else if (str1.StartsWith("-")) { string str2 = str1.Substring(1); if (str2.Length == 1 && !this.IsEnglishLetter(str2[0])) { this.SymbolName = str2; } else { this.ShortName = str2; } } else { if (!str1.StartsWith("<") || !str1.EndsWith(">")) { throw new ArgumentException(string.Format("Invalid template pattern '{0}'", (object)template), nameof(template)); } this.ValueName = str1.Substring(1, str1.Length - 2); } } if (string.IsNullOrEmpty(this.LongName) && string.IsNullOrEmpty(this.ShortName) && string.IsNullOrEmpty(this.SymbolName)) { throw new ArgumentException(string.Format("Invalid template pattern '{0}'", (object)template), nameof(template)); } }
public void TestParsing(string expected, string template, string fullName, CommandOptionType type, params string[] values) { // Arrange var option = new CommandOption(template, type); option.Values.AddRange(values.ToList()); var optionList = new List <CommandOption> { option }; // Act var provider = new CommandLineOptionsProvider(optionList); var builder = new ConfigurationBuilder(); var config = provider.Build(builder); config.TryGet(fullName, out var actual); // Assert Assert.Equal(expected, actual); }
private InteractionDataOption GetArg(string name, CommandOptionType requested) { InteractionDataOption arg = _args[name]; if (arg == null) { return(null); } if (arg.Type != CommandOptionType.Mentionable) { ValidateArgs(name, arg.Type, requested); } else if (requested != CommandOptionType.Role && requested != CommandOptionType.User) { throw new Exception($"Attempted to parse {name} role/user type to: {requested} which is not valid."); } return(arg); }
public CommandOption(string template, CommandOptionType optionType) { Template = template; OptionType = optionType; Values = new List <string>(); foreach (var part in Template.Split(new[] { ' ', '|' }, StringSplitOptions.RemoveEmptyEntries)) { if (part.StartsWith("--")) { LongName = part.Substring(2); } else if (part.StartsWith("-")) { var optName = part.Substring(1); // If there is only one char and it is not an English letter, it is a symbol option (e.g. "-?") if (optName.Length == 1 && !IsEnglishLetter(optName[0])) { SymbolName = optName; } else { ShortName = optName; } } else if (part.StartsWith("<") && part.EndsWith(">")) { ValueName = part.Substring(1, part.Length - 2); } else { throw new Exception("TODO: invalid template pattern " + template); } } if (string.IsNullOrEmpty(LongName) && string.IsNullOrEmpty(ShortName) && string.IsNullOrEmpty(SymbolName)) { throw new Exception("TODO: invalid template pattern " + template); } }
internal CommandOption Option(string template, string description, CommandOptionType optionType, Action <CommandOption> configuration, bool inherited, string typeDisplayName, object defaultValue, bool multiple, List <string> allowedValues ) { var option = new CommandOption(template, optionType) { Description = description, Inherited = inherited, DefaultValue = defaultValue, TypeDisplayName = typeDisplayName, Multiple = multiple, AllowedValues = allowedValues }; bool optionAdded = Options.Add(option); if (!optionAdded) { throw new AppRunnerException($"Option with template `{option.Template}` already added"); } configuration(option); return(option); }
/// <summary> /// Shortcut to create commands /// </summary> /// <param name="app">Command line application object</param> /// <param name="optionName">Name for option</param> /// <param name="shortName">Short name for option</param> /// <param name="description">Description for help</param> /// <param name="optionType">Type of option</param> /// <returns></returns> internal static CommandOption AddOption(this CommandLineApplication app, string optionName, string shortName, string description, CommandOptionType optionType) { var argSuffix = optionType == CommandOptionType.MultipleValue ? "..." : null; var argString = optionType == CommandOptionType.SingleValue ? null : $" <arg>{argSuffix}"; switch (optionType) { case CommandOptionType.MultipleValue: case CommandOptionType.SingleValue: return (app.Option(string.IsNullOrWhiteSpace(shortName) ? $"-{shortName}|--{optionName}{argString}" : $"--{optionName}{argString}", description, optionType)); case CommandOptionType.NoValue: return (app.Option(string.IsNullOrWhiteSpace(shortName) ? $"-{shortName}|--{optionName}" : $"--{optionName}", description, optionType)); default: return(null); } }
public CommandOption Option(string template, string description, CommandOptionType optionType) { return Option(template, description, optionType, _ => { }); }
public CommandOption Option(string template, string description, CommandOptionType optionType) { return(Option(template, description, optionType, _ => { })); }