public void It_can_peek_tokenized_value()
{
var lexed = new PeekEnumerable<Token>(ArgumentLexer.Lex(new[] { "--parameter=parametervalue", "argument" }));
lexed.Next();
var first = lexed.Peek();
Assert.That(first, Is.EqualTo(new Token("parametervalue", TokenType.ParameterValue, 1)));
Assert.That(lexed.Next(), Is.EqualTo(first));
Assert.That(lexed.Peek(), Is.EqualTo(new Token("argument", TokenType.Argument, 2)));
}
public ParsedArguments Parse(IList<Token> lexed, IEnumerable<string> arguments)
{
var recognizedIndexes = new List<int>();
var peekTokens = new PeekEnumerable<Token>(lexed);
var encounteredParameter = false;
IList<RecognizedArgument> recognized = new List<RecognizedArgument>();
while (peekTokens.HasMore())
{
var current = peekTokens.Next();
switch (current.TokenType)
{
case TokenType.Argument:
{
var argumentWithOptions = _argumentWithOptions
.SingleOrDefault(argopt => argopt.Argument.Accept(current.Index, current.Value));
if (null == argumentWithOptions && !encounteredParameter && _allowInferParameter)
{
InferParameter(recognizedIndexes, recognized, current);
continue;
}
if (null == argumentWithOptions)
{
continue;
}
recognizedIndexes.Add(current.Index);
recognized.Add(new RecognizedArgument(
argumentWithOptions,
current.Index,
current.Value));
}
break;
case TokenType.Parameter:
{
encounteredParameter = true;
var argumentWithOptions = _argumentWithOptions
.SingleOrDefault(argopt => argopt.Argument.Accept(current.Index, current.Value));
if (null == argumentWithOptions)
continue;
string value;
recognizedIndexes.Add(current.Index);
if (peekTokens.Peek().TokenType == TokenType.ParameterValue)
{
var paramValue = peekTokens.Next();
recognizedIndexes.Add(paramValue.Index);
value = paramValue.Value;
}
else
{
value = string.Empty;
}
recognized.Add(new RecognizedArgument(
argumentWithOptions,
current.Index,
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 });
return new ParsedArguments(argumentList)
{
ArgumentWithOptions = _argumentWithOptions.ToArray(),
RecognizedArguments = recognized,
UnRecognizedArguments = unRecognizedArguments
};
}
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
};
}
