Exemple #1
0
        /// <summary>
        /// Prints the usage for given type <typeparamref name="T"/>
        /// </summary>
        /// <typeparam name="T">class that mape arguments for CLI</typeparam>
        public static void PrintOnConsoleFor <T>(string alias) where T : ICLIArguments
        {
            // analyze the target type and build the model for usage
            var analyzer = new ArgumentModelAnalyzer <T>();

            analyzer.Analyze();
            var model = analyzer.BuildModel();

            // print usage
            var helper = new ConsoleUsagePrinter(model, alias);

            helper.Print();
        }
Exemple #2
0
        public void ParseConsoleArguments_WorksFine()
        {
            //******** GIVEN
            string[] arguments = new string[] { "/copy", @"--src='C:\Temp\Pluto'", "--singleOutput", "--v=WARN" };
            var      analyizer = new ArgumentModelAnalyzer <TestArguments>();

            analyizer.Analyze();
            var model      = analyizer.BuildModel();
            var aggregator = new CLIArgumentAggregator(model);

            //******** WHEN
            string[] parsed = aggregator.AdaptFromCLI(arguments);

            //******** ASSERT
            Assert.IsNotNull(parsed);
            Assert.AreEqual(arguments.Length - 1, parsed.Length);
            Assert.AreEqual(@"/copy --src='C:\Temp\Pluto'", parsed[0]);
            Assert.AreEqual(arguments[3], parsed[1]);
            Assert.AreEqual(arguments[2], parsed[2]);
        }
Exemple #3
0
        public void ExampleOnRootArgumentIsSuccesfullyPrinted()
        {
            //******** GIVEN
            var testArguments = new OnlyOptionsArguments();
            var analyzer      = new ArgumentModelAnalyzer <OnlyOptionsArguments>();

            analyzer.Analyze();
            var model = analyzer.BuildModel();

            this._Printer = new StringBuilderUsagePrinter(model, "my.exe");

            //******** WHEN
            this._Printer.Print();

            //******** ASSERT
            var text = this._Printer.GetText();

            Assert.IsNotNull(text);
            Assert.IsTrue(text.Contains(testArguments.Examples.ToList()[0].HelpText), $"Unable to find help text {testArguments.Examples.ToList()[0].HelpText}");
            Assert.IsTrue(text.Contains(testArguments.Examples.ToList()[1].HelpText), $"Unable to find help text {testArguments.Examples.ToList()[1].HelpText}");
        }
Exemple #4
0
        public void ExampleOnVerbAreSuccesfullyPrinted()
        {
            //******** GIVEN
            var testArguments = new OptionsPlusVerbArguments()
            {
                CopyWithArguments = new CopyFilesWith1MandatoryOption()
            };
            var analyzer = new ArgumentModelAnalyzer <OptionsPlusVerbArguments>();

            analyzer.Analyze();
            var model = analyzer.BuildModel();

            this._Printer = new StringBuilderUsagePrinter(model, "my.exe");

            //******** WHEN
            this._Printer.Print();

            //******** ASSERT
            var text = this._Printer.GetText();

            Assert.IsNotNull(text);
            Assert.IsTrue(text.Contains(testArguments.CopyWithArguments.Examples.ToList()[0].HelpText), $"Unable to find help text {testArguments.CopyWithArguments.Examples.ToList()[0].HelpText}");
        }
Exemple #5
0
        /// <summary>
        /// Parses the cli arguments and stores internally the proper models
        /// </summary>
        /// <param name="args">string arguments of the CLI</param>
        /// <exception cref="System.ArgumentException">Thrown if <paramref name="args"/> is null, empty or whitespace.</exception>
        public T Parse <T>(string[] args) where T : CLIArguments
        {
            string[] _Arguments = args ?? throw new ArgumentNullException(nameof(args));

            // parsing
            if (this._ArgumentsAdapter != null)
            {
                _Arguments = this._ArgumentsAdapter.Invoke(args);
            }

            // initialize the output
            T parsedArguments = null;

            try
            {
                // analyze the target type and build the model for usage
                var analyzer = new ArgumentModelAnalyzer <T>();
                analyzer.Analyze();
                this._Model = analyzer.BuildModel();

                // if needed, I aggregate options for verbs with the verb itself
                if (!_UseAggregatedArgumentsAsInputForVerbs)
                {
                    var aggregator = new CLIArgumentAggregator(this._Model);
                    _Arguments = aggregator.AdaptFromCLI(_Arguments);
                }

                // instance a new item
                parsedArguments = (T)this._ArgumentsActivator();
                List <KeyValuePair <PropertyInfo, Option> > options;
                List <KeyValuePair <PropertyInfo, Verb> >   verbs;
                ParseArguments(_Arguments, parsedArguments, out options, out verbs);

                // check mandatory fields
                foreach (var opt in options.Where(x => x.Value.Mandatory))
                {
                    var currentValue = opt.Key.GetValue(parsedArguments);
                    if (currentValue == null)
                    {
                        throw new InvalidCLIArgumentException($"Invalid Argument: {opt.Value.LongCode} is missing", opt.Value.LongCode);
                    }
                }

                // success
                if (this._OnSuccessCallback != null)
                {
                    this._OnSuccessCallback(parsedArguments);
                }
            }
            catch (Exception ex)
            {
                //store the error
                this._OccurredError = ex;
                // callback
                if (this._OnErrorCallback != null)
                {
                    this._OnErrorCallback(ex);
                }
            }

            return(parsedArguments);
        }