コード例 #1
0
        private CommandTree ParseCommandParameters(
            CommandTreeParserContext context,
            CommandInfo command,
            CommandTree?parent,
            CommandTreeTokenStream stream)
        {
            context.ResetArgumentPosition();

            var node = new CommandTree(parent, command);

            while (stream.Peek() != null)
            {
                var token = stream.Peek();
                if (token == null)
                {
                    // Should not happen, but the compiler isn't
                    // smart enough to realize this...
                    throw new RuntimeException("Could not get the next token.");
                }

                switch (token.TokenKind)
                {
                case CommandTreeToken.Kind.LongOption:
                    // Long option
                    ParseOption(context, stream, token, node, true);
                    break;

                case CommandTreeToken.Kind.ShortOption:
                    // Short option
                    ParseOption(context, stream, token, node, false);
                    break;

                case CommandTreeToken.Kind.String:
                    // Command
                    ParseString(context, stream, node);
                    break;

                case CommandTreeToken.Kind.Remaining:
                    // Remaining
                    stream.Consume(CommandTreeToken.Kind.Remaining);
                    context.State = State.Remaining;
                    break;

                default:
                    throw new InvalidOperationException($"Encountered unknown token ({token.TokenKind}).");
                }
            }

            // Add unmapped parameters.
            foreach (var parameter in node.Command.Parameters)
            {
                if (node.Mapped.All(m => m.Parameter != parameter))
                {
                    node.Unmapped.Add(parameter);
                }
            }

            return(node);
        }
コード例 #2
0
 public static CommandOption FindOption(this CommandTree tree, string name, bool longOption)
 {
     return(tree.Command.Parameters
            .OfType <CommandOption>()
            .FirstOrDefault(o => longOption
             ? o.LongNames.Contains(name, StringComparer.Ordinal)
             : o.ShortNames.Contains(name, StringComparer.Ordinal)));
 }
コード例 #3
0
        public static CommandTree?GetRootCommand(this CommandTree node)
        {
            while (node.Parent != null)
            {
                node = node.Parent;
            }

            return(node);
        }
コード例 #4
0
        public static CommandTree GetLeafCommand(this CommandTree node)
        {
            while (node.Next != null)
            {
                node = node.Next;
            }

            return(node);
        }
コード例 #5
0
        public static void Bind(CommandTree tree, ref CommandSettings settings, ITypeResolver resolver)
        {
            ValidateRequiredParameters(tree);

            TypeConverter GetConverter(CommandParameter parameter)
            {
                if (parameter.Converter == null)
                {
                    if (parameter.ParameterType.IsArray)
                    {
                        // Return a converter for each array item (not the whole array)
                        return(TypeDescriptor.GetConverter(parameter.ParameterType.GetElementType()));
                    }

                    return(TypeDescriptor.GetConverter(parameter.ParameterType));
                }
                var type = Type.GetType(parameter.Converter.ConverterTypeName);

                return(resolver.Resolve(type) as TypeConverter);
            }

            while (tree != null)
            {
                // Process mapped parameters.
                foreach (var mapped in tree.Mapped)
                {
                    var converter = GetConverter(mapped.Parameter);
                    mapped.Parameter.Assign(settings, converter.ConvertFromInvariantString(mapped.Value));
                    ValidateParameter(mapped.Parameter, settings);
                }

                // Process unmapped parameters.
                foreach (var parameter in tree.Unmapped)
                {
                    // Is this an option with a default value?
                    if (parameter is CommandOption option && option.DefaultValue != null)
                    {
                        parameter.Assign(settings, option.DefaultValue.Value);
                        ValidateParameter(parameter, settings);
                    }
                }

                tree = tree.Next;
            }

            // Validate the settings.
            var validationResult = settings.Validate();

            if (!validationResult.Successful)
            {
                throw RuntimeException.ValidationFailed(validationResult);
            }
        }
