Esempio n. 1
0
        private static void ValidateExamples(CommandModel model, CommandAppSettings settings)
        {
            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, settings, ParsingMode.Strict);
                    parser.Parse(example);
                }
                catch (Exception ex)
                {
                    throw new CommandConfigurationException("Validation of examples failed.", ex);
                }
            }
        }
        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));
            }
        }