示例#1
0
        internal static FailedArgumentConversionArityResult Validate(
            SymbolResult symbolResult,
            IArgument argument,
            int minimumNumberOfValues,
            int maximumNumberOfValues)
        {
            SymbolResult argumentResult = null;

            switch (symbolResult)
            {
            case CommandResult commandResult:
                argumentResult = commandResult.Root.FindResultFor(argument);
                break;

            case OptionResult optionResult:
                argumentResult = optionResult.Children.ResultFor(argument);
                break;

            case ArgumentResult _:
                throw new ArgumentException("");
            }


            var tokenCount = argumentResult?.Tokens.Count ?? 0;

            if (tokenCount < minimumNumberOfValues)
            {
                if (symbolResult.UseDefaultValueFor(argument))
                {
                    return(null);
                }

                return(new MissingArgumentConversionResult(
                           argument,
                           symbolResult.ValidationMessages.RequiredArgumentMissing(symbolResult)));
            }

            if (tokenCount > maximumNumberOfValues)
            {
                if (maximumNumberOfValues == 1)
                {
                    return(new TooManyArgumentsConversionResult(
                               argument,
                               symbolResult.ValidationMessages.ExpectsOneArgument(symbolResult)));
                }
                else
                {
                    return(new TooManyArgumentsConversionResult(
                               argument,
                               symbolResult.ValidationMessages.ExpectsFewerArguments(
                                   symbolResult.Token,
                                   tokenCount,
                                   maximumNumberOfValues)));
                }
            }

            return(null);
        }
        internal static FailedArgumentConversionArityResult Validate(
            SymbolResult symbolResult,
            IArgument argument,
            int minimumNumberOfValues,
            int maximumNumberOfValues)
        {
            var argumentResult = symbolResult switch
            {
                CommandResult commandResult => commandResult.Root.FindResultFor(argument),
                OptionResult optionResult => optionResult.Children.ResultFor(argument),
                _ => symbolResult
            };

            var tokenCount = argumentResult?.Tokens.Count ?? 0;

            if (tokenCount < minimumNumberOfValues)
            {
                if (symbolResult.UseDefaultValueFor(argument))
                {
                    return(null);
                }

                return(new MissingArgumentConversionResult(
                           argument,
                           symbolResult.ValidationMessages.RequiredArgumentMissing(symbolResult)));
            }

            if (tokenCount > maximumNumberOfValues)
            {
                if (maximumNumberOfValues == 1)
                {
                    return(new TooManyArgumentsConversionResult(
                               argument,
                               symbolResult.ValidationMessages.ExpectsOneArgument(symbolResult)));
                }
                else
                {
                    return(new TooManyArgumentsConversionResult(
                               argument,
                               symbolResult.ValidationMessages.ExpectsFewerArguments(
                                   symbolResult.Tokens.Last(),
                                   tokenCount,
                                   maximumNumberOfValues)));
                }
            }

            return(null);
        }
示例#3
0
        internal static ArgumentConversionResult?Validate(
            SymbolResult symbolResult,
            Argument argument,
            int minimumNumberOfValues,
            int maximumNumberOfValues)
        {
            var argumentResult = symbolResult switch
            {
                ArgumentResult a => a,
                _ => symbolResult.Root !.FindResultFor(argument)
            };

            var tokenCount = argumentResult?.Tokens.Count ?? 0;

            if (tokenCount < minimumNumberOfValues)
            {
                if (symbolResult.UseDefaultValueFor(argument))
                {
                    return(null);
                }

                return(ArgumentConversionResult.Failure(
                           argument,
                           symbolResult.LocalizationResources.RequiredArgumentMissing(symbolResult),
                           ArgumentConversionResultType.FailedMissingArgument));
            }

            if (tokenCount > maximumNumberOfValues)
            {
                if (symbolResult is OptionResult optionResult)
                {
                    if (!optionResult.Option.AllowMultipleArgumentsPerToken)
                    {
                        return(ArgumentConversionResult.Failure(
                                   argument,
                                   symbolResult !.LocalizationResources.ExpectsOneArgument(symbolResult),
                                   ArgumentConversionResultType.FailedTooManyArguments));
                    }
                }
            }

            return(null);
        }
        internal static FailedArgumentArityResult Validate(
            SymbolResult symbolResult,
            IArgument argument,
            int minimumNumberOfValues,
            int maximumNumberOfValues)
        {
            var tokenCount = symbolResult.Tokens.Count;

            if (tokenCount < minimumNumberOfValues)
            {
                if (symbolResult.UseDefaultValueFor(argument))
                {
                    return(null);
                }

                return(new MissingArgumentResult(
                           argument,
                           symbolResult.ValidationMessages.RequiredArgumentMissing(symbolResult)));
            }

            if (tokenCount > maximumNumberOfValues)
            {
                if (maximumNumberOfValues == 1)
                {
                    return(new TooManyArgumentsResult(
                               argument,
                               symbolResult.ValidationMessages.ExpectsOneArgument(symbolResult)));
                }
                else
                {
                    return(new TooManyArgumentsResult(
                               argument,
                               symbolResult.ValidationMessages.ExpectsFewerArguments(symbolResult, maximumNumberOfValues)));
                }
            }

            return(null);
        }