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