Beispiel #1
0
        static void Main(string[] args)
        {
            var outputFile = string.Empty;
            var parser = new OptionParser
            {
                new Option
                {
                    ShortForm = "o",
                    LongForm = "output",
                    Required = true,
                    ActionWithParam = option => outputFile = option
                },
            };

            var inputs = parser.Parse(args);
            if (inputs.Length == 0)
                return;

            Console.WriteLine("Usage: compiler -o output.exe input.exe");
            Console.WriteLine(parser.GetUsage());

            //FIXME: make this use architecture etc
            //var assembly = AssemblyFactory.GetAssembly(inputs[0]);
            //var compiler = new AssemblyCompiler(new MethodCompilerStage(), new GccBuildStage(outputFile));
            //var context = new AssemblyCompilerContext(assembly, assembly.EntryPoint);
            //compiler.Compile(context);
        }
        public void Parser_Flag_Int_Enum_Success(TestOptionEnum value)
        {
            string[] args = new string[] { "-enum", ((int)value).ToString() };

            OptionParser parser = new OptionParser();

            var obj = parser.Parse<TestOptionObject>(args);

            Assert.AreEqual(value, obj.enumValue);

            args[1] = ((int)value).ToString();

            obj = parser.Parse<TestOptionObject>(args);

            Assert.AreEqual(value, obj.enumValue);
        }
        public void Parse_IntValueAndParameterWithShortName_PropertiesAreSetCorrect()
        {
            const int expectedValue0 = 1234;
            const int expectedValue1 = 4321;

            var args = new[] { "hello", "-j", expectedValue1.ToString(), "-i", expectedValue0.ToString() };

            var parser = new OptionParser(typeof(TestOptionWithInt));

            // Act
            var option = parser.Parse(args) as TestOptionWithInt;

            // Assert
            option
            .Should()
            .NotBeNull();

            option !.IntValue
            .Should()
            .Be(expectedValue0);

            option.IntValue2
            .Should()
            .Be(expectedValue1);

            option.DefIntValue
            .Should()
            .Be(1357);
        }
        public void Parse_RequiredValueMissing_ThrowsException()
        {
            var args = Array.Empty <string>();

            var parser = new OptionParser(typeof(TestOptionWithValueOption));

            // Act
            Action act = () => parser.Parse(args);

            // Assert
            var exception = act
                            .Should()
                            .Throw <RequiredArgumentMissingException>()
                            .Which;

            exception.MissingProperty
            .Should()
            .BeSameAs(typeof(TestOptionWithValueOption).GetProperty(nameof(TestOptionWithValueOption.TestValue)));

            exception.ValueAttribute
            .Should()
            .BeEquivalentTo(new OptionValueAttribute(0)
            {
                IsRequired = true
            });
        }
 public void ShortOptionRun_WithColonArgument_ThrowsException()
 {
     var parser = new OptionParser {
         Definitions = SingleNoneArgument
     };
     var results = parser.Parse(new[] { "-aardvark:animal" }).ToArray();
 }
 public void JustASlash_ThrowsException()
 {
     var parser = new OptionParser {
         Definitions = SingleRequiredArgument
     };
     var results = parser.Parse(new[] { "/", "a" }).ToArray();
 }
 public void ShortSlashOptionNoneArgument_WithEmptyEqualsArgument_ThrowsException()
 {
     var parser = new OptionParser {
         Definitions = SingleNoneArgument
     };
     var results = parser.Parse(new[] { "/a=" }).ToArray();
 }
