private Argument MapEnumType(Type enumType, ICliConfig cliConfig, string name, bool optional)
{
Type enumArgType = typeof(EnumArg <>).MakeGenericType(enumType);
Argument arg = (Argument)Activator.CreateInstance(enumArgType, name, (string)null, optional);
return(arg);
}
public IArgument Map(ArgumentAttribute argAttrib, PropertyInfo pi, ICliConfig config, string parent)
{
Type argType = pi.PropertyType;
if (argAttrib.Dynamic)
{
if (!typeof(IEnumerable).IsAssignableFrom(argType))
{
throw new ArgumentException(
$"dynamic property type must be assignable to {typeof( IEnumerable<> )} "
+ $"but was {argType} for {pi.Name}");
}
argType = argType.GenericTypeArguments[0];
}
Func <ICliConfig, string, bool, Argument> map = GetMap(argType);
Argument arg = map(
config,
argAttrib.Name ?? (string.IsNullOrEmpty(parent)? pi.Name : pi.Name.Replace(parent, string.Empty)),
argAttrib.Optional);
arg.Description = argAttrib.Description;
return(arg);
}
private static IViolation<ICliSpecification> CheckFlagNamesAndOptionAliases(
UniqueNames _this,
ICliSpecification subject,
ICliConfig conf ) {
bool CmpOptAliasFlag( IOption opt, IFlag flag ) {
return CmpChars(
// ReSharper disable once PossibleInvalidOperationException
opt.FlagAlias.Value,
flag.Name,
conf?.CaseSensitiveFlags??true );
}
IOption opt1 = subject.Options.FirstOrDefault(
o1 => o1.FlagAlias.HasValue&&subject.Flags.Any( f1 => CmpOptAliasFlag( o1, f1 ) ) );
if( opt1 != null ) {
IFlag flag1 = subject.Flags.First( f1 => CmpOptAliasFlag( opt1, f1 ) );
return new Violation<ICliSpecification>(
_this,
Enumerable.Empty<ISolution<ICliSpecification>>( ),
$"name collision between option {opt1.Name} flag alias and flag {flag1.Name}" );
}
return NonViolation<ICliSpecification>.Instance;
}
public HelpOption(ICliConfig config, char?flag = null) : base(
new UnifiedName("help"),
true,
flag ?? HelpFlagFromPrefix(config.FlagPrefix( )),
null,
null)
{
}
public void Apply(IParserResult subject, IBehaviors context)
{
ICliConfig config = context.Get <ConfigBehavior>( ).Config;
(subject as ParserResult)?.SetArgument(
Target,
config.Prompt(config, subject, Target));
}
public ConflictResolver(
ICliConfig config,
ICliSpecification spec = null,
Func <IList <ISolution <IParserResult> >, ISolution <IParserResult> > userPrompt = null)
{
_config = config;
_rules = spec?.Rules ?? Enumerable.Empty <IRule <IParserResult> >( );
_userPrompt = userPrompt ?? UserPrompt;
}
public InvalidFlagParser(ICliSpecification spec)
{
ICliConfig conf = spec.Config;
_flagPrefix = spec.Config.FlagPrefix( );
_cmpChars = conf.CaseSensitiveFlags
? (Func <char, char, bool>)((c1, c2) => c1 == c2)
: (c1, c2) => char.ToUpperInvariant(c1) == char.ToUpperInvariant(c2);
}
public CliSpecification(
ICliConfig config = null,
IArgument dynamicArgument = null,
IEnumerable <IArgument> args = null) : this(
config,
dynamicArgument,
args?.ToArray( ))
{
}
public FloatArg(
string name,
string description,
ICliConfig config,
bool optional = true) :
base(name, description, optional)
{
_config = config;
}
public OptionParser(ICliSpecification spec)
{
_options = spec.Options.ToList( );
_conf = spec.Config;
_optionPrefix = spec.Config.OptionPrefix( );
_cmpChars = _conf.CaseSensitiveOptions
? (Func <char, char, bool>)((c1, c2) => c1 == c2)
: (c1, c2) => char.ToUpperInvariant(c1) == char.ToUpperInvariant(c2);
}
public CliSpecification(
ICliConfig config = null,
IArgument dynamicArgument = null,
params IArgument[] args) : base(true, dynamicArgument, args)
{
Config = config ?? commons.config.Config.New <ICliConfig>( );
if (Config.AutoAddHelpOption)
{
Options.Add(HelpOption = new HelpOption(Config));
}
}
public FlagParser(ICliSpecification spec)
{
ICliConfig conf = spec.Config;
_flags = spec.Flags.ToList( );
_options = spec.Options.Where(o => o.FlagAlias.HasValue).ToList( );
_matches = new List <IItem>( );
_flagPrefix = spec.Config.FlagPrefix( );
_cmpChars = conf.CaseSensitiveFlags
? (Func <char, char, bool>)((c1, c2) => c1 == c2)
: (c1, c2) => char.ToUpperInvariant(c1) == char.ToUpperInvariant(c2);
}
public FloatArg(
string name,
string description,
ICliConfig config,
float minValue,
bool optional = true) : this(
name,
description,
config,
optional)
{
MinValue = minValue;
}
public DoubleArg(
string name,
string description,
ICliConfig config,
double minValue,
bool optional = true) : this(
name,
description,
config,
optional)
{
MinValue = minValue;
}
public LongArg(
string name,
string description,
ICliConfig config,
long minValue,
bool optional = true) : this(
name,
description,
config,
optional)
{
MinValue = minValue;
}
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));
}
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 IntArg(
string name,
string description,
ICliConfig config,
int minValue,
int maxValue,
bool optional = true) : this(
name,
description,
config,
minValue,
optional)
{
MaxValue = maxValue;
}
public override IViolation<ICliSpecification> Check(
ICliSpecification subject,
IBehaviors context = null ) {
ConfigBehavior cb = null;
context?.TryGet( out cb );
ICliConfig conf = cb?.Config;
foreach( Func<UniqueNames, ICliSpecification, ICliConfig, IViolation<ICliSpecification>> check
in __checks ) {
IViolation<ICliSpecification> violation = check( this, subject, conf );
if( violation != NonViolation<ICliSpecification>.Instance )
return violation;
}
return NonViolation<ICliSpecification>.Instance;
}
private static IViolation<ICliSpecification> CheckFlagNames(
UniqueNames _this,
ICliSpecification subject,
ICliConfig conf ) {
bool CmpFlagNames( IFlag f1, IFlag f2 ) {
return f1 != f2&&CmpChars( f1.Name, f2.Name, conf?.CaseSensitiveFlags??true );
}
IFlag flag1 =
subject.Flags.FirstOrDefault( f1 => subject.Flags.Any( f2 => CmpFlagNames( f1, f2 ) ) );
if( flag1 != null ) {
IFlag flag2 = subject.Flags.First( f2 => CmpFlagNames( flag1, f2 ) );
return new Violation<ICliSpecification>(
_this,
Enumerable.Empty<ISolution<ICliSpecification>>( ),
$"name collision between flags {flag1.Name} and {flag2.Name}" );
}
return NonViolation<ICliSpecification>.Instance;
}
private static IViolation<ICliSpecification> CheckOptionAliases(
UniqueNames _this,
ICliSpecification subject,
ICliConfig conf ) {
bool CmpOptAliases( IOption o1, IOption o2 ) {
return o1 != o2&&
o1.FlagAlias.HasValue&&
o2.FlagAlias.HasValue&&
CmpChars( o1.FlagAlias.Value, o2.FlagAlias.Value, conf?.CaseSensitiveFlags??true );
}
IOption opt1 = subject.Options.FirstOrDefault( o1 => subject.Options.Any( o2 => CmpOptAliases( o1, o2 ) ) );
if( opt1 != null ) {
IOption opt2 = subject.Options.First(
o2 => CmpOptAliases( opt1, o2 ) );
return new Violation<ICliSpecification>(
_this,
Enumerable.Empty<ISolution<ICliSpecification>>( ),
$"flag alias name collision between options {opt1.Name} and {opt2.Name}" );
}
return NonViolation<ICliSpecification>.Instance;
}
public IArgument Map(FirstArgumentAttribute argAttrib, string name, Type t, ICliConfig config)
{
if (argAttrib?.Dynamic ?? false)
{
if (!typeof(IEnumerable).IsAssignableFrom(t))
{
throw new ArgumentException(
$"dynamic property type must be assignable to {typeof( IEnumerable<> )} but was {t} for {name}");
}
t = t.GenericTypeArguments[0];
}
Func <ICliConfig, string, bool, Argument> map = GetMap(t);
Argument arg = map(
config,
argAttrib?.Name ?? name,
true);
arg.Description = argAttrib?.Description;
return(arg);
}
private static IViolation<ICliSpecification> CheckOptionNames(
UniqueNames _this,
ICliSpecification subject,
ICliConfig conf ) {
bool CmpOptNames( IOption o1, IOption o2 ) {
return o1 != o2&&o1.Name.Equals(
o2.Name,
conf?.CaseSensitiveOptions??true
? StringComparison.Ordinal
: StringComparison.OrdinalIgnoreCase );
}
IOption opt1 = subject.Options.FirstOrDefault( o1 => subject.Options.Any( o2 => CmpOptNames( o1, o2 ) ) );
if( opt1 != null ) {
IOption opt2 = subject.Options.First( o2 => CmpOptNames( opt1, o2 ) );
return new Violation<ICliSpecification>(
_this,
Enumerable.Empty<ISolution<ICliSpecification>>( ),
$"name collision between options {opt1.Name} and {opt2.Name}" );
}
return NonViolation<ICliSpecification>.Instance;
}
public override bool CanStartWithPrefix(ICliConfig conf)
{
return(ArgumentHelper.SignedNumberCanStartWithPrefixCheck(conf));
}
private static Argument GetDirectoryArg(ICliConfig cliConfig, string name, bool optional)
{
// same TODO as above (GetFileArg)
return(new DirectoryArgument(name, null, optional));
}
private static Argument GetFileArg(ICliConfig cliConfig, string name, bool optional)
{
// TODO: issue with order of arguments: interactive set to true here is problematic
return(new FileArgument(name, null, optional));
}
private static Argument GetIntArg(ICliConfig cliConfig, string name, bool optional)
{
return(new IntArg(name, null, cliConfig, optional));
}
public GetCommand(ICliConfig cliConfig, IConsole console, ILogger <GetCommand> logger)
: base(console, logger)
{
_cliConfig = cliConfig;
}
public static string Prompt(ICliConfig config, IParserResult pr, IArgument arg)
{
config.Out.Write($"{Environment.NewLine}Enter value for argument {arg.Name}: ");
return(config.In.ReadLine( ));
}
public PolicyChecker(ICliConfig config)
{
_config = config;
}
