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();
}
/// <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();
}
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"));
}
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));
}
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"));
}
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);
}
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);
}
static void Main(string[] args)
{
OptionParser parser = new OptionParser();
var setting = parser.Parse(args);
SignHost.SignPath(setting);
System.Console.ReadLine();
}
/// <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);
}
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);
}
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"));
}
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));
}
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>());
}
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"));
}
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;
}
}