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);
}
