/// <summary>
/// Whether or not the there is a named argument/value associated with the supplied argument.
/// </summary>
/// <param name="arg"></param>
/// <returns></returns>
public bool Contains(ArgAttribute arg)
{
if (Named == null || Named.Count == 0)
{
return(false);
}
if (Named.ContainsKey(arg.Name))
{
return(true);
}
if (Named.ContainsKey(arg.Alias))
{
return(true);
}
if (arg.IsCaseSensitive)
{
return(false);
}
if (Named.ContainsKey(arg.NameLowered))
{
return(true);
}
if (Named.ContainsKey(arg.AliasLowered))
{
return(true);
}
return(false);
}
private void AddToLookup(ArgAttribute argAtt)
{
if (argAtt.IsNamed)
{
// Set the name
_named[argAtt.Name] = argAtt;
bool hasAlias = !string.IsNullOrEmpty(argAtt.Alias);
// Set the alias
if (hasAlias)
{
_named[argAtt.Alias] = argAtt;
}
// Lowercase name and alias
if (!argAtt.IsCaseSensitive)
{
_named[argAtt.Name.ToLower()] = argAtt;
}
if (!argAtt.IsCaseSensitive && hasAlias)
{
_named[argAtt.Alias.ToLower()] = argAtt;
}
}
else
{
_positional[argAtt.IndexPosition] = argAtt;
}
}
/// <summary>
/// Validates various aspects of the argument.
/// </summary>
/// <param name="argAttr"></param>
/// <param name="argVal"></param>
/// <param name="errors"></param>
public static bool ValidateArg(ArgAttribute argAttr, string argVal, IList <string> errors)
{
// Arg name or index.
string argId = string.IsNullOrEmpty(argAttr.Name) ? "[" + argAttr.IndexPosition + "]" : argAttr.Name;
int initialErrorCount = errors.Count;
// Argument missing and required.
if (argAttr.IsRequired && string.IsNullOrEmpty(argVal))
{
errors.Add(string.Format("Required argument '{0}' : {1} is missing.", argAttr.Name, argAttr.DataType.FullName));
return(false);
}
// Argument missing and Optional - Can't do much.
if (!argAttr.IsRequired && string.IsNullOrEmpty(argVal))
{
return(true);
}
// File doesn't exist.
if (argAttr.DataType == typeof(System.IO.File) && !System.IO.File.Exists(argVal))
{
errors.Add(string.Format("File '{0}' associated with argument '{1}' does not exist.", argVal, argId));
}
// Wrong data type.
else if (!argAttr.Interpret && !Converter.CanConvertTo(argAttr.DataType, argVal))
{
errors.Add(string.Format("Argument value of '{0}' for '{1}' does not match type {2}.",
argVal, argId, argAttr.DataType.FullName));
}
return(initialErrorCount == errors.Count);
}
private ArgsSchema Add <T>(int indexPosition, string name, string alias, bool isRequired, T defaultValue, string description, string example, string exampleMultipe, bool interpret,
bool isCaseSensitive, string tag, bool onlyForDevelopment)
{
var latest = new ArgAttribute()
{
Name = name,
Alias = alias,
DefaultValue = defaultValue,
Description = description,
DataType = typeof(T),
Example = example,
ExampleMultiple = exampleMultipe,
Interpret = interpret,
IsCaseSensitive = isCaseSensitive,
IsRequired = isRequired,
IsUsedOnlyForDevelopment = onlyForDevelopment,
IndexPosition = indexPosition,
Tag = tag
};
_attributes.Add(latest);
AddToLookup(latest);
_last = latest;
return(this);
}
/// <summary>
/// Set the argument value from command line on the property of the object
/// recieving the value.
/// </summary>
/// <param name="argReciever"></param>
/// <param name="val"></param>
/// <param name="rawArgValue"></param>
private static void SetValue(object argReciever, KeyValuePair <ArgAttribute, PropertyInfo> val, string rawArgValue)
{
ArgAttribute argAttr = val.Key;
// First interpret.
string argValue = rawArgValue;
if (argAttr.Interpret)
{
argValue = Substitute(argValue);
}
ReflectionHelper.SetProperty(argReciever, val.Value, argValue);
}
/// <summary>
/// Validates the index position of the non-named argument.
/// </summary>
/// <param name="argAttr"></param>
/// <param name="positionalArgCount"></param>
/// <param name="errors"></param>
/// <returns></returns>
public static bool ValidateIndex(ArgAttribute argAttr, int positionalArgCount, IList <string> errors)
{
// Now check the positional args.
bool isValidIndex = argAttr.IndexPosition < positionalArgCount;
// Required and positional arg valid.
if (argAttr.IsRequired && !isValidIndex)
{
errors.Add(string.Format("Positional argument at index : [{0}]' was not supplied.", argAttr.IndexPosition));
}
return(isValidIndex);
}
private static bool IsSameArg(string key, ArgAttribute arg)
{
if (string.Compare(key, arg.Name, true) == 0)
{
return(true);
}
if (string.Compare(key, arg.Alias, true) == 0)
{
return(true);
}
return(false);
}
/// <summary>
/// Validate the parsed args supplied with the args specification list.
/// </summary>
/// <param name="parsedArgs"></param>
/// <param name="argSpecs"></param>
/// <param name="errors"></param>
/// <param name="onArgumentValidationSuccessCallback"></param>
public static void Validate(Args parsedArgs, List <ArgAttribute> argSpecs, IList <string> errors,
Action <ArgAttribute, string, int> onArgumentValidationSuccessCallback)
{
// Get all the properties that have arg attributes.
bool hasPositionalArgs = parsedArgs.Positional != null && parsedArgs.Positional.Count > 0;
int positionalArgCount = hasPositionalArgs ? parsedArgs.Positional.Count : 0;
// Go through all the arg specs.
for (int ndx = 0; ndx < argSpecs.Count; ndx++)
{
ArgAttribute argAttr = argSpecs[ndx];
string argVal = string.Empty;
int initialErrorCount = errors.Count;
// Named argument. key=value
if (argAttr.IsNamed)
{
// FIX: Item # 3926 - Case insensitivity not working.
argVal = GetNamedArgValue(argAttr, parsedArgs);
ValidateArg(argAttr, argVal, errors);
}
else
{
// Index argument [0] [1]
bool validIndex = ValidateIndex(argAttr, positionalArgCount, errors);
if (validIndex)
{
argVal = parsedArgs.Positional[argAttr.IndexPosition];
ValidateArg(argAttr, argVal, errors);
}
}
// Notify if successful validation of single attribute.
if (initialErrorCount == errors.Count && onArgumentValidationSuccessCallback != null)
{
onArgumentValidationSuccessCallback(argAttr, argVal, ndx);
}
}
}
private static string GetNamedArgValue(ArgAttribute argAttr, Args args)
{
// Case sensitive
if (argAttr.IsCaseSensitive)
{
return(args.Get <string>(argAttr.Name, string.Empty));
}
// Not case sensitive. Try to match name.
string suppliedName = argAttr.Name;
foreach (var pair in args.Named)
{
if (string.Compare(pair.Key, argAttr.Name, true) == 0)
{
suppliedName = pair.Key;
break;
}
}
// Get the value based on the correct name.
return(args.Get <string>(suppliedName, string.Empty));
}
private static string GetNamedArgValue(ArgAttribute argAttr, Args args)
{
// Case sensitive
if (argAttr.IsCaseSensitive)
{
return(args.Get <string>(argAttr.Name, string.Empty));
}
// Not case sensitive. Try to match name.
string suppliedName = argAttr.Name;
foreach (var pair in args.Named)
{
// Can be either alias or full name.
if (IsSameArg(pair.Key, argAttr))
{
suppliedName = pair.Key;
break;
}
}
// Get the value based on the correct name.
return(args.Get <string>(suppliedName, string.Empty));
}
