private void ValidateCommand(CommandResult commandResult)
{
foreach (var a in commandResult
.Command
.Arguments)
{
if (a is Argument argument)
{
var arityFailure = ArgumentArity.Validate(
commandResult,
a,
a.Arity.MinimumNumberOfValues,
a.Arity.MaximumNumberOfValues);
if (arityFailure != null)
{
_errors.Add(
new ParseError(arityFailure.ErrorMessage, commandResult));
}
foreach (var validator in argument.SymbolValidators)
{
var errorMessage = validator(commandResult);
if (!string.IsNullOrWhiteSpace(errorMessage))
{
_errors.Add(
new ParseError(errorMessage, commandResult));
}
}
}
}
}
private void ValidateArgument(ArgumentResult argumentResult)
{
var arityFailure = ArgumentArity.Validate(argumentResult);
if (arityFailure != null)
{
_errors.Add(new ParseError(arityFailure.ErrorMessage));
return;
}
if (argumentResult.Argument is Argument argument)
{
var parseError = argumentResult.Parent.UnrecognizedArgumentError(argument) ??
argumentResult.Parent.CustomError(argument);
if (parseError != null)
{
_errors.Add(parseError);
return;
}
}
if (argumentResult.ArgumentConversionResult is FailedArgumentConversionResult failed)
{
_errors.Add(
new ParseError(
failed.ErrorMessage,
argumentResult));
}
}
protected override void Stop(SyntaxNode node)
{
ValidateCommandHandler(_innermostCommandResult);
foreach (var commandResult in _innermostCommandResult.RecurseWhileNotNull(c => c.ParentCommandResult))
{
foreach (var symbol in commandResult.Command.Children)
{
PopulateDefaultValues(commandResult, symbol);
}
ValidateCommand(commandResult);
foreach (var result in commandResult.Children)
{
switch (result)
{
case ArgumentResult argumentResult:
ValidateArgument(argumentResult);
break;
case OptionResult optionResult:
var argument = optionResult.Option.Argument;
var arityFailure = ArgumentArity.Validate(
optionResult,
argument,
argument.Arity.MinimumNumberOfValues,
argument.Arity.MaximumNumberOfValues);
if (arityFailure != null)
{
_errors.Add(
new ParseError(arityFailure.ErrorMessage, optionResult));
}
var results = optionResult.Children
.OfType <ArgumentResult>()
.ToArray();
foreach (var a in results)
{
ValidateArgument(a);
}
break;
}
}
}
}
private void ValidateCommandResult()
{
if (_innermostCommandResult !.Command is Command command)
{
for (var i = 0; i < command.Validators.Count; i++)
{
var validator = command.Validators[i];
var errorMessage = validator(_innermostCommandResult);
if (!string.IsNullOrWhiteSpace(errorMessage))
{
_errors.Add(
new ParseError(errorMessage !, _innermostCommandResult));
}
}
}
foreach (var option in _innermostCommandResult
.Command
.Options)
{
if (option is Option o &&
o.IsRequired &&
_rootCommandResult !.FindResultFor(o) is null)
{
_errors.Add(
new ParseError($"Option '{o.Aliases.First()}' is required.",
_innermostCommandResult));
}
}
foreach (var symbol in _innermostCommandResult
.Command
.Arguments)
{
var arityFailure = ArgumentArity.Validate(
_innermostCommandResult,
symbol,
symbol.Arity.MinimumNumberOfValues,
symbol.Arity.MaximumNumberOfValues);
if (arityFailure != null)
{
_errors.Add(
new ParseError(arityFailure.ErrorMessage !, _innermostCommandResult));
}
}
}
private void ValidateCommandResult(CommandResult commandResult)
{
if (commandResult.Command is Command command)
{
foreach (var validator in command.Validators)
{
var errorMessage = validator(commandResult);
if (!string.IsNullOrWhiteSpace(errorMessage))
{
_errors.Add(
new ParseError(errorMessage, commandResult));
}
}
}
foreach (var option in commandResult
.Command
.Options)
{
if (option is Option o &&
o.Required &&
_rootCommandResult.FindResultFor(o) == null)
{
_errors.Add(
new ParseError($"Option '{o.RawAliases.First()}' is required.",
commandResult));
}
}
foreach (var symbol in commandResult
.Command
.Arguments)
{
var arityFailure = ArgumentArity.Validate(
commandResult,
symbol,
symbol.Arity.MinimumNumberOfValues,
symbol.Arity.MaximumNumberOfValues);
if (arityFailure != null)
{
_errors.Add(
new ParseError(arityFailure.ErrorMessage, commandResult));
}
}
}
private void ValidateOptionResult(OptionResult optionResult)
{
var argument = optionResult.Option.Argument;
var arityFailure = ArgumentArity.Validate(
optionResult,
argument,
argument.Arity.MinimumNumberOfValues,
argument.Arity.MaximumNumberOfValues);
if (arityFailure != null)
{
_errors.Add(
new ParseError(arityFailure.ErrorMessage !, optionResult));
}
if (optionResult.Option is Option option)
{
for (var i = 0; i < option.Validators.Count; i++)
{
var validate = option.Validators[i];
var message = validate(optionResult);
if (!string.IsNullOrWhiteSpace(message))
{
_errors.Add(new ParseError(message !, optionResult));
}
}
}
for (var i = 0; i < optionResult.Children.Count; i++)
{
var result = optionResult.Children[i];
if (result is ArgumentResult argumentResult)
{
ValidateArgumentResult(argumentResult);
}
}
}
private void ValidateOptionResult(OptionResult optionResult)
{
var argument = optionResult.Option.Argument;
var arityFailure = ArgumentArity.Validate(
optionResult,
argument,
argument.Arity.MinimumNumberOfValues,
argument.Arity.MaximumNumberOfValues);
if (arityFailure != null)
{
_errors.Add(
new ParseError(arityFailure.ErrorMessage !, optionResult));
}
if (optionResult.Option is Option option)
{
foreach (var validate in option.Validators)
{
var message = validate(optionResult);
if (!string.IsNullOrWhiteSpace(message))
{
_errors.Add(new ParseError(message !, optionResult));
}
}
}
foreach (var argumentResult in optionResult
.Children
.OfType <ArgumentResult>())
{
ValidateArgumentResult(argumentResult);
}
}
internal virtual ArgumentConversionResult Convert(
IArgument argument)
{
var parentResult = Parent;
if (ShouldCheckArity() &&
ArgumentArity.Validate(parentResult,
argument,
argument.Arity.MinimumNumberOfValues,
argument.Arity.MaximumNumberOfValues) is FailedArgumentConversionResult failedResult)
{
return(failedResult);
}
if (parentResult.UseDefaultValueFor(argument))
{
var defaultValueFor = parentResult.GetDefaultValueFor(argument);
return(ArgumentConversionResult.Success(argument, defaultValueFor));
}
if (argument is Argument a &&
a.ConvertArguments != null)
{
if (ConversionResult != null)
{
return(ConversionResult);
}
var success = a.ConvertArguments(this, out var value);
if (value is ArgumentConversionResult conversionResult)
{
return(conversionResult);
}
else if (success)
{
return(ArgumentConversionResult.Success(argument, value));
}
else
{
return(ArgumentConversionResult.Failure(argument, ErrorMessage ?? $"Invalid: {parentResult.Token()} {string.Join(" ", parentResult.Tokens.Select(t => t.Value))}"));
}
}
switch (argument.Arity.MaximumNumberOfValues)
{
case 0:
return(ArgumentConversionResult.Success(argument, null));
case 1:
return(ArgumentConversionResult.Success(argument, parentResult.Tokens.Select(t => t.Value).SingleOrDefault()));
default:
return(ArgumentConversionResult.Success(argument, parentResult.Tokens.Select(t => t.Value).ToArray()));
}
bool ShouldCheckArity()
{
return(!(parentResult is OptionResult optionResult &&
optionResult.IsImplicit));
}
}
