Ejemplo n.º 1
0
        public bool TryGetParameterWithNameIgnoringHeader(string name, out ParameterOption matchingParamerter)
        {
            string paramName = name.TrimStart(ParameterHeader);

            matchingParamerter = Parameters.FirstOrDefault(x => string.Equals(x.Name, paramName, StringComparison.OrdinalIgnoreCase));
            return(matchingParamerter != null);
        }
        private ParseCommandLineResult ParseCommandLineResultFromParameters(Command knownCommand, IImmutableList <string> parameters)
        {
            var    valuedParameters       = new List <(ParameterOption Param, string Value)>();
            var    flaggedParameters      = new List <ParameterOption>();
            var    possibleNextParameters = new List <string>();
            string remainingText          = string.Empty;

            int i = 0;

            while (i < parameters.Count)
            {
                bool grabbedParamValue = false;
                var  paramName         = parameters[i];
                if (knownCommand.TryGetParameterWithNameIgnoringHeader(paramName, out ParameterOption knownParam))
                {
                    //Then we already know about this param
                    if (knownParam.TakesInputValue)
                    {
                        grabbedParamValue = PullOutValuedParameter(parameters, valuedParameters, i, grabbedParamValue, knownParam);
                    }
                    else
                    {
                        flaggedParameters.Add(knownParam);
                    }
                }
                else
                {
                    //We don't know about the parameter with the name.
                    //  Maybe someone forgot about it in the list, or user hasn't typed in the full text because it at the end.
                    if (IndexIsForLastParameter(i, parameters))
                    {
                        //If we're on the last param value user is probably mid-way through typing it
                        remainingText = paramName;
                        var parametersAlreadyUsed = valuedParameters.Select(x => x.Param).Concat(flaggedParameters).ToImmutableList();
                        possibleNextParameters = knownCommand.GetPossibleParametersThatStartWith(remainingText, parametersAlreadyUsed).Select(x => x.Name).ToList();
                    }
                    else
                    {
                        //Since it's not last, this is a parameter we don't know about
                        //  Default to assuming it takes a value and isn't a flag
                        paramName  = paramName.TrimStart(knownCommand.ParameterHeader);
                        knownParam = new ParameterOption(paramName, true, "Unknown Parameter");

                        grabbedParamValue = PullOutValuedParameter(parameters, valuedParameters, i, grabbedParamValue, knownParam);
                    }
                }

                i += grabbedParamValue ? 2 : 1;
            }

            return(new ParseCommandLineResult(knownCommand,
                                              flaggedParameters,
                                              valuedParameters,
                                              remainingText,
                                              possibleNextParameters));
        }