private void AddFlags(CliSpecification spec, Type t)
{
foreach (PropertyInfo pi in t.GetProperties( ))
{
FlagAttribute flagAttrib = pi.GetCustomAttribute <FlagAttribute>( );
if (flagAttrib == null)
{
continue;
}
AddFlag(spec, t, flagAttrib, pi);
}
}
private void AddOptions(CliSpecification spec, Type t)
{
foreach (PropertyInfo pi in t.GetProperties( ))
{
OptionAttribute optionAttrib = pi.GetCustomAttribute <OptionAttribute>( );
if (optionAttrib == null)
{
continue;
}
AddOption(spec, t, optionAttrib, pi);
}
}
public void OptionCaseSensitivityIgnoreCaseUpperUpper( )
{
ICliConfig conf = Config.New <ICliConfig>( );
conf.CaseSensitiveFlags = false;
ICliSpecification spec = new CliSpecification(conf);
IFlag flag = new Flag('F');
spec.Flags.Add(flag);
CommandLineParser clp = new CommandLineParser(spec);
IParserResult pr = clp.Parse(new[] { "-F" });
Assert.IsTrue(pr.IsSet(flag));
}
public void OptionCaseSensitivityIgnoreCaseUpper( )
{
ICliConfig conf = Config.New <ICliConfig>( );
conf.CaseSensitiveOptions = false;
ICliSpecification spec = new CliSpecification(conf);
IOption opt = new Option(new UnifiedName("opt"));
spec.Options.Add(opt);
CommandLineParser clp = new CommandLineParser(spec);
IParserResult pr = clp.Parse(new[] { "--OPT" });
Assert.IsTrue(pr.IsSet(opt));
}
private void AddFlag(
CliSpecification spec,
Type t,
FlagAttribute flagAttrib,
PropertyInfo pi)
{
Flag flag = new Flag(
flagAttrib.Name,
flagAttrib.Optional,
GetDynamicArgument(spec, t, pi.Name),
GetArguments(spec, t, pi.Name));
flag.Description = flagAttrib.Description;
spec.Flags.Add(flag);
}
private IArgument GetDynamicArgument(CliSpecification spec, Type t, string parent)
{
foreach (PropertyInfo pi in t.GetProperties( ))
{
ArgumentAttribute argAttrib = pi.GetCustomAttribute <ArgumentAttribute>( );
FirstArgumentAttribute firstArgAttrib = pi.GetCustomAttribute <FirstArgumentAttribute>( );
if (argAttrib == null &&
firstArgAttrib == null)
{
continue;
}
if (argAttrib != null &&
(string.Compare(parent, argAttrib.Of, StringComparison.InvariantCulture) != 0 ||
t.Name.Contains(parent)))
{
continue;
}
if (firstArgAttrib != null &&
string.Compare(parent, pi.Name, StringComparison.InvariantCulture) != 0)
{
continue;
}
if (!argAttrib?.Dynamic ?? !firstArgAttrib.Dynamic)
{
continue;
}
if (argAttrib != null)
{
return(_argTypeMapper.Map(
argAttrib,
pi,
_config.CliConfig,
parent));
}
return(_argTypeMapper.Map(
firstArgAttrib,
$"{pi.Name}{ImplicitFirstArg}",
pi.PropertyType,
spec.Config));
}
return(null);
}
public void OptionCaseSensitivityIncorrectCase( )
{
ICliSpecification spec = new CliSpecification( );
IOption opt = new Option(new UnifiedName("opt"));
spec.Options.Add(opt);
CommandLineParser clp = new CommandLineParser(spec);
Exception exc = null;
try {
clp.Parse(new[] { "--OPT" });
} catch (Exception ex) {
exc = ex;
}
Assert.IsNotNull(exc);
Assert.IsTrue(exc.Message.StartsWith("unknown option"));
}
public void FlagCaseSensitivityIncorrectCase( )
{
ICliSpecification spec = new CliSpecification( );
IFlag flag = new Flag('f');
spec.Flags.Add(flag);
CommandLineParser clp = new CommandLineParser(spec);
Exception exc = null;
try {
clp.Parse(new[] { "-F" });
} catch (Exception ex) {
exc = ex;
}
Assert.IsNotNull(exc);
Assert.IsTrue(exc.Message.StartsWith("unknown flag"));
}
public void TestTemplate1(
string[] args,
bool arg1ShouldBeSet,
bool arg2ShouldBeSet,
bool optShouldBeSet,
bool flagShouldBeSet,
string arg1ShouldBe = null,
string arg2ShouldBe = null)
{
IArgument arg1 = new Argument <string>("Argument 1", null);
IArgument arg2 = new Argument <string>("Argument 2", null);
CliSpecification spec = new CliSpecification(
args: new[] {
arg1
});
IFlag flag = new Flag('x');
spec.Flags.Add(flag);
IOption opt = new Option(
new UnifiedName("my", "opt"),
true,
'm',
null,
arg2);
spec.Options.Add(opt);
ICommandLineParser clp = new CommandLineParser(spec);
IParserResult pr = clp.Parse(args);
Assert.AreEqual(arg1ShouldBeSet, pr.IsSet(arg1));
Assert.AreEqual(arg2ShouldBeSet, pr.IsSet(arg2));
Assert.AreEqual(optShouldBeSet, pr.IsSet(opt));
Assert.AreEqual(flagShouldBeSet, pr.IsSet(flag));
if (arg1ShouldBe != null)
{
Assert.AreEqual(arg1ShouldBe, pr.GetValue(arg1));
}
if (arg2ShouldBe != null)
{
Assert.AreEqual(arg2ShouldBe, pr.GetValue(arg2));
}
}
public void DynamicArgumentTest2( )
{
IArgument <string> dynStringArg = new StringArg("dyn arg", null);
CliSpecification spec =
new CliSpecification(
null,
dynStringArg);
IArgument <int> dynIntArg = new Argument <int>("dyn int arg", null);
IOption myOpt = new Option(
new UnifiedName("my", "opt"),
false,
null,
dynIntArg);
spec.Options.Add(myOpt);
ICommandLineParser clp = new CommandLineParser(spec);
IParserResult pr =
clp.Parse(
new[] {
"arg1",
"arg2",
"--my-opt",
"23",
"42"
});
List <string> dynArgValues = pr.GetDynamicValues(dynStringArg).ToList( );
Assert.AreEqual(2, dynArgValues.Count);
Assert.AreEqual("arg1", dynArgValues[0]);
Assert.AreEqual("arg2", dynArgValues[1]);
List <int> dynIntArgValues = pr.GetDynamicValues(dynIntArg).ToList( );
Assert.AreEqual(2, dynIntArgValues.Count);
Assert.AreEqual(23, dynIntArgValues[0]);
Assert.AreEqual(42, dynIntArgValues[1]);
}
private void AddArguments(CliSpecification spec, Type t)
{
foreach (PropertyInfo pi in t.GetProperties( ))
{
ArgumentAttribute argAttrib = pi.GetCustomAttribute <ArgumentAttribute>( );
if (argAttrib == null)
{
continue;
}
if (!string.IsNullOrEmpty(argAttrib.Of))
{
continue;
}
IArgument arg;
if (argAttrib.Dynamic)
{
spec.DynamicArgument = arg =
_argTypeMapper.Map(
argAttrib,
pi,
_config.CliConfig,
string.Empty);
}
else
{
spec.AddArgument(
arg = _argTypeMapper.Map(
argAttrib,
pi,
_config.CliConfig,
string.Empty));
}
foreach (ArgumentConstraintAttribute ca in pi.GetCustomAttributes <ArgumentConstraintAttribute>( ))
{
ca.Handler.Handle(arg, ca);
}
}
}
public ICliSpecification DeriveSpecification <T>( ) where T : IConfiguration
{
CliSpecInterfaceCheck <T>(out Type t, out CliDefinitionAttribute cliDefAttrib);
if (typeof(T).GetProperties( ).Any(p => p.GetCustomAttribute <HelpAttribute>( ) != null) &&
_config.CliConfig.AutoAddHelpOption == false)
{
_config.CliConfig.AutoAddHelpOption = true;
}
CliSpecification spec = new CliSpecification(_config.CliConfig)
{
Description = cliDefAttrib.Description
};
AddOptions(spec, t);
AddFlags(spec, t);
AddArguments(spec, t);
ConstraintsCollector <T> cc = new ConstraintsCollector <T>(_config, spec);
foreach (IRule <IParserResult> rule in cc.Constraints)
{
spec.Rules.Add(rule);
}
if (spec.Options.Count + spec.Flags.Count + spec.Arguments.Count( ) == 0 &&
spec.DynamicArgument == null)
{
throw new ArgumentException($"{t.Name} does not define options, flags or arguments");
}
return(spec);
}
