public void PositionalArguments( string[] args, string firstParsedArgument, string secondParsedArgument, ICommandLineParser parser) { const string FirstArgument = "firstArgument"; const string SecondArgument = "secondArgument"; "establish positional arguments".x(() => args = new[] { FirstArgument, SecondArgument }); "establish a parser with parsing configuration for positional arguments".x(() => { parser = new CommandLineParser(CommandLineParserConfigurator .Create() .WithPositional(v => firstParsedArgument = v) .WithPositional(v => secondParsedArgument = v) .BuildConfiguration()); }); "when parsing".x(() => parser.Parse(args)); "should parse positional argument".x(() => new[] { firstParsedArgument, secondParsedArgument } .Should().Equal(FirstArgument, SecondArgument)); }
public void ValueConvertion( string[] args, int firstParsedArgument, bool secondParsedArgument, ICommandLineParser parser) { const int Value = 42; "establish non-string arguments".x(() => args = new[] { "-value", Value.ToString(), "true" }); "establish a parser with parsing configuration with type convertion".x(() => { parser = new CommandLineParser(CommandLineParserConfigurator .Create() .WithNamed("value", (int v) => firstParsedArgument = v) .WithPositional((bool v) => secondParsedArgument = v) .BuildConfiguration()); }); "when parsing".x(() => parser.Parse(args)); "should convert parsed named arguments".x(() => firstParsedArgument.Should().Be(Value)); "should convert parsed positional arguments".x(() => secondParsedArgument.Should().BeTrue()); }
public void SupportsRestrictedValues( string value, string expectedParsedValue, bool expectedSuccessful, string[] args, string parsedValue, ICommandLineParser parser, ParseResult parseResult) { "establish arguments".x(() => args = new[] { "-n", value }); "establish a parser with parsing configuration with value check".x(() => { parser = new CommandLineParser(CommandLineParserConfigurator .Create() .WithNamed("n", v => parsedValue = v) .RestrictedTo(KnownValue) .BuildConfiguration()); }); "when parsing".x(() => parseResult = parser.Parse(args)); "should parse allowed values".x(() => parsedValue.Should().Be(expectedParsedValue)); "should fail for not allowed values".x(() => parseResult.Succeeded.Should().Be(expectedSuccessful)); }
public void SupportsLongAliasForSwitch( string[] args, bool firstParsedSwitch, string secondParsedSwitch, ICommandLineParser parser) { "establish arguments with switch with long alias".x(() => args = new[] { "-f", "--secondSwitch" }); "establish a parser with parsing configuration for switches with long aliases".x(() => { parser = new CommandLineParser(CommandLineParserConfigurator .Create() .WithSwitch("f", () => firstParsedSwitch = true) .HavingLongAlias("firstSwitch") .WithSwitch("s", () => secondParsedSwitch = "yeah") .HavingLongAlias("secondSwitch") .BuildConfiguration()); }); "when parsing".x(() => parser.Parse(args)); "should parse switch".x(() => new object[] { firstParsedSwitch, secondParsedSwitch } .Should().Equal(true, "yeah")); }
public void RequiredPositional( string[] args, string firstParsedArgument, string secondParsedArgument, ICommandLineParser parser, ParseResult result) { const string FirstName = "firstName"; const string FirstValue = "firstValue"; const string SecondName = "secondName"; const string SecondValue = "secondValue"; "establish some arguments with missing required positional argument".x(() => args = new[] { "-" + FirstName, FirstValue, "-" + SecondName, SecondValue }); "establish a parser with parsing configuration with required positional arguments".x(() => { parser = new CommandLineParser(CommandLineParserConfigurator .Create() .WithPositional(v => { }) .Required() .WithNamed(FirstName, v => { }) .WithNamed(SecondName, v => { }) .BuildConfiguration()); }); "when parsing".x(() => result = parser.Parse(args)); "should return parsing failure".x(() => result.Succeeded.Should().BeFalse()); }
public void Switch( string[] args, bool firstParsedSwitch, string secondParsedSwitch, ICommandLineParser parser) { "establish arguments with switch".x(() => args = new[] { "-firstSwitch", "-secondSwitch" }); "establish a parser with parsing configuration for switches".x(() => { CommandLineConfiguration configuration = CommandLineParserConfigurator .Create() .WithSwitch("firstSwitch", () => firstParsedSwitch = true) .WithSwitch("secondSwitch", () => secondParsedSwitch = "yeah") .BuildConfiguration(); parser = new CommandLineParser(configuration); }); "when parsing".x(() => parser.Parse(args)); "should parse switch".x(() => new object[] { firstParsedSwitch, secondParsedSwitch } .Should().Equal(true, "yeah")); }
public static void Main(string[] args) { const string ShortOutput = "short"; const string LongOutput = "long"; // set default values here string output = null; bool debug = false; string path = null; string value = null; int threshold = 0; var configuration = CommandLineParserConfigurator .Create() .WithNamed("o", v => output = v) .HavingLongAlias("output") .Required() .RestrictedTo(ShortOutput, LongOutput) .DescribedBy("method", "specifies the output method.") .WithNamed("t", (int v) => threshold = v) .HavingLongAlias("threshold") .DescribedBy("value", "specifies the threshold used in output.") .WithSwitch("d", () => debug = true) .HavingLongAlias("debug") .DescribedBy("enables debug mode") .WithPositional(v => path = v) .Required() .DescribedBy("path", "path to the output file.") .WithPositional(v => value = v) .DescribedBy("value", "some optional value.") .BuildConfiguration(); var parser = new CommandLineParser(configuration); var parseResult = parser.Parse(args); if (!parseResult.Succeeded) { Usage usage = new UsageComposer(configuration).Compose(); Console.WriteLine(parseResult.Message); Console.WriteLine("usage:" + usage.Arguments); Console.WriteLine("options"); Console.WriteLine(usage.Options.IndentBy(4)); Console.WriteLine(); return; } Console.WriteLine("parsed successfully: path = " + path + ", value = " + value + "output = " + output + ", debug = " + debug + ", threshold = " + threshold); }
public void RealWorldScenario( string[] args, bool firstParsedSwitch, string secondParsedSwitch, string firstNamedValue, string secondNamedValue, string firstPositionalValue, string secondPositionalValue, ICommandLineParser parser) { "establish arguments".x(() => args = new[] { "1u", "-secondSwitch", "-firstName", "1n", "-firstSwitch", "-secondName", "2n", "2u" }); "establish a parsing configuration".x(() => { var configuration = CommandLineParserConfigurator .Create() .WithNamed("firstName", s => firstNamedValue = s) .Required() .RestrictedTo("1n", "??") .DescribedBy("name", "the first name") .WithSwitch("firstSwitch", () => firstParsedSwitch = true) .WithPositional(x => firstPositionalValue = x) .Required() .WithSwitch("secondSwitch", () => secondParsedSwitch = "yeah") .HavingLongAlias("theOtherSwitch") .DescribedBy("the second switch") .WithPositional(x => secondPositionalValue = x) .WithNamed("secondName", s => secondNamedValue = s) .BuildConfiguration(); parser = new CommandLineParser(configuration); }); "when parsing".x(() => parser.Parse(args)); "should parse arguments".x(() => new object[] { firstParsedSwitch, secondParsedSwitch, firstNamedValue, secondNamedValue, firstPositionalValue, secondPositionalValue } .Should().Equal(true, "yeah", "1n", "2n", "1u", "2u")); }
public void UnknownArgument( string[] args, CommandLineConfiguration configuration, UsageComposer usageComposer, Usage usage) { "establish a parsing configuration"._(() => { configuration = CommandLineParserConfigurator .Create() .WithNamed("optional", _) .DescribedBy("placeholder", "optional description") .WithNamed("required", _) .Required() .DescribedBy("placeholder", "required description") .BuildConfiguration(); }); "establish a usage composer using the parsing configuration"._(() => { usageComposer = new UsageComposer(configuration); }); "when composing usage"._(() => usage = usageComposer.Compose()); "should list arguments"._(() => usage.Arguments .Should().Contain("-optional <placeholder>") .And.Contain("-required <placeholder>")); "should show whether an argument is optional or required"._(() => (usage.Arguments + " ") .Should().Contain("[-optional <placeholder>]") .And.Contain(" -required <placeholder> ")); "should list options per argument with description"._(() => usage.Options .Should().Contain("optional description") .And.Contain("required description")); }
public void SupportsLongAliasForNamed( string[] args, string nameParsedArgument, string longAliasParsedArgument, ICommandLineParser parser) { const string Name = "s"; const string ShortValue = "short"; const string LongAlias = "long"; const string LongAliasValue = "long"; "establish named arguments with long alias".x(() => args = new[] { "-" + Name, ShortValue, "--" + LongAlias, LongAliasValue }); "establish a parser with parsing configuration with long aliases".x(() => { parser = new CommandLineParser(CommandLineParserConfigurator .Create() .WithNamed(Name, v => nameParsedArgument = v) .HavingLongAlias("_") .WithNamed("_", v => longAliasParsedArgument = v) .HavingLongAlias(LongAlias) .BuildConfiguration()); }); "when parsing".x(() => parser.Parse(args)); "should parse named arguments".x(() => new[] { nameParsedArgument, longAliasParsedArgument } .Should().Equal(ShortValue, LongAliasValue)); }
static void Main(string[] args) { List <AbsoluteFilePath> paths = null; var configuration = CommandLineParserConfigurator.Create() .WithPositional(v => paths = v.Split(';').Select(x => new AbsoluteFilePath(Path.GetFullPath(x))).ToList()) .BuildConfiguration(); var parser = new CommandLineParser(configuration); var result = parser.Parse(args); if (!result.Succeeded) { Console.WriteLine(result.Message); return; } foreach (AbsoluteFilePath path in paths) { ConvertFile(path); } }
public void NamedArguments( string[] args, string firstParsedArgument, string secondParsedArgument, ICommandLineParser parser) { const string FirstName = "firstName"; const string FirstValue = "firstValue"; const string SecondName = "secondName"; const string SecondValue = "secondValue"; "establish named arguments".x(() => args = new[] { "-" + FirstName, FirstValue, "-" + SecondName, SecondValue }); "establish a parser with parsing configuration for named arguments".x(() => { parser = new CommandLineParser(CommandLineParserConfigurator .Create() .WithNamed(FirstName, v => firstParsedArgument = v) .WithNamed(SecondName, v => secondParsedArgument = v) .BuildConfiguration()); }); "when parsing".x(() => parser.Parse(args)); "should parse named arguments".x(() => new[] { firstParsedArgument, secondParsedArgument } .Should().Equal(FirstValue, SecondValue)); }
public static int Main(string[] args) { string input = null; string output = null; string markup = Markdown; var configuration = CommandLineParserConfigurator .Create() .WithNamed("i", v => input = v) .HavingLongAlias("input") .Required() .DescribedBy("path", "specifies the input path pointing to a xBehave/xUnit XML report.") .WithNamed("o", v => output = v) .HavingLongAlias("output") .Required() .DescribedBy("path", "specifies the output path where the generated markdown will be written to.") .WithNamed("m", v => markup = v) .HavingLongAlias("markup") .DescribedBy($"markup [{Markdown} | {DokuWiki}]", "specifies which markup to use") .BuildConfiguration(); var parser = new CommandLineParser(configuration); var parseResult = parser.Parse(args); if (!parseResult.Succeeded) { Usage usage = new UsageComposer(configuration).Compose(); Console.WriteLine(parseResult.Message); Console.WriteLine("usage:" + usage.Arguments); Console.WriteLine("options"); Console.WriteLine(usage.Options.IndentBy(4)); Console.WriteLine(); return(InvalidFunction); } if (!File.Exists(input)) { Console.WriteLine("Input file '{0}' does not exist, please define an existing file.", input); return(FileNotFound); } IMarkupWriter markupWriter; switch (markup.ToLowerInvariant()) { case Markdown: markupWriter = new MarkdownWriter(); break; case DokuWiki: markupWriter = new DokuWikiWriter(); break; default: return(InvalidMarkup); } var inputXml = XDocument.Load(input); var converter = new Converter(markupWriter); var outputMarkdown = converter.Convert(inputXml); using (var writer = new StreamWriter(output)) { writer.Write(outputMarkdown); } return(Ok); }
static void Main(string[] args) { string direction = string.Empty; bool query = false; bool raw = false; bool init = false; bool deInit = false; bool help = false; bool htmlReport = false; string inject = string.Empty; string tags = string.Empty; string timeSpan = string.Empty; bool pause = false; var configuration = CommandLineParserConfigurator .Create() .WithSwitch("q", () => query = true).HavingLongAlias("query").DescribedBy("Call the db and get your working times.") .WithSwitch("r", () => raw = true).HavingLongAlias("raw").DescribedBy("Get all logged events") .WithSwitch("i", () => init = true).HavingLongAlias("init").DescribedBy("Create windows tasks (you need elevated permissions for this one!") .WithSwitch("d", () => deInit = true).HavingLongAlias("deinit").DescribedBy("Remove windows tasks (you need elevated permissions for this one!") .WithSwitch("b", () => pause = true).HavingLongAlias("pause").DescribedBy("Manage your breaks") .WithSwitch("h", () => help = true).HavingLongAlias("help").DescribedBy("Show this usage screen.") .WithSwitch("o", () => htmlReport = true).HavingLongAlias("out").DescribedBy("Show html report.") .WithNamed("j", I => inject = I).HavingLongAlias("inject").DescribedBy("Time|Direction\"", "Use this for debugging only! You can inject timestamps. 1 for lock, 0 for unlock") .WithNamed("t", t => tags = t).HavingLongAlias("tags").DescribedBy("timestamp|Tag1,Tag2,...\"", "Tag a timestamp; use ticks for the timestamp (-r shows them)") .WithPositional(d => direction = d).DescribedBy("lock", "tell me to \"lock\" for \"out\" and keep empty for \"in\"") .BuildConfiguration(); var parser = new CommandLineParser(configuration); var parseResult = parser.Parse(args); if (!parseResult.Succeeded || args.Length == 0) { ShowUsage(configuration, parseResult.Message); Environment.Exit((int)ExitCode.ArgumentError); } else { if (help) { ShowUsage(configuration); Environment.Exit((int)ExitCode.OK); } if (init) { using (TaskService ts = new TaskService()) { try { DefineTask(ts, "myLock lock screen", "lock_pc", TriggerType.Lock); DefineTask(ts, "myLock unlock screen", "unlock_pc", TriggerType.Unlock); DefineTask(ts, "myLock login to pc", "login_pc", TriggerType.Logon); DefineTask(ts, "myLock logout from pc", "logout_pc", TriggerType.Logoff); DefineTask(ts, "myLock energysaver from pc", "energysave_pc", TriggerType.Energysave); Console.WriteLine("Initialization complete."); Environment.Exit((int)ExitCode.OK); } catch (UnauthorizedAccessException) { Console.Error.WriteLine("Access denied, please use an elevated prompt."); Environment.Exit((int)ExitCode.Exception); } } } if (deInit) { using (TaskService ts = new TaskService()) { try { //Remove tasks foreach (var t in ts.RootFolder.AllTasks) { if (t.Name.StartsWith(taskPrefix)) { ts.RootFolder.DeleteTask(t.Name); } } Console.WriteLine("Deinitialization complete."); Environment.Exit((int)ExitCode.OK); } catch (UnauthorizedAccessException) { Console.Error.WriteLine("Access denied, please use an elevated prompt."); Environment.Exit((int)ExitCode.Exception); } } } if (!string.IsNullOrEmpty(inject)) { TimeStampCollection col; try { col = Saver.Load <TimeStampCollection>(dbFile); } catch (FileNotFoundException) { col = new TimeStampCollection(); } TimeStamp stamp = new TimeStamp(); string[] injection = inject.Split('|'); stamp.Stamp = DateTime.Parse(injection[0]); if (injection.Length > 1) { stamp.Direction = (Direction)(Convert.ToInt32(injection[1])); } if (injection.Length > 2) { stamp.User = injection[2]; } col.TimeStamps.Add(stamp); col.TimeStamps.Sort(); Saver.Save <TimeStampCollection>(dbFile, col); Console.WriteLine("Injection successfull."); Console.WriteLine("Values were: {0}", inject); Environment.Exit((int)ExitCode.OK); } if (raw) { TimeStampCollection col = Saver.Load <TimeStampCollection>(dbFile); foreach (var t in col.TimeStamps) { Console.WriteLine("{0,-10} {1} {2} {3} {4}", UnixTimestampFromDateTime(t.Stamp), t.Stamp, t.User, t.Direction, (t.Tags.Count > 0) ? "Tags: " + String.Join(", ", t.Tags) : string.Empty); } Console.WriteLine("EOF"); Environment.Exit((int)ExitCode.OK); } if (pause) { interactivebreaktime(0); } if (!string.IsNullOrEmpty(tags)) { TimeStampCollection col; try { col = Saver.Load <TimeStampCollection>(dbFile); } catch (FileNotFoundException) { col = new TimeStampCollection(); } int iPipe = tags.IndexOf("|"); if (iPipe == -1) { Console.Error.WriteLine("Wrong input format, use \"Ticks|foo,bar,zwusch\"!"); Environment.Exit(-3); } long lTicks = long.Parse(tags.Substring(0, iPipe)); List <string> tagList = tags.Substring(iPipe + 1).Split(',').ToList <string>(); try { var q = (from c in col.TimeStamps where UnixTimestampFromDateTime(c.Stamp) == lTicks select c).Single(); q.Tags.AddRange(tagList); Saver.Save <TimeStampCollection>(dbFile, col); } catch (InvalidOperationException) { Console.Error.WriteLine("Timestamp {0} could not be found. Check with \"-r\".", lTicks); Environment.Exit((int)ExitCode.Exception); } } if (!query) { LogTimeStamp(direction); } else { if (!htmlReport) { QueryWorkingTimes(timeSpan); } else { } } } }