示例#1
0
        private static void ValidateExamples(CommandModel model)
        {
            var examples = new List <string[]>();

            examples.AddRangeIfNotNull(model.Examples);

            // Get all examples.
            var queue = new Queue <ICommandContainer>(new[] { model });

            while (queue.Count > 0)
            {
                var current = queue.Dequeue();

                foreach (var command in current.Commands)
                {
                    examples.AddRangeIfNotNull(command.Examples);
                    queue.Enqueue(command);
                }
            }

            // Validate all examples.
            foreach (var example in examples)
            {
                try
                {
                    var parser = new CommandTreeParser(model);
                    parser.Parse(example);
                }
                catch (Exception ex)
                {
                    throw new ConfigurationException("Validation of examples failed.", ex);
                }
            }
        }
示例#2
0
        public int Execute(IConfiguration configuration, IEnumerable <string> args)
        {
            if (configuration == null)
            {
                throw new ArgumentNullException(nameof(configuration));
            }
            if (configuration.Commands.Count == 0)
            {
                throw new CommandAppException("No commands have been configured.");
            }

            // Create the command model.
            var model = CommandModelBuilder.Build(configuration);

            // Parse and map the model against the arguments.
            var parser = new CommandTreeParser(model, new CommandOptionAttribute("-h|--help"));

            var(tree, remaining) = parser.Parse(args);

            // Currently the root?
            if (tree == null)
            {
                // Display help.
                HelpWriter.Write(model);
                return(0);
            }

            // Get the command to execute.
            var leaf = tree.GetLeafCommand();

            if (leaf.Command.IsProxy || leaf.ShowHelp)
            {
                // Proxy's can't be executed. Show help.
                HelpWriter.Write(model, leaf.Command);
                return(0);
            }

            // Register the arguments with the container.
            var arguments = new Arguments(remaining);

            _registrar?.RegisterInstance(typeof(IArguments), arguments);

            // Create the resolver.
            var resolver = new TypeResolverAdapter(_registrar?.Build());

            // Execute the command tree.
            return(Execute(leaf, tree, remaining, resolver));
        }
示例#3
0
            public static T Bind <T>(IEnumerable <string> args, Action <Configurator> action)
                where T : CommandSettings, new()
            {
                // Configure
                var configurator = new Configurator(null);

                action(configurator);

                // Parse command tree.
                var parser = new CommandTreeParser(CommandModelBuilder.Build(configurator));
                var result = parser.Parse(args);

                // Bind the settings to the tree.
                CommandSettings settings = new T();

                CommandBinder.Bind(result.Tree, ref settings, new TypeResolverAdapter(null));

                // Return the settings.
                return((T)settings);
            }
            public static string GetParseMessage(IEnumerable <string> args, Configurator configurator, bool shouldThrowOnSuccess = true)
            {
                try
                {
                    // Create the model from the configuration.
                    var model = CommandModelBuilder.Build(configurator);

                    // Parse the resulting tree from the model and the args.
                    var parser = new CommandTreeParser(model);
                    parser.Parse(args);

                    // If we get here, something is wrong.
                    if (shouldThrowOnSuccess)
                    {
                        throw new InvalidOperationException("Expected a parse exception.");
                    }

                    return(null);
                }
                catch (ParseException ex)
                {
                    return(Render(ex.Pretty));
                }
            }
    public async Task <int> Execute(IConfiguration configuration, IEnumerable <string> args)
    {
        if (configuration == null)
        {
            throw new ArgumentNullException(nameof(configuration));
        }

        _registrar.RegisterInstance(typeof(IConfiguration), configuration);
        _registrar.RegisterLazy(typeof(IAnsiConsole), () => configuration.Settings.Console.GetConsole());

        // Create the command model.
        var model = CommandModelBuilder.Build(configuration);

        _registrar.RegisterInstance(typeof(CommandModel), model);
        _registrar.RegisterDependencies(model);

        // No default command?
        if (model.DefaultCommand == null)
        {
            // Got at least one argument?
            var firstArgument = args.FirstOrDefault();
            if (firstArgument != null)
            {
                // Asking for version? Kind of a hack, but it's alright.
                // We should probably make this a bit better in the future.
                if (firstArgument.Equals("--version", StringComparison.OrdinalIgnoreCase) ||
                    firstArgument.Equals("-v", StringComparison.OrdinalIgnoreCase))
                {
                    var console = configuration.Settings.Console.GetConsole();
                    console.WriteLine(ResolveApplicationVersion(configuration));
                    return(0);
                }
            }
        }

        // Parse and map the model against the arguments.
        var parser       = new CommandTreeParser(model, configuration.Settings);
        var parsedResult = parser.Parse(args);

        _registrar.RegisterInstance(typeof(CommandTreeParserResult), parsedResult);

        // Currently the root?
        if (parsedResult.Tree == null)
        {
            // Display help.
            configuration.Settings.Console.SafeRender(HelpWriter.Write(model));
            return(0);
        }

        // Get the command to execute.
        var leaf = parsedResult.Tree.GetLeafCommand();

        if (leaf.Command.IsBranch || leaf.ShowHelp)
        {
            // Branches can't be executed. Show help.
            configuration.Settings.Console.SafeRender(HelpWriter.WriteCommand(model, leaf.Command));
            return(leaf.ShowHelp ? 0 : 1);
        }

        // Register the arguments with the container.
        _registrar.RegisterInstance(typeof(IRemainingArguments), parsedResult.Remaining);

        // Create the resolver and the context.
        using (var resolver = new TypeResolverAdapter(_registrar.Build()))
        {
            var context = new CommandContext(parsedResult.Remaining, leaf.Command.Name, leaf.Command.Data);

            // Execute the command tree.
            return(await Execute(leaf, parsedResult.Tree, context, resolver, configuration).ConfigureAwait(false));
        }
    }