private ActionParsedState GetState(ActionParsed actionParsed) { ActionParsedState state = ActionParsedState.None; var countMap = actionParsed.ActionMap.ArgumentsMaps.Count(); var countArgs = actionParsed.Arguments.Count(); var countExtras = actionParsed.ArgumentsExtras.Count(); var allValids = actionParsed.Arguments.All(f => f.ParsingStates.HasFlag(ArgumentParsedState.Valid)); if (countMap == 0 && countArgs == 0 && countExtras == 0) { state |= ActionParsedState.Valid | ActionParsedState.NoArgumentsInMapAndInInput; } else { if (countExtras > 0) { state |= ActionParsedState.HasExtras; } if (allValids) { state |= ActionParsedState.Valid; } else { state |= ActionParsedState.IsInvalid; } } return(state); }
private string GetDebugName(ActionMap map, ActionParsed parsed) { if (map != parsed.ActionMap) throw new Exception("There are errors in one of the methods: GetCurrentMethodMap() or GetCurrentMethodResult()"); var specification = CommandParserUtils.GetMethodSpecification(parsed); return this.GetType().Name + "." + specification; }
/// <summary> /// Initialize /// </summary> /// <param name="actionParsed">ActionParsed of this method</param> public MethodResult(ActionParsed actionParsed) { this.ActionParsed = actionParsed; this.MethodInfo = this.ActionParsed.ActionMap.Method; this.Parameters = this.ActionParsed.Arguments.Where(f => f.IsMapped).ToDictionary(f => f.Name, f => f.Value); this.Target = this.ActionParsed.ActionMap.Target; this.Name = this.ActionParsed.Name; }
public static string GetMethodSpecification(ActionParsed parsed) { var format = "{0}({1})"; string args = null; foreach (var map in parsed.ActionMap.ArgumentsMaps) { var typeName = ReflectionHelper.CSharpName(map.Type); var value = parsed.Arguments.First(f => f.Map == map); var valueWithDesc = value.GetArgumentNameInputted() + " = " + (string.IsNullOrWhiteSpace(value.Raw) ? "?" : value.Raw); args += args == null ? typeName + " " + valueWithDesc : ", " + typeName + " " + valueWithDesc; } return(string.Format(format, parsed.ActionMap.ActionName, args)); }
private void RemoveIncompatibleValidMethods(ParseResult.Level level, ActionParsed reference) { // Remove all valid methos there are incompatible with best valid method foreach (var cmd in level.Commands) { foreach (var validMethod in cmd.Methods.ToList()) { if (validMethod == reference) { continue; } var argsA = reference.Arguments; var argsB = validMethod.Arguments; if (!this.AllRawAreEqualsOfArgumentParsed(argsA, argsB)) { cmd.RemoveMethod(validMethod); } } } }
/// <summary> /// Create a list of actions parsed from the specific target object /// </summary> /// <param name="argumentsRaw">List of arguments raw</param> /// <param name="enableMultiAction">Determine whether the parse can have more than one action per line</param> /// <param name="maps">Map of actions</param> /// <param name="initialExtraArguments">Return all arguments that are in init, that is, before any action</param> /// <returns>List of ActionParsed</returns> public IEnumerable <ActionParsed> Parse(IEnumerable <ArgumentRaw> argumentsRaw, bool enableMultiAction, IEnumerable <ActionMap> maps, out IEnumerable <ArgumentRaw> initialExtraArguments) { var actionsMapped = new List <ActionParsed>(); var mapsDefaults = maps.Where(map => map.IsDefault); var initialExtraArgumentsAux = new List <ArgumentRaw>(); initialExtraArguments = initialExtraArgumentsAux; // map the actions that are default if has default arguments if (argumentsRaw.Count() == 0) { foreach (var map in mapsDefaults) { var actionCallerDefault = new ActionParsed(map.MapName, map, null, 0); actionsMapped.Add(actionCallerDefault); } } else { //var argumentsRawDefault = new List<ArgumentRaw>(); List <ActionParsed> lastFounds = null; List <ActionParsed> defaultsCallers = null; bool continueSearchToNextAction = true; var index = 0; foreach (var argRaw in argumentsRaw) { ArgumentRaw argRawAction = null; // found all actions that has the same name (e.g: overrides methods). // ** use ValueRaw because de Value property has the value scaped when is action // ** and ValueRaw mantein the original value: // ** Value: \exists-method-scaped -> exists-method-scaped // ** ValueRaw: \exists-method-scaped -> \exists-method-scaped var founds = maps.Where(map => map.ActionName == argRaw.ValueRaw).ToList(); if (argRaw.Format == ArgumentFormat.Unnamed && founds.Count > 0 && continueSearchToNextAction) { argRawAction = argRaw; } // consider initial args as LEVEL 0 // $ --id 10 action 1 // 1) "--id 10" : LEVEL 0 // 2) "action 1" : LEVEL 1 if (index == 0 && initialExtraArgumentsAux.Any()) { index = 1; } if (argRawAction != null) { lastFounds = new List <ActionParsed>(); foreach (var actionMap in founds) { var actionCaller = new ActionParsed(actionMap.MapName, actionMap, argRaw, index); lastFounds.Add(actionCaller); actionsMapped.Add(actionCaller); } index++; } else if (lastFounds != null) { foreach (var actionMap in lastFounds) { actionMap.AddArgumentRaw(argRaw); } } else if (defaultsCallers == null) { if (mapsDefaults.Any()) { defaultsCallers = new List <ActionParsed>(); foreach (var map in mapsDefaults) { var actionCallerDefault = new ActionParsed(map.MapName, map, null, index); actionCallerDefault.AddArgumentRaw(argRaw); defaultsCallers.Add(actionCallerDefault); actionsMapped.Add(actionCallerDefault); } index++; } else if (actionsMapped.Count == 0 && initialExtraArguments != null) { initialExtraArgumentsAux.Add(argRaw); } } else if (defaultsCallers != null) { foreach (var caller in defaultsCallers) { caller.AddArgumentRaw(argRaw); } } // disable the search to the next action if (!enableMultiAction) { continueSearchToNextAction = false; } } } foreach (var action in actionsMapped) { var argumentsMapped = this.argumentParser.Parse(action.GetArgumentsRaw(), action.ActionMap.EnablePositionalArgs, action.ActionMap.ArgumentsMaps); var argumentsExtras = argumentsMapped.Where(f => f.ParsingType == ArgumentParsedType.NotMapped); var arguments = argumentsMapped.Where(f => f.ParsingType != ArgumentParsedType.NotMapped); action.Arguments = arguments; action.ArgumentsExtras = argumentsExtras; action.ParsingStates = GetState(action); } return(actionsMapped); }
private ParseResult.Level GetLevelWithPropertiesUsingMethodExtras(IEnumerable <CommandMap> commandsMap, ActionParsed bestValidMethodInLevel) { var argumentsRawProperties = bestValidMethodInLevel.ArgumentsExtras.SelectMany(f => f.AllRaw).ToList(); if (argumentsRawProperties.Any()) { return(this.GetLevelWithProperties(commandsMap, argumentsRawProperties)); } return(null); }
private bool IsMethodImplicitAndNoArguments(ActionParsed action) { return(this.IsMethodImplicit(action) && action.ActionMap.ArgumentsMaps.Empty()); }
private bool IsMethodImplicit(ActionParsed action) { return(action.ActionMap.IsDefault && action.ArgumentRawOfAction == null); }