コード例 #1
0
 public void Can_parse_verb_noun_format_with_no_arguments()
 {
     var parser = new CommandLineParser();
     var commandLine = (parser.Parse(new[] { "add-wrap" }) as CommandLineParser.Success).CommandLine;
     commandLine.Noun.ShouldBe("wrap");
     commandLine.Verb.ShouldBe("add");
     commandLine.Arguments.ShouldBeEmpty();
 }
コード例 #2
0
 public void Can_parse_verb_noun_format()
 {
     var parser = new CommandLineParser();
     var commandLine = (parser.Parse(new[] { "add-wrap", "foo", "bar" }) as CommandLineParser.Success).CommandLine;
     commandLine.Noun.ShouldBe("wrap");
     commandLine.Verb.ShouldBe("add");
     commandLine.Arguments.ShouldHaveSameElementsAs(new[] { "foo", "bar" });
 }
コード例 #3
0
        public IEnumerable<ICommandOutput> Execute(IEnumerable<string> strings)
        {
            var parser = new CommandLineParser();
            var parseResult = parser.Parse(strings);
            if (parseResult is CommandLineParser.NotEnoughArgumentsFailure)
            {
                yield return new NotEnoughParameters();
                yield break;
            }

            var commandLine = ((CommandLineParser.Success)parseResult).CommandLine;
            var matchingNouns = _commands.Nouns.Where(x => x.StartsWith(commandLine.Noun, StringComparison.OrdinalIgnoreCase)).ToList();
            if (matchingNouns.Count != 1)
            {
                yield return new NamespaceNotFound(matchingNouns);
                yield break;
            }
            var noun = matchingNouns[0];

            var matchingVerbs = _commands.Verbs.Where(x => x.StartsWith(commandLine.Verb, StringComparison.OrdinalIgnoreCase)).ToList();
            if (matchingVerbs.Count != 1)
            {
                yield return new UnknownCommand(commandLine.Verb, matchingVerbs);
                yield break;
            }

            var verb = matchingVerbs[0];

            var command = _commands.Get(noun, verb);

            var inputsFromCommandLine = ParseInputsFromCommandLine(commandLine.Arguments).ToLookup(x => x.Key, x => x.Value);

            var unnamedCommandInputsFromCommandLine = inputsFromCommandLine[null].ToList();
            List<ParsedInput> assignedNamedInputValues = null;
            AmbiguousInputNameException exception = null;
            try
            {
                assignedNamedInputValues = (from namedValues in inputsFromCommandLine
                                            where namedValues.Key != null
                                            let value = namedValues.LastOrDefault()
                                            let commandInput = FindCommandInputDescriptor(command, namedValues.Key)
                                            let parsedValue = commandInput != null ? commandInput.ValidateValue(value) : null
                                            select new ParsedInput
                                            {
                                                    InputName = namedValues.Key,
                                                    RawValue = value,
                                                    Input = commandInput,
                                                    ParsedValue = parsedValue
                                            }).ToList();
            }
            catch(AmbiguousInputNameException e)
            {
                exception = e;
            }
            if (exception != null)
            {
                yield return exception;
                yield break;
            }
            var namedInputsNameNotFound = assignedNamedInputValues.FirstOrDefault(x => x.Input == null);
            if (namedInputsNameNotFound != null)
            {
                yield return new UnknownCommandInput(namedInputsNameNotFound.InputName);
                yield break;
            }

            var namedInputsValueNotParsed = assignedNamedInputValues.FirstOrDefault(x => x.RawValue == null);

            var inputNamesAlreadyFilled = assignedNamedInputValues.Select(x => x.InputName).ToList();

            // now got a clean set of input names that pass. Now on to the unnamed ones.
            var unfullfilledCommandInputs = (from input in command.Inputs
                                             where !inputNamesAlreadyFilled.Contains(input.Key, StringComparer.OrdinalIgnoreCase)
                                                   && input.Value.Position != null && input.Value.Position >= 0
                                             orderby input.Value.Position ascending
                                             select input.Value).ToList();

            if (unnamedCommandInputsFromCommandLine.Count > unfullfilledCommandInputs.Count)
            {
                yield return new InvalidCommandValue(unnamedCommandInputsFromCommandLine);
                yield break;
            }

            var assignedUnnamedInputValues = (from unnamedValue in unnamedCommandInputsFromCommandLine
                                              let input = unfullfilledCommandInputs[unnamedCommandInputsFromCommandLine.IndexOf(unnamedValue)]
                                              let commandValue = input.ValidateValue(unnamedValue)
                                              select new ParsedInput
                                              {
                                                  InputName = null,
                                                  RawValue = unnamedValue,
                                                  Input = input,
                                                  ParsedValue = commandValue
                                              }).ToList();

            var unnamedFailed = assignedUnnamedInputValues.Where(x => x.ParsedValue == null).ToList();
            if (unnamedFailed.Count > 0)
            {
                yield return new InvalidCommandValue(unnamedCommandInputsFromCommandLine);
                yield break;
            }

            var allAssignedInputs = assignedNamedInputValues.Concat(assignedUnnamedInputValues);

            allAssignedInputs = TryAssignSwitchParameters(allAssignedInputs, command.Inputs);

            var missingRequiredInputs = command.Inputs.Select(x => x.Value)
                                              .Where(x => !allAssignedInputs.Select(i => i.Input).Contains(x) && x.IsRequired)
                                              .ToList();
            if (missingRequiredInputs.Count > 0)
            {
                yield return new MissingCommandValue(missingRequiredInputs);
                yield break;
            }

            var missingInputValues = allAssignedInputs.Select(x => x.Input);
            // all clear, assign and run
            var commandInstance = command.Create();
            foreach (var namedInput in allAssignedInputs)
                namedInput.Input.SetValue(commandInstance, namedInput.ParsedValue);
            var enumerator = commandInstance.Execute().GetEnumerator();
            MoveNextResult result;
            do
            {
                ICommandOutput msg;
                Exception error;
                result = enumerator.TryMoveNext(out msg, out error);
                if (result == MoveNextResult.Moved)
                    yield return msg;
                else if (result == MoveNextResult.End)
                    yield break;
                else if (result == MoveNextResult.Error)
                    yield return new ExceptionError(error);
            } while (result == MoveNextResult.Moved);
        }
コード例 #4
0
 public void Cannot_parse_single_argument_without_dash()
 {
     var parser = new CommandLineParser();
     var result = parser.Parse(new[] { "fail" }) as CommandLineParser.NotEnoughArgumentsFailure;
     result.ShouldNotBeNull();
 }
コード例 #5
0
 public void Cannot_parse_empty_command_line()
 {
     var parser = new CommandLineParser();
     var result = parser.Parse(new string[0]) as CommandLineParser.NotEnoughArgumentsFailure;
     result.ShouldNotBeNull();
 }