コード例 #6
0
        private void ParseOption(
            CommandTreeParserContext context,
            CommandTreeTokenStream stream,
            CommandTreeToken token,
            CommandTree node,
            bool isLongOption)
        {
            // Consume the option token.
            stream.Consume(isLongOption ? CommandTreeToken.Kind.LongOption : CommandTreeToken.Kind.ShortOption);

            if (context.State == State.Normal)
            {
                // Find the option.
                var option = node.FindOption(token.Value, isLongOption, CaseSensitivity);
                if (option != null)
                {
                    node.Mapped.Add(new MappedCommandParameter(
                                        option, ParseOptionValue(context, stream, token, node, option)));

                    return;
                }

                // Help?
                if (_help?.IsMatch(token.Value) == true)
                {
                    node.ShowHelp = true;
                    return;
                }
            }

            if (context.State == State.Remaining)
            {
                ParseOptionValue(context, stream, token, node, null);
                return;
            }

            if (context.ParsingMode == ParsingMode.Strict)
            {
                throw ParseException.UnknownOption(context.Arguments, token);
            }
            else
            {
                ParseOptionValue(context, stream, token, node, null);
            }
        }
コード例 #7
0
        private static void ValidateRequiredParameters(CommandTree tree)
        {
            var node = tree.GetRootCommand();

            while (node != null)
            {
                foreach (var parameter in node.Unmapped)
                {
                    if (parameter.Required)
                    {
                        switch (parameter)
                        {
                        case CommandArgument argument:
                            throw RuntimeException.MissingRequiredArgument(node, argument);
                        }
                    }
                }
                node = node.Next;
            }
        }
コード例 #8
0
        public static bool IsOptionMappedWithParent(this CommandTree tree, string name, bool longOption)
        {
            var node = tree.Parent;

            while (node != null)
            {
                var option = node.Command?.Parameters.OfType <CommandOption>()
                             .FirstOrDefault(o => longOption
                        ? o.LongNames.Contains(name, StringComparer.Ordinal)
                        : o.ShortNames.Contains(name, StringComparer.Ordinal));

                if (option != null)
                {
                    return(node.Mapped.Any(p => p.Parameter == option));
                }

                node = node.Parent;
            }

            return(false);
        }
コード例 #9
0
ファイル: CommandExecutor.cs プロジェクト: gep13/spectre.cli
        private static Task <int> Execute(
            CommandTree leaf,
            CommandTree tree,
            CommandContext context,
            ITypeResolver resolver,
            IConfiguration configuration)
        {
            // Bind the command tree against the settings.
            var settings = CommandBinder.Bind(tree, leaf.Command.SettingsType, resolver);

            configuration.Settings.Interceptor?.Intercept(context, settings);

            // Create and validate the command.
            var command          = leaf.CreateCommand(resolver);
            var validationResult = command.Validate(context, settings);

            if (!validationResult.Successful)
            {
                throw RuntimeException.ValidationFailed(validationResult);
            }

            // Execute the command.
            return(command.Execute(context, settings));
        }
