static void HandleCommand(CommandLineApplication cla, CommandLineBinding binding, MemberInfo m, Func <object> modelGetter) { if (!binding._executed) { return; } if (m is MethodInfo) { var mi = (MethodInfo)m; var miParams = mi.GetParameters(); if (miParams.Length == 1) { mi.Invoke(binding._parentBinding.GetModel(), new object[] { modelGetter() }); } else if (miParams.Length == 0) { mi.Invoke(binding._parentBinding.GetModel(), EmptyValues); } } else if (m is PropertyInfo) { var pi = (PropertyInfo)m; pi.SetValue(binding._parentBinding.GetModel(), modelGetter()); } }
static void HandleRemainingArguments(RemainingArgumentsAttribute att, CommandLineBinding binding, MemberInfo m) { if (att.SkipIfNone && binding._cla.RemainingArguments?.Count == 0) { // No remaining args return; } var args = binding._cla.RemainingArguments?.ToArray(); if (args == null) { args = new string[0]; } if (m is MethodInfo) { var mi = (MethodInfo)m; mi.Invoke(binding.GetModel(), args); } else if (m is PropertyInfo) { var pi = (PropertyInfo)m; pi.SetValue(binding.GetModel(), args); } }
public void TestBasicOnExec() { var b1 = CommandLineBinding <BasicOnExec1> .Build(); Assert.False(b1.Model._onExecInvoked); var r1 = b1.Execute(); Assert.False(b1.Model._onExecInvoked); Assert.Equal(0, r1); var b2 = CommandLineBinding <BasicOnExec2> .Build(); Assert.False(b2.Model._onExecInvoked); Assert.Null(b2.Model._onExecParam); var r2 = b2.Execute(); Assert.True(b2.Model._onExecInvoked); Assert.NotNull(b2.Model._onExecParam); Assert.Equal(0, r2); var b3 = CommandLineBinding <BasicOnExec3> .Build(); Assert.False(b3.Model._onExecInvoked); Assert.Null(b3.Model._onExecParam); var r3 = b3.Execute(); Assert.True(b3.Model._onExecInvoked); Assert.NotNull(b3.Model._onExecParam); Assert.Equal(BasicOnExec3.RETURN_VALUE, r3); }
public void TestSameExecMultiNames() { var args = new[] { new[] { "-g", "Howdy!" }, new[] { "-g", "Howdy!", "--uppercase" }, new[] { "-g", "Howdy!", "--uppercase", "name", "John", "Jacob", "Jingle" }, }; var claOut = new StringWriter(); var claError = new StringWriter(); var binderOut = new StringWriter(); var binderError = new StringWriter(); foreach (var a in args) { var cla = BuildDocSampleCLA(); var binder = CommandLineBinding <DocSampleModel> .Build(); SetOutErr(cla, claOut, claError); binder.Out = binderOut; binder.Error = binderError; cla.Execute(a); binder.Execute(a); } //Console.WriteLine(nameof(TestSameExecMultiNames) + "Out: " + binderOut.ToString()); //Console.WriteLine(nameof(TestSameExecMultiNames) + "Err: " + binderError.ToString()); Assert.Equal(claOut.ToString(), binderOut.ToString()); Assert.Equal(claError.ToString(), binderError.ToString()); }
public void TestSameNameHelp() { var claOut = new StringWriter(); var claError = new StringWriter(); var binderOut = new StringWriter(); var binderError = new StringWriter(); var cla = BuildDocSampleCLA(); var binder = CommandLineBinding <DocSampleModel> .Build(); SetOutErr(cla, claOut, claError); binder.Out = binderOut; binder.Error = binderError; var args = new[] { "name", "--help-me" }; cla.Execute(args); binder.Execute(args); //Console.WriteLine(nameof(TestSameNameHelp) + "Out: " + claOut.ToString()); //Console.WriteLine(nameof(TestSameNameHelp) + "Err: " + claError.ToString()); Assert.Equal(claOut.ToString(), binderOut.ToString()); Assert.Equal(claError.ToString(), binderError.ToString()); }
public void TestBasicOnBind() { var b1 = CommandLineBinding <BasicOnBind1> .Build(); Assert.NotNull(b1.Model._opt1OnBindConfig); Assert.NotNull(b1.Model._arg1OnBindConfig); Assert.NotNull(b1.Model._cmd1OnBindConfig); }
public void TestBasicRemainingArgs() { var empty = new string[0]; var b1_1 = CommandLineBinding <BasicRemainingArgs1> .Build(); Assert.Null(b1_1.Model.TheRest); b1_1.Execute(); Assert.Equal(empty, b1_1.Model.TheRest); var b1_2 = CommandLineBinding <BasicRemainingArgs1> .Build(); Assert.Null(b1_2.Model.TheRest); b1_2.Execute("--flag1"); Assert.Equal(empty, b1_2.Model.TheRest); var b1_3 = CommandLineBinding <BasicRemainingArgs1> .Build(); Assert.Null(b1_3.Model.TheRest); b1_3.Execute("--opt1", "opt1-value", "--multi1", "m1", "--multi1", "m2"); Assert.Equal(empty, b1_3.Model.TheRest); var b2_1 = CommandLineBinding <BasicRemainingArgs1> .Build(); Assert.Null(b2_1.Model.TheRest); b2_1.Execute("foo"); Assert.Equal(new[] { "foo" }, b2_1.Model.TheRest); var b2_2 = CommandLineBinding <BasicRemainingArgs1> .Build(); Assert.Null(b2_2.Model.TheRest); b2_2.Execute("foo", "bar", "baz"); Assert.Equal(new[] { "foo", "bar", "baz" }, b2_2.Model.TheRest); var b3_1 = CommandLineBinding <BasicRemainingArgs1> .Build(); Assert.Null(b3_1.Model.TheRest); b3_1.Execute("--flag1", "foo"); Assert.Equal(new[] { "foo" }, b3_1.Model.TheRest); var b3_2 = CommandLineBinding <BasicRemainingArgs1> .Build(); Assert.Null(b3_2.Model.TheRest); b3_2.Execute("--opt1", "opt1-value", "--multi1", "m1", "--multi1", "m2", "foo", "bar", "baz"); Assert.Equal("opt1-value", b3_2.Model.Opt1); Assert.Equal(new[] { "m1", "m2" }, b3_2.Model.Multi1); Assert.Equal(new[] { "foo", "bar", "baz" }, b3_2.Model.TheRest); // This scenario is not supported (interleaved un-named args with named args) //var b3_3 = CommandLineBinding<BasicRemainingArgs1>.Build(); //Assert.Null(b3_3.Model.TheRest); //b3_3.Execute("--opt1", "opt1-value", "foo", "--multi1", "m1", "bar", "--multi1", "m2", "baz"); //Assert.Equal("opt1-value", b3_3.Model.Opt1); //Assert.Equal(new[] { "m1", "m2" }, b3_3.Model.Multi1); //Assert.Equal(new[] { "foo", "bar", "baz" }, b3_3.Model.TheRest); }
static void AddVersionOption(CommandLineBinding binding, Attribute att, MemberInfo m) { if (att is VersionOptionAttribute) { binding._versionOption = (VersionOptionAttribute)att; binding._bindingActions.Add(() => { if (binding._versionOption == null) { return; } if (binding._versionShortGetter == null) { binding._versionShortGetter = binding._versionLongGetter; } if (binding._versionShortGetter != null) { binding._cla.VersionOption(binding._versionOption.Template, binding._versionShortGetter, binding._versionLongGetter); } else { binding._cla.VersionOption(binding._versionOption.Template, binding._versionOption.ShortVersion, binding._versionOption.LongVersion); } }); } else if (att is ShortVersionGetterAttribute || att is LongVersionGetterAttribute) { var mi = m as MethodInfo; var pi = m as PropertyInfo; Func <string> getter = null; if (mi != null && mi.ReturnParameter.ParameterType == typeof(string) && mi.GetParameters().Length == 0) { getter = () => (string)mi.Invoke(binding.GetModel(), EmptyValues); } else if (pi != null && pi.PropertyType == typeof(string)) { getter = () => (string)pi.GetValue(binding.GetModel()); } if (getter != null && att is ShortVersionGetterAttribute) { binding._versionShortGetter = getter; } if (getter != null && att is LongVersionGetterAttribute) { binding._versionLongGetter = getter; } } }
public void TestBasicCommands() { var outWriter = new StringWriter(); var errWriter = new StringWriter();; var binding = CommandLineBinding <BasicCommands> .Build(); binding.Out = outWriter; binding.Error = errWriter; binding.Execute(BasicCommands.HELP_TEMPLATE); // Console.WriteLine("*******************************"); // Console.WriteLine("Out: " + outWriter.ToString()); // Console.WriteLine("Err: " + errWriter.ToString()); // Console.WriteLine("*******************************"); Assert.True(outWriter.ToString().Contains("sub1")); Assert.True(outWriter.ToString().Contains("sub2")); Assert.True(outWriter.ToString().Contains("sub3")); Assert.Equal(string.Empty, errWriter.ToString()); Assert.Null(binding.Model.Sub1); Assert.Null(binding.Model._sub2); Assert.Null(binding.Model.Sub3); binding = CommandLineBinding <BasicCommands> .Build(); binding.Execute("sub1"); Assert.False(binding.Model.Opt1); Assert.NotNull(binding.Model.Sub1); Assert.Null(binding.Model.Sub1.Url); Assert.Null(binding.Model._sub2); Assert.Null(binding.Model.Sub3); binding = CommandLineBinding <BasicCommands> .Build(); binding.Execute("--opt1", "sub1"); Assert.True(binding.Model.Opt1); Assert.NotNull(binding.Model.Sub1); Assert.Null(binding.Model.Sub1.Url); Assert.Null(binding.Model._sub2); Assert.Null(binding.Model.Sub3); binding = CommandLineBinding <BasicCommands> .Build(); binding.Execute("sub1", "--url", "foo"); Assert.NotNull(binding.Model.Sub1); Assert.Equal("foo", binding.Model.Sub1.Url); Assert.Null(binding.Model._sub2); Assert.Null(binding.Model.Sub3); binding = CommandLineBinding <BasicCommands> .Build(); binding.Execute("sub2"); Assert.Null(binding.Model.Sub1); Assert.NotNull(binding.Model._sub2); Assert.Null(binding.Model._sub2.Path); Assert.Null(binding.Model.Sub3); }
public void TestBasicOnInit() { var b1 = CommandLineBinding <BasicOnInit1> .Build(); Assert.False(b1.Model._onInitInvoked); var b2 = CommandLineBinding <BasicOnInit2> .Build(); Assert.True(b2.Model._onInitInvoked); Assert.NotNull(b2.Model._onInitParam); }
static void AddHelpOption(CommandLineBinding binding, Attribute att, MemberInfo m) { var a = (HelpOptionAttribute)att; binding._helpOption = a; binding._bindingActions.Add(() => { binding._cla.HelpOption(binding._helpOption.Template); }); }
public void TestEmptyModel1() { var outWriter = new StringWriter(); var errWriter = new StringWriter();; var x = CommandLineBinding <EmptyModel1> .Build(); x.Out = outWriter; x.Error = errWriter; x.Execute("-f foo --bar bar baz"); x.Execute("-h"); x.Execute("-v"); Assert.Equal(string.Empty, outWriter.ToString()); Assert.Equal(string.Empty, errWriter.ToString()); }
static void HandleOption(CommandOption co, CommandLineBinding binding, MemberInfo m) { if (!co.HasValue()) { return; } object coValue; if (co.OptionType == CommandOptionType.NoValue) { //coValue = bool.Parse(co.Value()); coValue = true; } else if (co.OptionType == CommandOptionType.SingleValue) { coValue = co.Value(); } else { coValue = co.Values.ToArray(); } if (m is MethodInfo) { var mi = (MethodInfo)m; var miParams = mi.GetParameters(); if (miParams.Length == 2) { mi.Invoke(binding.GetModel(), new object[] { coValue, binding }); } else if (miParams.Length == 1) { mi.Invoke(binding.GetModel(), new object[] { coValue }); } else { mi.Invoke(binding.GetModel(), EmptyValues); } } else if (m is PropertyInfo) { var pi = (PropertyInfo)m; pi.SetValue(binding.GetModel(), coValue); } }
static void SetCLA(CommandLineBinding binding, Attribute att) { var claAtt = (CommandLineAttribute)att; if (claAtt == null) { claAtt = new CommandLineAttribute(); } if (binding._cla == null) { binding._cla = new CommandLineApplication(claAtt.ThrowOnUnexpectedArg); } binding._cla.Name = claAtt.Name ?? string.Empty; binding._cla.FullName = claAtt.FullName ?? string.Empty; binding._cla.Description = claAtt.Description ?? string.Empty; binding._cla.AllowArgumentSeparator = claAtt.AllowArgumentSeparator; }
public void TestBasicSwitches() { var boolSwitch = "--" + nameof(BasicSwitches.ImplicitBool).ToLower(); var boolNullSwitch = "--" + nameof(BasicSwitches.ImplicitBoolNullable).ToLower(); var outWriter = new StringWriter(); var errWriter = new StringWriter();; var binding = CommandLineBinding <BasicSwitches> .Build(); binding.Out = outWriter; binding.Error = errWriter; binding.Execute("--help-me"); Assert.True(outWriter.ToString().Contains(boolSwitch)); Assert.True(outWriter.ToString().Contains(boolNullSwitch)); Assert.Equal(string.Empty, errWriter.ToString()); binding = CommandLineBinding <BasicSwitches> .Build(); binding.Execute(boolSwitch); Assert.True(binding.Model._impliciBoolCalled); Assert.True(binding.Model._impliciBoolValue); Assert.False(binding.Model.ImplicitBoolNullable.HasValue); // TODO: // Apparently NoValue options of the formt --opt:true or --opt:false // are not support contrary to my interpretation of // https://msdn.microsoft.com/en-us/magazine/mt763239.aspx?f=255&MSPPError=-2147217396 //model = CommandLineModel<BasicSwitches>.Build(); //model.Execute(boolSwitch + "=true"); //Assert.True(model.Instance._impliciBoolCalled); //Assert.False(model.Instance._impliciBoolValue); //Assert.False(model.Instance.ImplicitBoolNullable.HasValue); binding = CommandLineBinding <BasicSwitches> .Build(); binding.Execute(boolNullSwitch); Assert.False(binding.Model._impliciBoolCalled); Assert.False(binding.Model._impliciBoolValue); Assert.True(binding.Model.ImplicitBoolNullable.HasValue); Assert.True(binding.Model.ImplicitBoolNullable.Value); }
public void TestBasicMultiOptions() { var outWriter = new StringWriter(); var errWriter = new StringWriter();; var binding = CommandLineBinding <BasicMultiOptions> .Build(); binding.Out = outWriter; binding.Error = errWriter; binding.Execute(BasicMultiOptions.HELP_TEMPLATE); // Console.WriteLine("*******************************"); // Console.WriteLine("Out: " + outWriter.ToString()); // Console.WriteLine("Err: " + errWriter.ToString()); // Console.WriteLine("*******************************"); binding = CommandLineBinding <BasicMultiOptions> .Build(); binding.Execute("--multi1", "v1", "--multi1", "v2", "--multi1", "v3"); Assert.Equal(new[] { "v1", "v2", "v3", }, binding.Model.Multi1); binding = CommandLineBinding <BasicMultiOptions> .Build(); binding.Execute("--multi2", "v1", "--multi2", "v2", "--multi2", "v3"); Assert.Equal(new[] { "v1", "v2", "v3", }, binding.Model._multi2Values); binding = CommandLineBinding <BasicMultiOptions> .Build(); binding.Execute("--multi3", "v1", "--multi3", "v2", "--multi3", "v3"); Assert.Equal(new[] { "v1", "v2", "v3", }, binding.Model._multi3Values); binding = CommandLineBinding <BasicMultiOptions> .Build(); binding.Execute( "--multi1", "v1", "--multi2", "v2", "--multi3", "v3", "--multi1", "vA", "--multi2", "vB", "--multi3", "vC", "--multi1", "vI", "--multi2", "vII", "--multi3", "vIII" ); Assert.Equal(new[] { "v1", "vA", "vI", }, binding.Model.Multi1); Assert.Equal(new[] { "v2", "vB", "vII", }, binding.Model._multi2Values); Assert.Equal(new[] { "v3", "vC", "vIII", }, binding.Model._multi3Values); }
static void BindRemainingArguments(CommandLineBinding binding) { var m = binding._remainingArgumentsMember; if (m == null) { return; } var a = (RemainingArgumentsAttribute)m.GetCustomAttribute(typeof(RemainingArgumentsAttribute)); var onConfigName = $"{m.Name}{MemberOnBindMethodSuffix}"; var onConfigMeth = binding.GetModel().GetType().GetTypeInfo().GetMethod( onConfigName, OnBindRemainingArgumentsParams); if (onConfigMeth != null) { onConfigMeth.Invoke(binding.GetModel(), new[] { binding._cla }); } binding._postExecActions.Add(() => { HandleRemainingArguments(a, binding, m); }); }
public void TestHelpfulEmptyModel() { var outWriter = new StringWriter(); var errWriter = new StringWriter();; var binding = CommandLineBinding <HelpfulEmptyModel> .Build(); binding.Out = outWriter; binding.Error = errWriter; binding.Execute("-f foo --bar bar baz"); Assert.Equal(string.Empty, outWriter.ToString()); binding.Execute("-v"); Assert.Equal(string.Empty, outWriter.ToString()); binding.Execute("-h"); Assert.True(outWriter.ToString().Contains("Usage")); Assert.True(outWriter.ToString().Contains("Options")); Assert.True(outWriter.ToString().Contains("Show help information")); Assert.Equal(string.Empty, errWriter.ToString()); }
public void TestDynamicallyVersionedEmptyModel() { var outWriter = new StringWriter(); var errWriter = new StringWriter();; var binding = CommandLineBinding <DynamicallyVersionedEmptyModel> .Build(); binding.Out = outWriter; binding.Error = errWriter; binding.Execute("-f foo --bar bar baz"); Assert.Equal(string.Empty, outWriter.ToString()); binding.Execute("-h"); Assert.Equal(string.Empty, outWriter.ToString()); binding.Execute("--version"); Assert.Equal($"{nameof(DynamicallyVersionedEmptyModel)} {DynamicallyVersionedEmptyModel.SVER}", binding.GetFullNameAndVersion()); Assert.Equal($"{nameof(DynamicallyVersionedEmptyModel)}\r\n{DynamicallyVersionedEmptyModel.LVER}", outWriter.ToString().Trim()); Assert.Equal(string.Empty, errWriter.ToString()); }
static void HandleArgument(CommandArgument ca, CommandLineBinding binding, MemberInfo m) { if (ca.Values?.Count == 0) { return; } object caValue; if (ca.MultipleValues) { caValue = ca.Values.ToArray(); } else { caValue = ca.Value; } if (m is MethodInfo) { var mi = (MethodInfo)m; var miParams = mi.GetParameters(); if (miParams.Length == 2) { mi.Invoke(binding.GetModel(), new object[] { caValue, binding }); } else { mi.Invoke(binding.GetModel(), new object[] { caValue }); } } else if (m is PropertyInfo) { var pi = (PropertyInfo)m; pi.SetValue(binding.GetModel(), caValue); } }
public void TestSameExecBadOption() { var claOut = new StringWriter(); var claError = new StringWriter(); var binderOut = new StringWriter(); var binderError = new StringWriter(); var cla = BuildDocSampleCLA(); var binder = CommandLineBinding <DocSampleModel> .Build(); SetOutErr(cla, claOut, claError); binder.Out = binderOut; binder.Error = binderError; cla.Execute("--foo"); binder.Execute("--foo"); // Console.WriteLine("Out: " + claOut.ToString()); // Console.WriteLine("Err: " + claError.ToString()); Assert.Equal(claOut.ToString(), binderOut.ToString()); Assert.Equal(claError.ToString(), binderError.ToString()); }
static void AddCommand(CommandLineBinding binding, Attribute att, MemberInfo m) { var a = (CommandAttribute)att; var cmdName = a.Name; if (string.IsNullOrEmpty(cmdName)) { cmdName = m.Name.ToLower(); } Type cmdType; if (m is MethodInfo) { var mi = (MethodInfo)m; var miParams = mi.GetParameters(); if (miParams.Length == 1) { cmdType = miParams[0].ParameterType; } else if (miParams.Length == 0) { cmdType = null; } else { throw new NotSupportedException("method signature is not supported"); } } else if (m is PropertyInfo) { var pi = (PropertyInfo)m; cmdType = pi.PropertyType; } else { return; } // See if there is an optional configuration method for this sub-command var onConfigName = $"{m.Name}{MemberOnBindMethodSuffix}"; var onConfigMeth = binding.GetModel().GetType().GetTypeInfo().GetMethod( onConfigName, OnBindCommandParams); // Add the option based on whether there is a config method Action <CommandLineApplication> configAction = cla => { }; if (onConfigMeth != null) { configAction = cla => onConfigMeth.Invoke(binding.GetModel(), new[] { cla }); } var subCla = binding._cla.Command(cmdName, configAction, a.ThrowOnUnexpectedArg); // When a sub-command is specified, its OnExecute handler is invoked instead of the // parent's so we inject a post-exec action to invoke the parent's post-exec actions Action parentPostExec = () => binding.PostExec(true); var subBinding = CommandLineBinding.BindModel(cmdType, subCla, binding.GetModel(), parentPostExec); subBinding._parentBinding = binding; binding._childBindings.Add(subBinding); // This is already invoked by Apply which is invoke by Build //subModelSetCLA.Invoke(null, new object[] { subModel, cmdType.GetTypeInfo() // .GetCustomAttribute<CommandLineApplicationAttribute>() }); // We need to make sure the command name from the Command attr is preserved after // processing of the optional CLA attr on the subclass which may have its own name subCla.Name = cmdName; binding._postExecActions.Add(() => HandleCommand(subCla, subBinding, m, () => subBinding.GetModel())); }
static void AddOption(CommandLineBinding binding, Attribute att, MemberInfo m) { var a = (OptionAttribute)att; // Resolve the option value type Type valueType = null; if (m is PropertyInfo) { var pi = (PropertyInfo)m; valueType = pi.PropertyType; } else if (m is MethodInfo) { var mi = (MethodInfo)m; var miParams = mi.GetParameters(); if (miParams.Length == 1 || (miParams.Length == 2 && typeof(CommandLineBinding).GetTypeInfo().IsAssignableFrom(miParams[1].ParameterType))) { valueType = miParams[0].ParameterType; } else if (miParams.Length > 0) { throw new NotSupportedException("method signature is not supported"); } } // Figure out the option type based on value type if it wasn't explicitly specified CommandOptionType optionType = CommandOptionType.NoValue; if (a.OptionType == null && valueType != null) { // Try to resolve the option type based on the property type if (valueType.GetTypeInfo().IsAssignableFrom(typeof(string))) { optionType = CommandOptionType.SingleValue; } else if (valueType.GetTypeInfo().IsAssignableFrom(typeof(string[]))) { optionType = CommandOptionType.MultipleValue; } else if (valueType == typeof(bool?) || valueType == typeof(bool)) { optionType = CommandOptionType.NoValue; } else { throw new NotSupportedException("option value type is not supported"); } } // Resolve the option template if it wasn't explicitly specified var template = a.Template; if (string.IsNullOrEmpty(template)) { template = $"--{m.Name.ToLower()}"; } // See if there is an optional configuration method for this option var onConfigName = $"{m.Name}{MemberOnBindMethodSuffix}"; var onConfigMeth = binding.GetModel().GetType().GetTypeInfo().GetMethod( onConfigName, OnBindOptionParams); // Add the option based on whether there is a config method CommandOption co; if (onConfigMeth != null) { co = binding._cla.Option(template, a.Description, optionType, cmdOpt => onConfigMeth.Invoke(binding.GetModel(), new[] { cmdOpt }), a.Inherited); } else { co = binding._cla.Option(template, a.Description, optionType, a.Inherited); } // Add a post-exec handler for this option binding._postExecActions.Add(() => HandleOption(co, binding, m)); }
static void AddArgument(CommandLineBinding binding, Attribute att, MemberInfo m) { var a = (ArgumentAttribute)att; // Resolve the option value type Type valueType = null; if (m is PropertyInfo) { var pi = (PropertyInfo)m; valueType = pi.PropertyType; } else if (m is MethodInfo) { var mi = (MethodInfo)m; var miParams = mi.GetParameters(); if (miParams.Length == 1 || (miParams.Length == 2 && typeof(CommandLineBinding).GetTypeInfo().IsAssignableFrom(miParams[1].ParameterType))) { valueType = miParams[0].ParameterType; } else if (miParams.Length > 0) { throw new NotSupportedException("method signature is not supported"); } } // Figure out the argument arity based on value type if it wasn't explicitly specified var multi = a.MultipleValues; if (multi == null && valueType != null) { // Try to resolve the option type based on the property type if (valueType.GetTypeInfo().IsAssignableFrom(typeof(string))) { multi = false; } else if (valueType.GetTypeInfo().IsAssignableFrom(typeof(string[]))) { multi = true; } else { throw new NotSupportedException("option value type is not supported"); } } // Resolve the arg name if it wasn't explicitly specified var argName = a.Name; if (string.IsNullOrEmpty(argName)) { argName = m.Name.ToLower(); } // See if there is an optional configuration method for this option var onConfigName = $"{m.Name}{MemberOnBindMethodSuffix}"; var onConfigMeth = binding.GetModel().GetType().GetTypeInfo().GetMethod( onConfigName, OnBindArgumentParams); CommandArgument ca; if (onConfigMeth != null) { ca = binding._cla.Argument(argName, a.Description, cmdArg => onConfigMeth.Invoke(binding.GetModel(), new[] { cmdArg }), multi.GetValueOrDefault()); } else { ca = binding._cla.Argument(argName, a.Description, multi.GetValueOrDefault()); } binding._postExecActions.Add(() => { HandleArgument(ca, binding, m); }); }
static void AddRemainingArguments(CommandLineBinding binding, Attribute att, MemberInfo m) { var a = (RemainingArgumentsAttribute)att; binding._remainingArgumentsMember = m; }
public void TestEmptyModel2b() { var x = CommandLineBinding <EmptyModel2> .Build(); x.Execute("-f", "foo", "--bar", "bar", "baz"); }