private static int DisplayCommandLine(ArgumentGroupInfo arguments)
{
int maxStringSize = 0;
for (int i = 0; i < arguments.RequiredArguments.Count; i++)
{
if (!arguments.RequiredArguments.ContainsKey(i))
{
Colorizer.WriteLine($"{Environment.NewLine}[Red!Error]: Required argument expected at position [Cyan!{i}]. Type declares arguments at position(s) [Cyan!{string.Join(",", arguments.RequiredArguments.Keys.OrderBy(x => x))}]. [Red!Check type definition].");
return(-1);
}
var b = arguments.RequiredArguments[i].GetCustomAttribute <ActualArgumentAttribute>();
maxStringSize = Math.Max(maxStringSize, b.Name.Length);
Colorizer.Write("[Cyan!{0}] ", b.Name);
}
foreach (var item in arguments.OptionalArguments.Values)
{
var b = item.GetCustomAttribute <ActualArgumentAttribute>();
maxStringSize = Math.Max(maxStringSize, b.Name.Length);
Colorizer.Write("\\[-[Yellow!{0}] value\\] ", b.Name);
}
Colorizer.WriteLine(string.Empty);
return(maxStringSize);
}
private static int DisplayCommandLine(ArgumentGroupInfo arguments, IColors colors)
{
int maxStringSize = 0;
for (int i = 0; i < arguments.RequiredArguments.Count; i++)
{
if (!arguments.RequiredArguments.ContainsKey(i))
{
string requiredArgError = $"{Environment.NewLine}[{colors.ErrorColor}!Error]: Required argument expected at position[{colors.RequiredArgumentColor}!{{0}}]. Type declares arguments at position(s) [{colors.RequiredArgumentColor}!{{1}}]. [{colors.ErrorColor}!Check type definition].";
Colorizer.WriteLine(requiredArgError, i, string.Join(",", arguments.RequiredArguments.Keys.OrderBy(x => x)));
return(-1);
}
var b = arguments.RequiredArguments[i].GetCustomAttribute <ActualArgumentAttribute>();
maxStringSize = Math.Max(maxStringSize, b.Name.Length);
string argumentName = $"[{colors.RequiredArgumentColor}!{{0}}] ";
Colorizer.Write(argumentName, b.Name);
}
foreach (var item in arguments.OptionalArguments.Values)
{
var b = item.GetCustomAttribute <ActualArgumentAttribute>();
maxStringSize = Math.Max(maxStringSize, b.Name.Length);
string optionalArgumentFormat = $"\\[-[{colors.OptionalArgumentColor}!{{0}}] value\\] ";
Colorizer.Write(optionalArgumentFormat, b.Name);
}
Colorizer.WriteLine(string.Empty);
return(maxStringSize);
}
public static void DisplayHelpForCommmand(string command, ArgumentGroupInfo propertyGroup, IColors colors)
{
string exeName = Assembly.GetEntryAssembly()?.GetName()?.Name;
Colorizer.WriteLine("Usage: ");
DisplayDetailedArgumentHelp(exeName, command, propertyGroup, colors);
}
private static void DisplayDetailedParameterHelp(ArgumentGroupInfo arguments)
{
int maxStringSize = DisplayCommandLine(arguments);
if (maxStringSize < 0)
{
return;
}
// write out the required arguments
for (int i = 0; i < arguments.RequiredArguments.Count; i++)
{
var b = arguments.RequiredArguments[i].GetCustomAttribute <ActualArgumentAttribute>();
if (TypeHelpers.IsEnum(arguments.RequiredArguments[i].PropertyType))
{
Colorizer.WriteLine(" - [Cyan!{0}] : {1} (one of [Green!{2}], [Cyan!required])", b.Name.PadRight(maxStringSize), b.Description, GetEnumValuesAsString(arguments.RequiredArguments[i].PropertyType));
}
else
{
Colorizer.WriteLine(" - [Cyan!{0}] : {1} ([Green!{2}], [Cyan!required])", b.Name.PadRight(maxStringSize), b.Description, GetFriendlyTypeName(arguments.RequiredArguments[i].PropertyType));
}
}
// write out the optional arguments
foreach (var item in arguments.OptionalArguments.Values)
{
var b = item.GetCustomAttribute <OptionalArgumentAttribute>();
if (TypeHelpers.IsEnum(item.PropertyType))
{
Colorizer.WriteLine(" - [Yellow!{0}] : {1} (one of [Green!{2}], default=[Yellow!{3}])", b.Name.PadRight(maxStringSize), b.Description, GetEnumValuesAsString(item.PropertyType), b.DefaultValue);
}
else
{
Colorizer.WriteLine(" - [Yellow!{0}] : {1} ([Green!{3}], default=[Yellow!{2}])", b.Name.PadRight(maxStringSize), b.Description, b.DefaultValue ?? "", GetFriendlyTypeName(item.PropertyType));
}
}
Colorizer.WriteLine(string.Empty);
}
private static void DisplayDetailedParameterHelp(ArgumentGroupInfo arguments, IColors colors)
{
int maxStringSize = DisplayCommandLine(arguments, colors);
// write out the required arguments
for (int i = 0; i < arguments.RequiredArguments.Count; i++)
{
var b = arguments.RequiredArguments[i].GetCustomAttribute <ActualArgumentAttribute>();
if (TypeHelpers.IsEnum(arguments.RequiredArguments[i].PropertyType))
{
string requiredArgFormatDetailed = $" - [{colors.RequiredArgumentColor}!{{0}}] : {{1}} (one of [{colors.ArgumentValueColor}!{{2}}], [{colors.RequiredArgumentColor}!required])";
Colorizer.WriteLine(requiredArgFormatDetailed, b.Name.PadRight(maxStringSize), b.Description, GetEnumValuesAsString(arguments.RequiredArguments[i].PropertyType));
}
else
{
string requiredArgFormatDetailed = $" - [{colors.RequiredArgumentColor}!{{0}}] : {{1}} ([{colors.ArgumentValueColor}!{{2}}], [{colors.RequiredArgumentColor}!required])";
Colorizer.WriteLine(requiredArgFormatDetailed, b.Name.PadRight(maxStringSize), b.Description, GetFriendlyTypeName(arguments.RequiredArguments[i].PropertyType));
}
}
// write out the optional arguments
foreach (var item in arguments.OptionalArguments.Values)
{
var b = item.GetCustomAttribute <OptionalArgumentAttribute>();
if (TypeHelpers.IsEnum(item.PropertyType))
{
string optionalFormatArg = $" - [{colors.OptionalArgumentColor}!{{0}}] : {{1}} (one of [{colors.ArgumentValueColor}!{{2}}], default=[{colors.OptionalArgumentColor}!{{3}}])";
Colorizer.WriteLine(optionalFormatArg, b.Name.PadRight(maxStringSize), b.Description, GetEnumValuesAsString(item.PropertyType), b.DefaultValue);
}
else
{
string optionalFormatArg = $" - [{colors.OptionalArgumentColor}!{{0}}] : {{1}} ([{colors.ArgumentValueColor}!{{3}}], default=[{colors.OptionalArgumentColor}!{{2}}])";
Colorizer.WriteLine(optionalFormatArg, b.Name.PadRight(maxStringSize), b.Description, b.DefaultValue ?? "", GetFriendlyTypeName(item.PropertyType));
}
}
Colorizer.WriteLine(string.Empty);
}
private static void DisplayDetailedArgumentHelp(string exeName, string command, ArgumentGroupInfo arguments, IColors colors)
{
string argumentNameFormat = $" [{colors.AssemblyNameColor}!{{ 0}}.exe] ";
Colorizer.Write(argumentNameFormat, exeName);
if (!string.IsNullOrEmpty(command))
{
string formatArgs = $"[{colors.ArgumentGroupColor}!{{0}}] ";
Colorizer.Write(formatArgs, command);
}
DisplayDetailedParameterHelp(arguments, colors);
}
private static void ParseRequiredParameters <TOptions>(string[] args, int offsetInArray, ArgumentGroupInfo TypeArgumentInfo, TOptions options, ref int currentLogicalPosition) where TOptions : new()
{
if (args.Length == 0)
{
throw new ArgumentException("Required parameters have not been specified");
}
int matchedRequiredParameters = 0;
do
{
//set the required property
PropertyInfo propInfo;
if (!TypeArgumentInfo.RequiredArguments.TryGetValue(currentLogicalPosition, out propInfo))
{
break;
}
//make sure that we don't run out of array
if (offsetInArray + currentLogicalPosition >= args.Length)
{
throw new ArgumentException("Required parameters have not been specified");
}
var value = PropertyHelpers.GetValueFromArgsArray(args, offsetInArray, ref currentLogicalPosition, propInfo);
propInfo.SetValue(options, value);
matchedRequiredParameters++;
} while (currentLogicalPosition < args.Length);
// no more? do we have any properties that we have not yet set?
if (TypeArgumentInfo.RequiredArguments.Count != matchedRequiredParameters)
{
throw new ArgumentException("Not all required arguments have been specified");
}
}
private static List <PropertyInfo> ParseOptionalParameters <TOptions>(string[] args, int offsetInArray, ArgumentGroupInfo TypeArgumentInfo, TOptions options, ref int currentLogicalPosition) where TOptions : new()
{
// we are going to assume that all optionl parameters are not matched to values in 'args'
List <PropertyInfo> unmatched = new List <PropertyInfo>(TypeArgumentInfo.OptionalArguments.Values);
// process the optional arguments
while (offsetInArray + currentLogicalPosition < args.Length)
{
if (args[offsetInArray + currentLogicalPosition][0] != '-')
{
throw new ArgumentException("Optional parameter name should start with '-'");
}
PropertyInfo optionalProp = null;
var optionalParamName = args[offsetInArray + currentLogicalPosition].Substring(1);
if (!TypeArgumentInfo.OptionalArguments.TryGetValue(optionalParamName, out optionalProp))
{
throw new ArgumentException($"Could not find argument {args[currentLogicalPosition]}");
}
// skip over the parameter name
currentLogicalPosition++;
var value = PropertyHelpers.GetValueFromArgsArray(args, offsetInArray, ref currentLogicalPosition, optionalProp);
optionalProp.SetValue(options, value);
unmatched.Remove(optionalProp);
}
return(unmatched);
}
private static TOptions InternalParse <TOptions>(string[] args, int offsetInArray, ArgumentGroupInfo arguments) where TOptions : new()
{
TOptions options = new TOptions();
int currentLogicalPosition = 0;
// let's match them to actual required args, in positional
if (arguments.RequiredArguments.Count > 0)
{
ParseRequiredParameters(args, offsetInArray, arguments, options, ref currentLogicalPosition);
}
// we are going to keep track of any properties that have not been specified so that we can set their default value.
var unmatchedOptionalProperties = ParseOptionalParameters(args, offsetInArray, arguments, options, ref currentLogicalPosition);
// for all the remaining optional properties, set their default value.
foreach (var property in unmatchedOptionalProperties)
{
//get the default value..
var value = property.GetCustomAttribute <OptionalArgumentAttribute>();
property.SetValue(options, Convert.ChangeType(value.DefaultValue, property.PropertyType));
}
return(options);
}
private static TOptions InternalParse <TOptions>(string[] args, int offsetInArray, ArgumentGroupInfo arguments, ParserOptions parseOptions)
where TOptions : new()
{
TOptions options = new TOptions();
int currentLogicalPosition = 0;
// let's match them to actual required args, in positional
if (arguments.RequiredArguments.Count > 0)
{
ParseRequiredParameters(args, offsetInArray, arguments, options, ref currentLogicalPosition);
}
// we are going to keep track of any properties that have not been specified so that we can set their default value.
var unmatchedOptionalProperties = ParseOptionalParameters(args, offsetInArray, arguments, options, ref currentLogicalPosition);
// for all the remaining optional properties, set their default value.
foreach (var property in unmatchedOptionalProperties)
{
//get the default value..
var value = property.GetCustomAttribute <OptionalArgumentAttribute>();
object defaultValue = value.DefaultValue;
// If we want to read values from the environment, try to get the value
if (parseOptions.ReadFromEnvironment && !value.IsCollection && parseOptions.VariableNamePrefix != null)
{
var envVar = Environment.GetEnvironmentVariable($"{parseOptions.VariableNamePrefix}{value.Name}");
if (!string.IsNullOrEmpty(envVar))
{
defaultValue = PropertyHelpers.GetValueForProperty(envVar, property);
}
}
property.SetValue(options, Convert.ChangeType(defaultValue, property.PropertyType));
}
return(options);
}
private static void DisplayDetailedArgumentHelp(string exeName, string command, ArgumentGroupInfo arguments)
{
Colorizer.Write(" [White!{0}.exe] ", exeName);
if (!string.IsNullOrEmpty(command))
{
Colorizer.Write("[Green!{0}] ", command);
}
DisplayDetailedParameterHelp(arguments);
}
