Exemple #1
0
        private void CreateSubApplications(Type type,
                                           CommandLineApplication parentApplication,
                                           IDependencyResolver dependencyResolver)
        {
            IEnumerable <Type> propertySubmodules =
                type.GetDeclaredProperties <SubCommandAttribute>()
                .Select(p => p.PropertyType);

            IEnumerable <Type> inlineClassSubmodules = type
                                                       .GetNestedTypes(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly)
                                                       .Where(x => x.HasAttribute <SubCommandAttribute>())
                                                       .Where(x => !x.IsCompilerGenerated())
                                                       .Where(x => !typeof(IAsyncStateMachine).IsAssignableFrom(x));

            foreach (Type submoduleType in propertySubmodules.Union(inlineClassSubmodules))
            {
                // TODO: optimization - return a LazyAppCreator, parsing sub applications only as needed
                //       the current code creates all sub applications
                //       for an app like git with a lot of commands this can have a noticeable impact
                //       this accounts for ~10% of the run time across all feature tests

                AppCreator appCreator = new AppCreator(_appSettings);
                appCreator.CreateApplication(submoduleType, dependencyResolver, parentApplication);
            }
        }
Exemple #2
0
        private void CreateSubApplications(Type type,
                                           CommandLineApplication parentApplication,
                                           IDependencyResolver dependencyResolver)
        {
            IEnumerable <Type> propertySubmodules =
                type.GetDeclaredProperties <SubCommandAttribute>()
                .Select(p => p.PropertyType);

            IEnumerable <Type> inlineClassSubmodules = type
                                                       .GetNestedTypes(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly)
                                                       .Where(x => x.HasAttribute <SubCommandAttribute>())
                                                       .Where(x => !x.IsCompilerGenerated())
                                                       .Where(x => !typeof(IAsyncStateMachine).IsAssignableFrom(x));

            foreach (Type submoduleType in propertySubmodules.Union(inlineClassSubmodules))
            {
                AppCreator appCreator = new AppCreator(_appSettings);
                appCreator.CreateApplication(submoduleType, dependencyResolver, parentApplication);
            }
        }
Exemple #3
0
        /// <summary>
        /// Executes the specified command with given parameters
        /// </summary>
        /// <param name="args">Command line arguments</param>
        /// <returns>If target method returns int, this method will return that value. Else,
        /// it will return 0 in case of success and 1 in case of unhandled exception</returns>
        public int Run(params string[] args)
        {
            try
            {
                AppCreator appCreator = new AppCreator(_settings);

                CommandLineApplication app = appCreator.CreateApplication(typeof(T), DependencyResolver);

                return(app.Execute(_parserBuilder.Build(), args));
            }
            catch (AppRunnerException e)
            {
                _settings.Error.WriteLine(e.Message + "\n");
#if DEBUG
                _settings.Error.WriteLine(e.StackTrace);
#endif
                return(1);
            }
            catch (CommandParsingException e)
            {
                var optionHelp = e.Command.OptionHelp;
                if (optionHelp != null)
                {
                    _settings.Out.WriteLine(
                        $"Specify --{optionHelp.LongName} for a list of available options and commands.");
                }

                _settings.Error.WriteLine(e.Message + "\n");
                e.Command.ShowHelp();

#if DEBUG
                _settings.Error.WriteLine(e.StackTrace);
#endif

                return(1);
            }
            catch (ValueParsingException e)
            {
                _settings.Error.WriteLine(e.Message + "\n");
                return(2);
            }
            catch (AggregateException e) when(e.InnerExceptions.Any(x => x.GetBaseException() is AppRunnerException) ||
                                              e.InnerExceptions.Any(x =>
                                                                    x.GetBaseException() is CommandParsingException))
            {
                foreach (var innerException in e.InnerExceptions)
                {
                    _settings.Error.WriteLine(innerException.GetBaseException().Message + "\n");
#if DEBUG
                    _settings.Error.WriteLine(innerException.GetBaseException().StackTrace);
                    if (e.InnerExceptions.Count > 1)
                    {
                        _settings.Error.WriteLine("-----------------------------------------------------------------");
                    }
#endif
                }

                return(1);
            }
            catch (AggregateException e) when(e.InnerExceptions.Any(x =>
                                                                    x.GetBaseException() is ArgumentValidationException))

            {
                ArgumentValidationException validationException =
                    (ArgumentValidationException)e.InnerExceptions.FirstOrDefault(x =>
                                                                                  x.GetBaseException() is ArgumentValidationException);

                foreach (var failure in validationException.ValidationResult.Errors)
                {
                    _settings.Out.WriteLine(failure.ErrorMessage);
                }

                return(2);
            }
            catch (AggregateException e) when(e.InnerExceptions.Any(x => x.GetBaseException() is ValueParsingException)
                                              )

            {
                ValueParsingException valueParsingException =
                    (ValueParsingException)e.InnerExceptions.FirstOrDefault(x =>
                                                                            x.GetBaseException() is ValueParsingException);

                _settings.Error.WriteLine(valueParsingException.Message + "\n");

                return(2);
            }
            catch (AggregateException e) when(e.InnerExceptions.Any(x => x is TargetInvocationException))
            {
                TargetInvocationException ex =
                    (TargetInvocationException)e.InnerExceptions.SingleOrDefault(x => x is TargetInvocationException);

                ExceptionDispatchInfo.Capture(ex.InnerException ?? ex).Throw();
                return(1); // this will never be called
            }
            catch (AggregateException e)
            {
                foreach (Exception innerException in e.InnerExceptions)
                {
                    ExceptionDispatchInfo.Capture(innerException).Throw();
                }

                return(1); // this will never be called if there is any inner exception
            }
            catch (ArgumentValidationException ex)
            {
                foreach (var failure in ex.ValidationResult.Errors)
                {
                    _settings.Out.WriteLine(failure.ErrorMessage);
                }

                return(2);
            }
            catch (TargetInvocationException ex)
            {
                ExceptionDispatchInfo.Capture(ex.InnerException ?? ex).Throw();
                return(1); // this will never be called
            }
        }
