private static IReadOnlyList<ArgumentToken> Lex(string commandLine, Func<string, IEnumerable<string>> responseFileReader) { var args = Splitter.Split(commandLine); return ArgumentLexer.Lex(args, responseFileReader); }
private static IReadOnlyList<ArgumentToken> Lex(string commandLine) { var args = Splitter.Split(commandLine); return ArgumentLexer.Lex(args); }
public ParsedArguments Parse(ArgumentLexer lex,IEnumerable<string> arguments) { var recognizedIndexes=new List<int>(); var lexer = new PeekEnumerable<Token>(lex); IList<RecognizedArgument> recognized=new List<RecognizedArgument>(); while (lexer.HasMore()) { var current = lexer.Next(); switch (current.TokenType) { case TokenType.Argument: { // TODO : move recognize into ArgumentBase var argumentWithOptions = _argumentWithOptions .Where(argopt => !argopt.Argument.Ordinal.HasValue) .SingleOrDefault(argopt => argopt.Argument .Prototype.Equals(current.Value,StringComparison.OrdinalIgnoreCase)); if (null == argumentWithOptions) { argumentWithOptions = _argumentWithOptions .Where(argopt => argopt.Argument.Ordinal.HasValue) .SingleOrDefault(argopt => argopt.Argument.Ordinal.Value.Equals(current.Index) && argopt.HasAlias(current.Value)); if (null == argumentWithOptions) { continue; } } recognizedIndexes.Add(current.Index); recognized.Add(new RecognizedArgument( argumentWithOptions, current.Value)); } break; case TokenType.Parameter: { var argumentWithOptions = _argumentWithOptions .SingleOrDefault(argopt => argopt.HasAlias(current.Value)); if (null == argumentWithOptions) continue; string value; recognizedIndexes.Add(current.Index); if (lexer.Peek().TokenType == TokenType.ParameterValue) { var paramValue = lexer.Next(); recognizedIndexes.Add(paramValue.Index); value = paramValue.Value; } else { value = string.Empty; } recognized.Add(new RecognizedArgument( argumentWithOptions, current.Value, value)); } break; case TokenType.ParameterValue: break; default: throw new ArgumentOutOfRangeException(current.TokenType.ToString()); } } var argumentList = arguments.ToList(); var unRecognizedArguments = argumentList .Select((value, i) => new { i, value }) .Where(indexAndValue => !recognizedIndexes.Contains(indexAndValue.i)) .Select(v => new UnrecognizedArgument(){ Index=v.i, Value=v.value}); var unMatchedRequiredArguments = _argumentWithOptions.Where(argumentWithOptions => argumentWithOptions.Required) .Where(argumentWithOptions => !recognized.Any(recogn => recogn.WithOptions.Equals(argumentWithOptions))); if (unMatchedRequiredArguments.Any()) { throw new MissingArgumentException("Missing arguments") { Arguments = unMatchedRequiredArguments .Select(unmatched =>new KeyValuePair<string,string>( unmatched.Argument.ToString(),unmatched.Argument.Help())).ToList() }; } return new ParsedArguments { ArgumentWithOptions = _argumentWithOptions.ToArray(), RecognizedArguments = recognized, UnRecognizedArguments = unRecognizedArguments }; }
public ParsedArguments Parse(IEnumerable<string> arguments) { var lexer = new ArgumentLexer(arguments); return Parse(lexer, arguments); }
public void It_can_tokenize_simple_argument() { var lexer = new ArgumentLexer(new[] { "argument" }); var tokens = lexer.ToArray(); Assert.That(tokens, Is.EquivalentTo(new[] { new Token("argument", TokenType.Argument, 0) })); }
public void It_can_tokenize_parametervalue2() { var lexer = new ArgumentLexer(new[] { "--parameter=parametervalue" }); var tokens = lexer.ToArray(); Assert.That(tokens, Is.EquivalentTo(new[] { new Token("parameter", TokenType.Parameter, 0), new Token("parametervalue", TokenType.ParameterValue, 1) })); }