Beispiel #8
0
        /// <summary>
        /// Application entry point for schema synchronizations
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            try
            {
                AppOptions options = OptionParser.Parse <AppOptions>();
                // determine the number of threads to use while processing
                if (options.Threads == 0)
                {
                    options.Threads = Environment.ProcessorCount;
                }
                if (options.Timeout == 0)
                {
                    options.Timeout = 300;
                }
                if (options.UpdateInterval == 0)
                {
                    options.UpdateInterval = 10000;
                }

                options.Source.MaxPoolSize = options.Threads * 4;
                options.Target.MaxPoolSize = options.Threads * 4;
                options.Source.Timeout     = options.Timeout;
                options.Target.Timeout     = options.Timeout;

                // create the synchronizer
                var synchronizer = new SyncSchema(options);
                synchronizer.Sync();
            }
            catch (OptionParsingException e)
            {
                Console.Error.WriteLine(e.Message);
                AppOptions.Usage();
            }
        }
 public void ShortOptionNoneArgument_WithEmptyColonArgument_ThrowsException()
 {
     var parser = new OptionParser {
         Definitions = SingleNoneArgument
     };
     var results = parser.Parse(new[] { "-a:" }).ToArray();
 }
 public void LongSlashOptionNoneArgument_WithEqualsArgument_ThrowsException()
 {
     var parser = new OptionParser {
         Definitions = SingleNoneArgument
     };
     var results = parser.Parse(new[] { "/aardvark=animal" }).ToArray();
 }
        public void SimpleParameters_WithParsedParameter_IsParsed()
        {
            var parameters = new SimpleParameters();

            OptionParser.Parse(new[] { "13" }, parameters);
            Assert.AreEqual(14, parameters.FirstPositionalArgument);
        }
        public void SimpleParameters_WithoutParameter_IsParsed()
        {
            var parameters = new SimpleParameters();

            OptionParser.Parse(new[] { "/f" }, parameters);
            Assert.IsTrue(parameters.Flag);
        }
        public void Parse_RequiredParameterMissing_ThrowsException()
        {
            const int expectedValue1 = 4321;

            var args = new[] { "hello", "-j", expectedValue1.ToString() };

            var parser = new OptionParser(typeof(TestOptionWithInt));

            // Act
            Action act = () => parser.Parse(args);

            // Assert
            var exception = act
                            .Should()
                            .Throw <RequiredArgumentMissingException>()
                            .Which;

            exception.MissingProperty
            .Should()
            .BeSameAs(typeof(TestOptionWithInt).GetProperty(nameof(TestOptionWithInt.IntValue)));

            exception.ParameterAttribute
            .Should()
            .BeEquivalentTo(new OptionParameterAttribute('i', "integer")
            {
                IsRequired = true
            });
        }
        public void SimpleParameters_WithSingleParameter_IsParsed()
        {
            var parameters = new SimpleParameters();

            OptionParser.Parse(new[] { "--Animal", "horse" }, parameters);
            Assert.AreEqual("horse", parameters.Animal);
        }
 public void LongOptionRequiringArgument_WithoutArgument_ThrowsException()
 {
     var parser = new OptionParser {
         Definitions = SingleRequiredArgument
     };
     var results = parser.Parse(new[] { "--aardvark" }).ToArray();
 }
 public void ShortSlashOptionRequiringArgument_WithoutArgument_ThrowsException()
 {
     var parser = new OptionParser {
         Definitions = SingleRequiredArgument
     };
     var results = parser.Parse(new[] { "/a" }).ToArray();
 }
 public void UnknownLongSlashOption_ThrowsException()
 {
     var parser = new OptionParser {
         Definitions = SingleRequiredArgument
     };
     var results = parser.Parse(new[] { "/long" }).ToArray();
 }
 public void ShortOptionRun_WithSecondOptionUnknown_ThrowsException()
 {
     var parser = new OptionParser {
         Definitions = SingleNoneArgument
     };
     var results = parser.Parse(new[] { "-an" }).ToArray();
 }
 public void ShortOptionRun_WithSecondOptionRequiringArgument_ThrowsException()
 {
     var parser = new OptionParser {
         Definitions = NoneOptionalRequiredArguments
     };
     var results = parser.Parse(new[] { "-ac" }).ToArray();
 }
Beispiel #20
0
        public void Should_not_inject_value_into_property_annotated_with_NotAnOption()
        {
            var result = OptionParser.Parse(new[] { "--NotAnOption", "foo" }, new OptionContract {
                NotAnOption = "bar"
            });

            Assert.That(result.Contract.NotAnOption, Is.EqualTo("bar"));
        }
Beispiel #21
0
        public void Shoul_parse_enum_array()
        {
            var result = OptionParser.Parse <OptionContract>(new[] { "-EnumArrayTest=Foo,Bar" });

            Assert.That(result.Contract.EnumArrayTest, Is.Not.Null);
            Assert.That(result.Contract.EnumArrayTest, Has.Length.EqualTo(2));
            Assert.That(result.Contract.EnumArrayTest[0], Is.EqualTo(MyEnum.Foo));
            Assert.That(result.Contract.EnumArrayTest[1], Is.EqualTo(MyEnum.Bar));
        }
