private ArgAction ParseInternal(CommandLineArgumentsDefinition definition, string[] input)
{
// TODO - Validation should be consistently done against the definition, not against the raw type
if (definition.ArgumentScaffoldType != null)
{
ValidateArgScaffold(definition.ArgumentScaffoldType);
}
var context = ArgHook.HookContext.Current;
context.Definition = definition;
_ambientDefinition = definition;
definition.Validate(context);
if (definition.ArgumentScaffoldType != null)
{
context.Args = Activator.CreateInstance(definition.ArgumentScaffoldType);
}
context.CmdLineArgs = input;
context.RunBeforeParse();
context.ParserData = ArgParser.Parse(definition, context.CmdLineArgs);
var actionToken = context.CmdLineArgs.FirstOrDefault();
var actionQuery = context.Definition.Actions.Where(a => a.IsMatch(actionToken));
if (actionQuery.Count() == 1)
{
context.SpecifiedAction = actionQuery.First();
}
else if (actionQuery.Count() > 1)
{
throw new InvalidArgDefinitionException("There are multiple actions that match argument '" + actionToken + "'");
}
context.RunBeforePopulateProperties();
CommandLineArgument.PopulateArguments(context.Definition.Arguments, context);
context.Definition.SetPropertyValues(context.Args);
object actionArgs = null;
object[] actionParameters = null;
if (context.SpecifiedAction == null && context.Definition.Actions.Count > 0)
{
if (context.CmdLineArgs.FirstOrDefault() == null)
{
throw new MissingArgException("No action was specified");
}
else
{
throw new UnknownActionArgException(string.Format("Unknown action: '{0}'", context.CmdLineArgs.FirstOrDefault()));
}
}
else if (context.SpecifiedAction != null)
{
PropertyInfo actionProp = null;
if (context.Definition.ArgumentScaffoldType != null)
{
actionProp = ArgAction.GetActionProperty(context.Definition.ArgumentScaffoldType);
}
if (actionProp != null)
{
actionProp.SetValue(context.Args, context.SpecifiedAction.Aliases.First(), null);
}
context.ParserData.ImplicitParameters.Remove(0);
CommandLineArgument.PopulateArguments(context.SpecifiedAction.Arguments, context);
}
context.RunAfterPopulateProperties();
if (context.SpecifiedAction != null)
{
actionArgs = context.SpecifiedAction.PopulateArguments(context.Args, ref actionParameters);
}
if (context.Definition.Metadata.HasMeta <AllowUnexpectedArgs>() == false)
{
if (context.ParserData.ImplicitParameters.Count > 0)
{
throw new UnexpectedArgException("Unexpected unnamed argument: " + context.ParserData.ImplicitParameters.First().Value);
}
if (context.ParserData.ExplicitParameters.Count > 0)
{
throw new UnexpectedArgException("Unexpected named argument: " + context.ParserData.ExplicitParameters.First().Key);
}
}
else
{
definition.UnexpectedExplicitArguments = context.ParserData.ExplicitParameters;
definition.UnexpectedImplicitArguments = context.ParserData.ImplicitParameters;
}
if (definition.ArgumentScaffoldType != null)
{
if (AmbientArgs.ContainsKey(definition.ArgumentScaffoldType))
{
AmbientArgs[definition.ArgumentScaffoldType] = context.Args;
}
else
{
AmbientArgs.Add(definition.ArgumentScaffoldType, context.Args);
}
}
PropertyInfo actionArgsPropertyInfo = null;
if (context.SpecifiedAction != null)
{
if (context.SpecifiedAction.Source is PropertyInfo)
{
actionArgsPropertyInfo = context.SpecifiedAction.Source as PropertyInfo;
}
else if (context.SpecifiedAction.Source is MethodInfo)
{
actionArgsPropertyInfo = new ArgActionMethodVirtualProperty(context.SpecifiedAction.Source as MethodInfo);
}
}
return(new ArgAction()
{
Value = context.Args,
ActionArgs = actionArgs,
ActionParameters = actionParameters,
ActionArgsProperty = actionArgsPropertyInfo,
ActionArgsMethod = context.SpecifiedAction != null ? context.SpecifiedAction.ActionMethod : null,
Definition = context.Definition,
Context = context,
});
}