Exemple #4
0
        /// <summary>
        /// Exceutes the specified command with given parameters
        /// </summary>
        /// <param name="args">Command line arguments</param>
        /// <returns>If target method returns int, this method will return that value. Else,
        /// it will return 0 in case of successs and 1 in case of unhandled exception</returns>
        public int Run(params string[] args)
        {
            try
            {
                AppCreator appCreator = new AppCreator(_settings);

                CommandLineApplication app = appCreator.CreateApplication(typeof(T), DependencyResolver);

                var parsedArguments = ArgumentParser.SplitFlags(args).ToArray();

                return(app.Execute(parsedArguments));
            }
            catch (AppRunnerException e)
            {
                Console.Error.WriteLine(e.Message + "\n");
#if DEBUG
                Console.Error.WriteLine(e.StackTrace);
#endif
                return(1);
            }
            catch (CommandParsingException e)
            {
                Console.Error.WriteLine(e.Message + "\n");
                e.Command.ShowHelp();

#if DEBUG
                Console.Error.WriteLine(e.StackTrace);
#endif

                return(1);
            }
            catch (ValueParsingException e)
            {
                Console.Error.WriteLine(e.Message + "\n");
                return(2);
            }
            catch (AggregateException e) when(e.InnerExceptions.Any(x => x.GetBaseException() is AppRunnerException) ||
                                              e.InnerExceptions.Any(x => x.GetBaseException() is CommandParsingException))
            {
                foreach (var innerException in e.InnerExceptions)
                {
                    Console.Error.WriteLine(innerException.GetBaseException().Message + "\n");
#if DEBUG
                    Console.Error.WriteLine(innerException.GetBaseException().StackTrace);
                    if (e.InnerExceptions.Count > 1)
                    {
                        Console.Error.WriteLine("-----------------------------------------------------------------");
                    }
#endif
                }

                return(1);
            }
            catch (AggregateException e) when(e.InnerExceptions.Any(x => x.GetBaseException() is ArgumentValidationException))

            {
                ArgumentValidationException validationException =
                    (ArgumentValidationException)e.InnerExceptions.FirstOrDefault(x => x.GetBaseException() is ArgumentValidationException);

                foreach (var failure in validationException.ValidationResult.Errors)
                {
                    Console.WriteLine(failure.ErrorMessage);
                }

                return(2);
            }
            catch (AggregateException e) when(e.InnerExceptions.Any(x => x.GetBaseException() is ValueParsingException))

            {
                ValueParsingException valueParsingException =
                    (ValueParsingException)e.InnerExceptions.FirstOrDefault(x => x.GetBaseException() is ValueParsingException);

                Console.Error.WriteLine(valueParsingException.Message + "\n");

                return(2);
            }
            catch (AggregateException e) when(e.InnerExceptions.Any(x => x is TargetInvocationException))
            {
                TargetInvocationException ex =
                    (TargetInvocationException)e.InnerExceptions.SingleOrDefault(x => x is TargetInvocationException);

                ExceptionDispatchInfo.Capture(ex.InnerException ?? ex).Throw();
                return(1); // this will never be called
            }
            catch (AggregateException e)
            {
                foreach (Exception innerException in e.InnerExceptions)
                {
                    ExceptionDispatchInfo.Capture(innerException).Throw();
                }

                return(1); // this will never be called if there is any inner exception
            }
            catch (ArgumentValidationException ex)
            {
                foreach (var failure in ex.ValidationResult.Errors)
                {
                    Console.WriteLine(failure.ErrorMessage);
                }

                return(2);
            }
            catch (TargetInvocationException ex)
            {
                ExceptionDispatchInfo.Capture(ex.InnerException ?? ex).Throw();
                return(1); // this will never be called
            }
        }