Beispiel #22
0
        public void Should_parse_named_option()
        {
            var result = OptionParser.Parse <OptionContract>(new[] { "--NamedTest", "foo" });

            Assert.That(result.Contract.NamedTest, Is.Null);

            result = OptionParser.Parse <OptionContract>(new[] { "--lollersk8", "foo" });
            Assert.That(result.Contract.NamedTest, Is.EqualTo("foo"));
        }
Beispiel #23
0
        public void Should_parse_flag_option()
        {
            var result = OptionParser.Parse <OptionContract>(new[] { "--FlagTest" });

            Assert.That(result.Contract.FlagTest, Is.True);

            result = OptionParser.Parse <OptionContract>(new[] { "--NotFlagTest" });
            Assert.That(result.Contract.FlagTest, Is.False);
        }
Beispiel #24
0
        public void Should_parse_case_sensitively()
        {
            var result = OptionParser.Parse <OptionContract>(new[] { "--CaseTest", "foo" });

            Assert.That(result.Contract.CaseTest, Is.EqualTo("foo"));

            result = OptionParser.Parse <OptionContract>(new[] { "--casetest", "foo" });
            Assert.That(result.Contract.CaseTest, Is.Null);
        }
Beispiel #25
0
        static void Main(string[] args)
        {
            OptionParser parser = new OptionParser();
            var setting = parser.Parse(args);

            SignHost.SignPath(setting);

            System.Console.ReadLine();
        }
Beispiel #26
0
        /// <summary>
        /// Executes the parse for the given key/arguments
        /// </summary>
        /// <returns></returns>
        protected override object ParseFromTokens(IEnumerable <Token> targetTokens)
        {
            // instance the value
            var returnValue = Activator.CreateInstance(this._Model.TargetType);

            // no token: return the empty option class
            if (!targetTokens.Any())
            {
                return(returnValue);
            }

            // I need to parse the options
            var tokens = targetTokens.Skip(1).ToList();

            // get properties to map
            var optionDefinitions = OptionDefinitionAttributeHelper.ExtractPropertiesMarkedWithOptionAttribute(this._Model.TargetType);
            Dictionary <PropertyInfo, OptionDefinitionAttribute> alreadyConsidered = new Dictionary <PropertyInfo, OptionDefinitionAttribute>();

            foreach (var token in tokens)
            {
                // find corresponding attribute
                var attribute      = AssertOptionAttributeExists(targetTokens.First().Name, token, optionDefinitions);
                var targetProperty = optionDefinitions.Single(x => x.Value.Code == token.Name || x.Value.LongCode == token.Name).Key;

                // parse the value
                var optionParser = new OptionParser(Option.FromAttribute(attribute).OnTargetProperty(targetProperty.PropertyType));
                var outputValue  = optionParser.Parse(token.AsNaturalString());

                // update the value
                targetProperty.SetValue(returnValue, outputValue);

                // already managed
                alreadyConsidered.Add(targetProperty, attribute);
            }

            // considered not managed
            foreach (var opt in optionDefinitions)
            {
                var definition = alreadyConsidered.Values.SingleOrDefault(x => x.Code == opt.Value.Code);
                if (definition != null)
                {
                    continue;
                }
                if (opt.Value.Mandatory)
                {
                    throw new InvalidCLIArgumentException($"Mandatory option {opt.Value.Code} not found in {this._Model.TargetType.Name}", "opt.Value.Code");
                }
                if (opt.Value.DefaultValue != null)
                {
                    var targetProperty = opt.Key;
                    targetProperty.SetValue(returnValue, opt.Value.DefaultValue);
                }
            }

            return(returnValue);
        }
