internal bool TryGetAndRemoveAdditionalExplicitParameters(CommandLineArgument argument, out List<string> result) { foreach(var knownKey in AdditionalExplicitParameters.Keys) { if(argument.IsMatch(knownKey)) { result = AdditionalExplicitParameters[knownKey]; AdditionalExplicitParameters.Remove(knownKey); return true; } } result = null; return false; }
/// <summary> /// Always validates the given argument, even if it was not specified by the user (arg will be null in this case). /// If you override this method then you should also override ImplementsValidateAlways so it returns true. ///</summary> /// <param name="argument">The argument that the attribute was placed on.</param> /// <param name="arg">The value specified on the command line or null if the user didn't actually specify a value for the argument. If the user specified the argument name, but not a value then arg will equal string.Empty</param> public virtual void ValidateAlways(CommandLineArgument argument, ref string arg) { throw new NotImplementedException(); }
private ArgAction ParseInternal(CommandLineArgumentsDefinition definition, string[] input) { // TODO - Validation should be consistently done against the definition, not against the raw type if (definition.ValidationEnabled && definition.ArgumentScaffoldType != null && validatedScaffoldTypes.Contains(definition.ArgumentScaffoldType) == false) { ValidateArgScaffold(definition.ArgumentScaffoldType); validatedScaffoldTypes.Add(definition.ArgumentScaffoldType); } definition.Clean(); var context = ArgHook.HookContext.Current; context.Definition = definition; _ambientDefinition = definition; definition.Validate(context); if (definition.ArgumentScaffoldType != null) { context.Args = ObjectFactory.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); } if (context.ParserData.AdditionalExplicitParameters.Count > 0) { throw new UnexpectedArgException("Unexpected named argument: " + context.ParserData.AdditionalExplicitParameters.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, }); }
public abstract bool TryComplete(bool shift, CommandLineArgument context, string soFar, out string completion);
internal ITabCompletionSource CreateTabCompletionSource(CommandLineArgumentsDefinition definition, CommandLineArgument argument) { if (this.CompletionSourceType.GetInterfaces().Contains(typeof(ITabCompletionSource)) == false) { throw new InvalidArgDefinitionException("The type " + this.CompletionSourceType.FullName + " does not implement ITabCompletionSource. The target argument was " + argument.DefaultAlias); } ITabCompletionSource ret; if (this.CompletionSourceType.IsSubclassOf(typeof(ArgumentAwareTabCompletionSource))) { ret = (ITabCompletionSource)Activator.CreateInstance(this.CompletionSourceType, definition, argument); } else { var toWrap = (ITabCompletionSource)Activator.CreateInstance(this.CompletionSourceType); ret = new ArgumentAwareWrapperTabCompletionSource(definition, argument, toWrap); } return(ret); }
internal static CommandLineAction Create(MethodInfo actionMethod, List <string> knownAliases) { var ret = PropertyInitializer.CreateInstance <CommandLineAction>(); ret.ActionMethod = actionMethod; ret.Source = actionMethod; ret.Aliases.Add(actionMethod.Name); ret.Metadata.AddRange(actionMethod.Attrs <IArgMetadata>().AssertAreAllInstanceOf <ICommandLineActionMetadata>()); ret.IgnoreCase = true; if (actionMethod.DeclaringType.HasAttr <ArgIgnoreCase>() && actionMethod.DeclaringType.Attr <ArgIgnoreCase>().IgnoreCase == false) { ret.IgnoreCase = false; } if (actionMethod.HasAttr <ArgIgnoreCase>() && actionMethod.Attr <ArgIgnoreCase>().IgnoreCase == false) { ret.IgnoreCase = false; } if (actionMethod.GetParameters().Length == 1 && ArgRevivers.CanRevive(actionMethod.GetParameters()[0].ParameterType) == false) { ret.Arguments.AddRange(actionMethod.GetParameters()[0].ParameterType.GetProperties(BindingFlags.Public | BindingFlags.Instance).Where(p => CommandLineArgument.IsArgument(p)).Select(p => CommandLineArgument.Create(p, knownAliases))); } else if (actionMethod.GetParameters().Length > 0 && actionMethod.GetParameters().Where(p => ArgRevivers.CanRevive(p.ParameterType) == false).Count() == 0) { ret.Arguments.AddRange(actionMethod.GetParameters().Where(p => CommandLineArgument.IsArgument(p)).Select(p => CommandLineArgument.Create(p))); foreach (var arg in (ret.Arguments).Where(a => a.Position >= 0)) { arg.Position++; // Since position 0 is reserved for the action specifier } } else if (actionMethod.GetParameters().Length > 0) { throw new InvalidArgDefinitionException("Your action method contains a parameter that cannot be revived on its own. That is only valid if the non-revivable parameter is the only parameter. In that case, the properties of that parameter type will be used."); } return(ret); }
internal ArgumentAwareTabCompletionSource(CommandLineArgumentsDefinition definition, CommandLineArgument target) { this.definition = definition; this.argument = target; }
public ArgumentAwareWrapperSmartTabCompletionSource(CommandLineArgumentsDefinition definition, CommandLineArgument target, ITabCompletionSource toWrap) { this.Target = target; this.Definition = definition; this.WrappedSource = toWrap; }