コード例 #10
0
        private string?ParseOptionValue(
            CommandTreeParserContext context,
            CommandTreeTokenStream stream,
            CommandTreeToken token,
            CommandTree current,
            CommandParameter?parameter)
        {
            var value = default(string);

            // Parse the value of the token (if any).
            var valueToken = stream.Peek();

            if (valueToken?.TokenKind == CommandTreeToken.Kind.String)
            {
                var parseValue = true;
                if (token.TokenKind == CommandTreeToken.Kind.ShortOption && token.IsGrouped)
                {
                    parseValue = false;
                }

                if (context.State == State.Normal && parseValue)
                {
                    // Is this a command?
                    if (current.Command.FindCommand(valueToken.Value, CaseSensitivity) == null)
                    {
                        if (parameter != null)
                        {
                            if (parameter.ParameterKind == ParameterKind.Flag)
                            {
                                if (!Constants.AcceptedBooleanValues.Contains(valueToken.Value, StringComparer.OrdinalIgnoreCase))
                                {
                                    // Flags cannot be assigned a value.
                                    throw ParseException.CannotAssignValueToFlag(context.Arguments, token);
                                }
                            }

                            value = stream.Consume(CommandTreeToken.Kind.String)?.Value;
                        }
                        else
                        {
                            // Unknown parameter value.
                            value = stream.Consume(CommandTreeToken.Kind.String)?.Value;

                            // In relaxed parsing mode?
                            if (context.ParsingMode == ParsingMode.Relaxed)
                            {
                                context.AddRemainingArgument(token.Value, value);
                            }
                        }
                    }
                }
                else
                {
                    context.AddRemainingArgument(token.Value, parseValue ? valueToken.Value : null);
                }
            }
            else
            {
                if (context.State == State.Remaining || context.ParsingMode == ParsingMode.Relaxed)
                {
                    context.AddRemainingArgument(token.Value, null);
                }
            }

            // No value?
            if (context.State == State.Normal)
            {
                if (value == null && parameter != null)
                {
                    if (parameter.ParameterKind == ParameterKind.Flag)
                    {
                        value = "true";
                    }
                    else
                    {
                        if (parameter is CommandOption option)
                        {
                            if (parameter.IsFlagValue())
                            {
                                return(null);
                            }

                            throw ParseException.OptionHasNoValue(context.Arguments, token, option);
                        }
                        else
                        {
                            // This should not happen at all. If it does, it's because we've added a new
                            // option type which isn't a CommandOption for some reason.
                            throw new InvalidOperationException($"Found invalid parameter type '{parameter.GetType().FullName}'.");
                        }
                    }
                }
            }

            return(value);
        }
コード例 #11
0
        private void ParseString(
            CommandTreeParserContext context,
            CommandTreeTokenStream stream,
            CommandTree node)
        {
            if (context.State == State.Remaining)
            {
                stream.Consume(CommandTreeToken.Kind.String);
                return;
            }

            var token = stream.Expect(CommandTreeToken.Kind.String);

            // Command?
            var command = node.Command.FindCommand(token.Value, CaseSensitivity);

            if (command != null)
            {
                if (context.State == State.Normal)
                {
                    node.Next = ParseCommand(context, node.Command, node, stream);
                }

                return;
            }

            // Current command has no arguments?
            if (!node.HasArguments())
            {
                throw ParseException.UnknownCommand(_configuration, node, context.Arguments, token);
            }

            // Argument?
            var parameter = node.FindArgument(context.CurrentArgumentPosition);

            if (parameter == null)
            {
                // No parameters left. Any commands after this?
                if (node.Command.Children.Count > 0 || node.Command.IsDefaultCommand)
                {
                    throw ParseException.UnknownCommand(_configuration, node, context.Arguments, token);
                }

                throw ParseException.CouldNotMatchArgument(context.Arguments, token);
            }

            // Yes, this was an argument.
            if (parameter.ParameterKind == ParameterKind.Vector)
            {
                // Vector
                var current = stream.Current;
                while (current?.TokenKind == CommandTreeToken.Kind.String)
                {
                    var value = stream.Consume(CommandTreeToken.Kind.String)?.Value;
                    node.Mapped.Add(new MappedCommandParameter(parameter, value));
                    current = stream.Current;
                }
            }
            else
            {
                // Scalar
                var value = stream.Consume(CommandTreeToken.Kind.String)?.Value;
                node.Mapped.Add(new MappedCommandParameter(parameter, value));
                context.IncreaseArgumentPosition();
            }
        }
コード例 #12
0
 public static CommandArgument FindArgument(this CommandTree tree, int position)
 {
     return(tree.Command.Parameters
            .OfType <CommandArgument>()
            .FirstOrDefault(c => c.Position == position));
 }
コード例 #13
0
 public static bool HasArguments(this CommandTree tree)
 {
     return(tree.Command.Parameters.OfType <CommandArgument>().Any());
 }