Beispiel #27
0
        public void Should_parse_numbers()
        {
            Assert.That(OptionParser.Parse <OptionContract>(new[] { "--IntTest", "1" }).Contract.IntTest, Is.EqualTo(1));
            Assert.That(OptionParser.Parse <OptionContract>(new[] { "--IntTest", "7" }).Contract.IntTest, Is.EqualTo(7));
            Assert.That(OptionParser.Parse <OptionContract>(new[] { "--IntTest", "-20" }).Contract.IntTest, Is.EqualTo(-20));

            Assert.That(OptionParser.Parse <OptionContract>(new[] { "--DoubleTest", "1" }).Contract.DoubleTest, Is.EqualTo(1));
            Assert.That(OptionParser.Parse <OptionContract>(new[] { "--DoubleTest", "7.5" }).Contract.DoubleTest, Is.EqualTo(7.5));
            Assert.That(OptionParser.Parse <OptionContract>(new[] { "--DoubleTest", "-20.0" }).Contract.DoubleTest, Is.EqualTo(-20));
        }
        public void Parser_Public_Property_Success(int value)
        {
            string[] args = new string[] { "-intValue", value.ToString() };

            OptionParser parser = new OptionParser();

            var obj = parser.Parse<TestOptionObject>(args);

            Assert.AreEqual(value, obj.intValue);
        }
Beispiel #29
0
        public void Should_parse_array()
        {
            var result = OptionParser.Parse <OptionContract>(new[] { "--ArrayTest", "foo,bar,baz" });

            Assert.That(result.Contract.ArrayTest, Is.Not.Null);
            Assert.That(result.Contract.ArrayTest, Has.Length.EqualTo(3));
            Assert.That(result.Contract.ArrayTest[0], Is.EqualTo("foo"));
            Assert.That(result.Contract.ArrayTest[1], Is.EqualTo("bar"));
            Assert.That(result.Contract.ArrayTest[2], Is.EqualTo("baz"));
        }
Beispiel #30
0
        public void Shoul_parse_non_string_array()
        {
            var result = OptionParser.Parse <OptionContract>(new[] { "--IntArrayTest", "5|4|-100" });

            Assert.That(result.Contract.IntArrayTest, Is.Not.Null);
            Assert.That(result.Contract.IntArrayTest, Has.Length.EqualTo(3));
            Assert.That(result.Contract.IntArrayTest[0], Is.EqualTo(5));
            Assert.That(result.Contract.IntArrayTest[1], Is.EqualTo(4));
            Assert.That(result.Contract.IntArrayTest[2], Is.EqualTo(-100));
        }
Beispiel #31
0
        public void Should_catch_error_when_value_cannot_be_parsed_in_array()
        {
            var result = OptionParser.Parse <OptionContract>(new[] { "--IntArrayTest=asdf" });

            Assert.That(result.IsValid, Is.False);

            Assert.That(result.Errors.Count(), Is.EqualTo(1));
            Assert.That(result.Errors.First().Argument, Is.EqualTo("--IntArrayTest=asdf"));
            Assert.That(result.Errors.First().ThrownException, Is.TypeOf <FormatException>());
        }
Beispiel #32
0
        public void Should_inject_non_option_valuus_as_array_into_value_property()
        {
            var result = OptionParser.Parse <OptionContract2>(new[] { "foo", "--Meh", "bar", "baz", "foo=bar", "-dne" });

            Assert.That(result.Contract.Values.Count(), Is.EqualTo(4));
            Assert.That(result.Contract.Values.ElementAt(0), Is.EqualTo("foo"));
            Assert.That(result.Contract.Values.ElementAt(1), Is.EqualTo("baz"));
            Assert.That(result.Contract.Values.ElementAt(2), Is.EqualTo("foo=bar"));
            Assert.That(result.Contract.Values.ElementAt(3), Is.EqualTo("-dne"));
        }
Beispiel #33
0
        static int Main(string[] args)
        {
            var opts = new OptionParser();
            opts.On("help", "display this help and exit").Do(() =>
            {
                opts.WriteUsage(Console.Out);
                Environment.Exit(0);
            });
            opts.On("version", 'V', "print version information and exit").Do(() =>
            {
                opts.WriteVersionInfo(Console.Out);
                Environment.Exit(0);
            });

            try
            {
                var commandType = App.Commands
                   .SingleOrDefault(NamedAsExecutable)
                   ?? typeof(UnknownCommand);

                var command = ((ICommand)Activator.CreateInstance(commandType));

                command.WithOptions(opts);
                opts.Parse(args);
                return command.Execute();
            }
            catch (OptionParserException ex)
            {
                Console.Error.WriteLine(ex.Message);
                opts.WriteUsageHeader(Console.Error);
                Console.Error.WriteLine("\nTry `{0} --help' for more options.", App.CommandName);
                return 2;
            }
            catch (Exception ex)
            {
                Console.Error.WriteLine(ex.Message);
                return 1;
            }
        }