private int Execute(List <string> args)
{
CommandLineApplication command = this;
CommandOption option = null;
IEnumerator <CommandArgument> arguments = null;
for (var index = 0; index < args.Count; index++)
{
var arg = args[index];
if (command.ResponseFileHandling != ResponseFileHandling.Disabled && index > _responseFileArgsEnd && arg.Length > 1 && arg[0] == '@')
{
var path = arg.Substring(1);
var fullPath = Path.IsPathRooted(path)
? path
: Path.Combine(command.WorkingDirectory, path);
IList <string> rspArgs;
try
{
rspArgs = ResponseFileParser.Parse(fullPath, command.ResponseFileHandling);
}
catch (Exception ex)
{
throw new CommandParsingException(this, $"Could not parse the response file '{arg}'", ex);
}
args.InsertRange(index + 1, rspArgs);
_responseFileArgsEnd = index + rspArgs.Count;
continue;
}
var processed = false;
if (!processed && option == null)
{
string[] longOption = null;
string[] shortOption = null;
if (arg != null)
{
if (arg.StartsWith("--"))
{
longOption = arg.Substring(2).Split(new[] { ':', '=' }, 2);
}
else if (arg.StartsWith("-"))
{
shortOption = arg.Substring(1).Split(new[] { ':', '=' }, 2);
}
}
if (longOption != null)
{
processed = true;
var longOptionName = longOption[0];
option = command.GetOptions().SingleOrDefault(opt => string.Equals(opt.LongName, longOptionName, StringComparison.Ordinal));
if (option == null)
{
if (string.IsNullOrEmpty(longOptionName) && !command.ThrowOnUnexpectedArgument && AllowArgumentSeparator)
{
// skip over the '--' argument separator
index++;
}
HandleUnexpectedArg(command, args, index, argTypeName: "option");
break;
}
// If we find a help/version option, show information and stop parsing
if (command.OptionHelp == option)
{
command.ShowHelp();
option.TryParse(null);
var parent = command;
while (parent.Parent != null)
{
parent = parent.Parent;
}
parent.SelectedCommand = command;
if (StopParsingAfterHelpOption)
{
return(0);
}
}
else if (command.OptionVersion == option)
{
command.ShowVersion();
option.TryParse(null);
var parent = command;
while (parent.Parent != null)
{
parent = parent.Parent;
}
parent.SelectedCommand = command;
if (StopParsingAfterVersionOption)
{
return(0);
}
}
if (longOption.Length == 2)
{
if (!option.TryParse(longOption[1]))
{
command.ShowHint();
throw new CommandParsingException(command, $"Unexpected value '{longOption[1]}' for option '{option.LongName}'");
}
option = null;
}
else if (option.OptionType == CommandOptionType.NoValue)
{
// No value is needed for this option
option.TryParse(null);
option = null;
}
}
if (shortOption != null)
{
processed = true;
option = command.GetOptions().SingleOrDefault(opt => string.Equals(opt.ShortName, shortOption[0], StringComparison.Ordinal));
// If not a short option, try symbol option
if (option == null)
{
option = command.GetOptions().SingleOrDefault(opt => string.Equals(opt.SymbolName, shortOption[0], StringComparison.Ordinal));
}
if (option == null)
{
HandleUnexpectedArg(command, args, index, argTypeName: "option");
break;
}
// If we find a help/version option, show information and stop parsing
if (command.OptionHelp == option)
{
command.ShowHelp();
return(0);
}
else if (command.OptionVersion == option)
{
command.ShowVersion();
return(0);
}
if (shortOption.Length == 2)
{
if (!option.TryParse(shortOption[1]))
{
command.ShowHint();
throw new CommandParsingException(command, $"Unexpected value '{shortOption[1]}' for option '{option.LongName}'");
}
option = null;
}
else if (option.OptionType == CommandOptionType.NoValue)
{
// No value is needed for this option
option.TryParse(null);
option = null;
}
}
}
if (!processed && option != null)
{
processed = true;
if (!option.TryParse(arg))
{
command.ShowHint();
throw new CommandParsingException(command, $"Unexpected value '{arg}' for option '{option.LongName}'");
}
option = null;
}
if (!processed && arguments == null)
{
var currentCommand = command;
foreach (var subcommand in command.Commands)
{
if (string.Equals(subcommand.Name, arg, StringComparison.OrdinalIgnoreCase))
{
processed = true;
command = subcommand;
break;
}
}
// If we detect a subcommand
if (command != currentCommand)
{
processed = true;
}
}
if (!processed)
{
if (arguments == null)
{
arguments = new CommandArgumentEnumerator(command.Arguments.GetEnumerator());
}
if (arguments.MoveNext())
{
processed = true;
arguments.Current.Values.Add(arg);
}
}
if (!processed)
{
HandleUnexpectedArg(command, args, index, argTypeName: "command or argument");
break;
}
}
if (option != null)
{
command.ShowHint();
throw new CommandParsingException(command, $"Missing value for option '{option.LongName}'");
}
return(command.Invoke());
}
private static void _ConfigureInvoker(CommandLineApplication command, Type type, MethodInfo methodInfo)
{
var helpOpt = command.HelpOption();
var parameters = methodInfo.GetParameters();
foreach (var param in parameters)
{
if (param.GetCustomAttribute <ConventionOptionAttribute>() != null)
{
_RegisterOption(command, param.ParameterType, _PascalToKebab(param.Name), param.GetCustomAttribute <ConventionDescriptionAttribute>()?.Text ?? "", param.GetCustomAttribute <ConventionIsRequiredAttribute>() != null);
}
else if (_IsExpectingSingleValue(param.ParameterType) || _IsExpectingMultiValue(param.ParameterType))
{
var desc = param.GetCustomAttribute <ConventionDescriptionAttribute>();
var description = desc?.Text ?? "";
command.Argument(param.Name, description, _IsExpectingMultiValue(param.ParameterType));
}
}
command.OnExecute(() =>
{
if (helpOpt.HasValue())
{
return(0);
}
CancellationTokenSource cts = null;
var obj = Activator.CreateInstance(type);
var alloptions = command.GetOptions();
foreach (var prop in type.GetProperties())
{
var option = alloptions.FirstOrDefault(opt => opt.LongName == _PascalToKebab(prop.Name));
if (option != null)
{
prop.SetValue(obj, _ExtractValueFromOption(prop.PropertyType, option));
}
}
if (type.GetMethod("Initialize") != null)
{
type.GetMethod("Initialize").Invoke(obj, null);
}
var allArgs = command.Arguments;
var handlerParams = new List <object>();
foreach (var param in methodInfo.GetParameters())
{
var arg = allArgs.FirstOrDefault(a => a.Name == param.Name);
var option = alloptions.FirstOrDefault(opt => opt.LongName == _PascalToKebab(param.Name));
object valueToAdd = null;
if (arg != null)
{
if (arg.MultipleValues)
{
valueToAdd = _ParseMultiValue(param.ParameterType, arg.Values);
}
else if (param.HasDefaultValue && arg.Value == null)
{
valueToAdd = param.DefaultValue;
}
else
{
valueToAdd = _ParseSingleValue(param.ParameterType, arg.Value);
}
}
else if (option != null)
{
if (param.HasDefaultValue && option.HasValue() == false)
{
valueToAdd = param.DefaultValue;
}
else
{
valueToAdd = _ExtractValueFromOption(param.ParameterType, option);
}
}
else if (param.ParameterType == typeof(CancellationToken))
{
if (cts == null)
{
cts = new CancellationTokenSource();
}
valueToAdd = cts.Token;
}
else
{
if (type.GetMethod("ResolveType") != null)
{
valueToAdd = type.GetMethod("ResolveType").Invoke(obj, new[] { param.ParameterType });
}
else
{
throw new Exception("Cannot resolve parameter type");
}
}
if (param.GetCustomAttribute <ConventionIsRequiredAttribute>() != null && valueToAdd == null)
{
throw new Exception($"{param.Name} is required");
}
handlerParams.Add(valueToAdd);
}
var res = methodInfo.Invoke(obj, handlerParams.ToArray());
if (res.GetType() == typeof(Task <int>))
{
var task = (Task <int>)res;
System.Console.CancelKeyPress += (sender, e) =>
{
cts?.Cancel();
Task.WaitAll(new[] { task }, 10000);
};
AppDomain.CurrentDomain.ProcessExit += (sender, e) =>
{
cts?.Cancel();
Task.WaitAll(new[] { task }, 10000);
};
Task.WaitAll(task);
return(task.Result);
}
else
{
return((int)res);
}
});
}