private static bool InternalTryParse <TOptions>(string[] args, ParserOptions parserOptions, out TOptions options, out Exception ex)
where TOptions : new()
{
options = default;
ex = null;
TypeArgumentInfo arguments = null;
try
{
// build a list of properties for the type passed in.
// this will throw for cases where the type is incorrecly annotated with attributes
TypeHelpers.ScanTypeForProperties <TOptions>(out arguments);
// before we do anything, let's expand the response files (if any).
args = ExpandResponseFiles(args);
// short circuit the request for help!
if (args.Length == 1)
{
if (args[0] == HelpGenerator.RequestShortHelpParameter || args[0] == "/?")
{
HelpGenerator.DisplayHelp(HelpFormat.Short, arguments, ColorScheme.Get());
ex = new HelpRequestedException();
return(false);
}
else if (args[0] == HelpGenerator.RequestLongHelpParameter)
{
HelpGenerator.DisplayHelp(HelpFormat.Full, arguments, ColorScheme.Get());
ex = new HelpRequestedException();
return(false);
}
}
// we have groups!
if (!arguments.ArgumentGroups.ContainsKey(string.Empty))
{
return(ParseCommandGroups(args, ref options, arguments, parserOptions));
}
// parse the arguments and build the options object
options = InternalParse <TOptions>(args, 0, arguments.ArgumentGroups[string.Empty], parserOptions);
return(true);
}
catch (Exception innerParserException)
{
ex = new ParserException(innerParserException.Message, innerParserException);
if (parserOptions.LogParseErrorToConsole)
{
string errorFormat = $"[{ColorScheme.Get().ErrorColor}!Error]: {{0}} {{1}}";
Colorizer.WriteLine(errorFormat, ex.Message, Environment.NewLine);
HelpGenerator.DisplayHelp(HelpFormat.Short, arguments, ColorScheme.Get());
}
return(false);
}
}
/// <summary>
/// Display the help based on the <typeparamref name="TOptions"/> type provided
/// </summary>
/// <typeparam name="TOptions">The type for which to generate the help.</typeparam>
/// <param name="helpFormat">Describes the level of details to generate for the help message.</param>
public static void DisplayHelp <TOptions>(HelpFormat helpFormat = HelpFormat.Short)
{
if (helpFormat != HelpFormat.Short && helpFormat != HelpFormat.Full)
{
throw new ParserException($"Unrecognized help format {helpFormat}", null);
}
try
{
// build a list of properties for the type passed in.
// this will throw for cases where the type is incorrecly annotated with attributes
TypeHelpers.ScanTypeForProperties <TOptions>(out TypeArgumentInfo arguments);
// If we get here, the options type is well defined, so let's display the help.
HelpGenerator.DisplayHelp(helpFormat, arguments, ColorScheme.Get());
}
catch (Exception ex)
{
string errorFormat = $"[{ColorScheme.Get().ErrorColor}!Error]: {{0}} {{1}}";
// If we were asked to display the help and something went wrong, display the error that went wrong.
Colorizer.WriteLine(errorFormat, ex.Message, Environment.NewLine);
}
}
private static bool ParseCommandGroups <TOptions>(string[] args, ref TOptions options, TypeArgumentInfo arguments, ParserOptions parserOptions) where TOptions : new()
{
if (arguments.ActionArgument == null)
{
throw new ArgumentException("Cannot have groups unless Command argument has been specified");
}
if (args.Length == 0)
{
throw new ArgumentException("Required parameters have not been specified");
}
// parse based on the command passed in (the first arg).
if (!arguments.ArgumentGroups.ContainsKey(args[0]))
{
throw new ArgumentException($"Unknown command '{args[0]}'");
}
// short circuit the request for help!
if (args.Length == 2 && (args[1] == "/?" || args[1] == "-?"))
{
HelpGenerator.DisplayHelpForCommmand(args[0], arguments.ArgumentGroups[args[0]], ColorScheme.Get());
// if we wanted the help, then we successfully parsed it!
return(true);
}
options = InternalParse <TOptions>(args, 1, arguments.ArgumentGroups[args[0]], parserOptions);
arguments.ActionArgument.SetValue(options, PropertyHelpers.GetValueAsType(args[0], arguments.ActionArgument));
return(true);
}