public static void InvalidCommandValues_ShouldRecommendHelp() { var args = new[] { "-n", "1" }; var dummyParsingErrorPrinter = new DummyParsingErrorPrinter(); var called = false; var builder = FluentArgsBuilder.New() .DefaultConfigs() .RegisterParsingErrorPrinter(dummyParsingErrorPrinter) .Given.Command("-n") .HasValue("111").Then(() => called = true) .ElseIsInvalid() .Call(() => called = true); var parseSuccess = builder.Parse(args); parseSuccess.Should().BeFalse(); called.Should().BeFalse(); dummyParsingErrorPrinter.ArgumentMissingErrors.Should().BeEmpty(); dummyParsingErrorPrinter.ArgumentParsingErrors.Should().BeEmpty(); dummyParsingErrorPrinter.InvalidStateErrors.Should().Be(0); dummyParsingErrorPrinter.InvalidCommandValueErrors.Count.Should().Be(1); dummyParsingErrorPrinter.InvalidCommandValueErrors.First().aliases.Should().BeEquivalentTo("-n"); dummyParsingErrorPrinter.InvalidCommandValueErrors.First().helpFlagAliases.Should().BeEquivalentTo("-h", "--help"); dummyParsingErrorPrinter.NotAllArgumentsAreUsedErrors.Should().BeEmpty(); }
public static void FailedValidationWithCustomParser_ShouldRecommendHelp() { var args = new[] { "101" }; var dummyParsingErrorPrinter = new DummyParsingErrorPrinter(); var called = false; var builder = FluentArgsBuilder.New() .DefaultConfigs() .RegisterParsingErrorPrinter(dummyParsingErrorPrinter) .PositionalArgument <int>() .WithParser(_ => 110) .WithValidation(n => n < 100) .IsRequired() .Call(_ => called = true); var parseSuccess = builder.Parse(args); parseSuccess.Should().BeFalse(); called.Should().BeFalse(); dummyParsingErrorPrinter.ArgumentMissingErrors.Should().BeEmpty(); dummyParsingErrorPrinter.InvalidStateErrors.Should().Be(0); dummyParsingErrorPrinter.ArgumentParsingErrors.Count.Should().Be(1); dummyParsingErrorPrinter.ArgumentParsingErrors.First().aliases.Should().BeNull(); dummyParsingErrorPrinter.ArgumentParsingErrors.First().helpFlagAliases.Should().BeEquivalentTo("-h", "--help"); dummyParsingErrorPrinter.InvalidCommandValueErrors.Should().BeEmpty(); dummyParsingErrorPrinter.NotAllArgumentsAreUsedErrors.Should().BeEmpty(); }
public static Task Main(string[] args) { return(FluentArgsBuilder.New() .DefaultConfigsWithAppDescription("This app allows to access a remote file system and to execute some commands on it.") .Parameter("-k", "--apikey") .WithDescription("The api key") .IsRequired() .Parameter <uint>("-t", "--timeout") .WithDescription("Command timeout in seconds") .IsOptionalWithDefault(60) .Given.Command("-c", "--command") .HasValue("init").Then(timeout => apiKey => Init(apiKey, timeout)) .HasValue("delete").Then(b => b .Parameter("-f", "--file") .WithDescription("The file to delete") .IsRequired() .Call(file => timeout => apiKey => Delete(apiKey, file, timeout))) .HasValue("move").Then(b => b .Parameter("-s", "--source") .WithDescription("Source path") .IsRequired() .Parameter("-d", "--destination") .WithDescription("Destination path") .IsRequired() .Call(destination => source => timeout => apiKey => Move(apiKey, source, destination, timeout))) .ElseIsInvalid() .Invalid() .ParseAsync(args)); }
public static void Main(string[] args) { FluentArgsBuilder.New() .Parameter <int>("-n").IsRequired() .Call(n => MyBlockingApp(n)) .Parse(args); }
public static void Main(string[] args) { FluentArgsBuilder.New() .WithApplicationDescription("A simple calculator: add two numbers") .Given.Flag("-v", "--version").Then(() => { /* ... */ Console.WriteLine("Program version: 2.0"); /* ... */ }) .Given.Flag("-u", "--update").Then(b => b .Parameter <Uri>("-s", "--source") .WithDescription("Update source url") .IsOptionalWithDefault(new Uri("http://my-update-server.com/update.zip")) .Call(uri => { /* ... */ Console.WriteLine($"Install update from {uri}..."); /* ... */ })) .PositionalArgument <int>() .WithDescription("The first number") .IsRequired() .PositionalArgument <int>() .WithDescription("the second number") .IsRequired() .Call(n2 => n1 => { /* ... */ Console.WriteLine($"{n1}+{n2}={n1 + n2}"); /* ... */ }) .Parse(args); }
// TODO: Enum parser private static IParsable BuildParser(DummyClient dummyClient) { return(FluentArgsBuilder.New() .Parameter("--apikey", "-k").IsRequired() .Given.Command("--action", "--act", "-a") .HasValue("copy").Then(b => b .Parameter("--source", "-s").IsRequired() .Parameter("--target", "-t").IsRequired() .Call(target => source => apiKey => { dummyClient.ApiKey = apiKey; dummyClient.CopyFile(source, target); })) .HasValue("delete", "del").Then(b => b .Parameter("--file", "-f").IsRequired() .Call(file => apiKey => { dummyClient.ApiKey = apiKey; dummyClient.DeleteFile(file); })) .HasValue("reset").Then(b => b .Parameter <int?>("--timeout", "-t").IsOptional() .Call(timeout => apiKey => { dummyClient.ApiKey = apiKey; dummyClient.ResetAccount(timeout); })) .ElseIsInvalid() .Invalid() .Build()); }
public static void Main(string[] args) { FluentArgsBuilder.New() .WithApplicationDescription("This application demonstrates how to use the help-features.") .RegisterHelpFlag("-h", "--help", "--another-help-flag") .Parameter("-n", "--name") .WithDescription("Your name.") .WithExamples("Peter", "Benjamin") .IsRequired() .Parameter <int>("-a", "--age") .WithDescription("Your age.") .WithExamples(23, 56) .WithValidation(a => a >= 0 && a <= 120, a => $"You are probably not {a} years old") .IsRequired() .Parameter <string?>("-e", "--email") .WithDescription("Your email address.") .WithExamples("*****@*****.**", "*****@*****.**") .WithValidation(m => m.Contains('@', StringComparison.InvariantCulture), "Your mail must contain an @-sign!") .IsOptional() .Call(email => age => name => { Console.WriteLine($"Name: {name}"); Console.WriteLine($"Age: {age}"); Console.WriteLine($"EMail: {email}"); }) .Parse(args); }
public static Task Main(string[] args) { return(FluentArgsBuilder.New() .Parameter <int>("-n").IsRequired() .Call(n => MyAsyncApp(n)) .ParseAsync(args)); }
public static Task Main(string[] args) { return FluentArgsBuilder.New() .DefaultConfigsWithAppDescription("An app to convert png files to jpg files.") .Parameter("-i", "--input") .WithDescription("Input png file") .WithExamples("input.png") .IsRequired() .Parameter("-o", "--output") .WithDescription("Output jpg file") .WithExamples("output.jpg") .IsRequired() .Parameter<ushort>("-q", "--quality") .WithDescription("Quality of the conversion") .WithValidation(n => n >= 0 && n <= 100) .IsOptionalWithDefault(50) .Call(quality => outputFile => inputFile => { /* ... */ Console.WriteLine($"Convert {inputFile} to {outputFile} with quality {quality}..."); /* ... */ return Task.CompletedTask; }) .ParseAsync(args); }
public static void Whitespaces_ShouldAlwaysThrow(string name) { Action buildAction = () => FluentArgsBuilder.New() .Flag(name) .Call(_ => { }); buildAction.Should().Throw <Exception>(); }
public static void IncludingTheSameParameterNameMultipleTimesInTheSameDefinition_ShouldAlwaysThrow() { Action buildAction = () => FluentArgsBuilder.New() .Parameter("-x", "-x").IsOptional() .Call(_ => { }); buildAction.Should().Throw <Exception>(); }
public static void Main(string[] args) { var success = FluentArgsBuilder.New() .PositionalArgument <int>().IsRequired() .Call(_ => { }) .Parse(args); Console.WriteLine($"Parse success: {success}"); }
public static void GivenARequiredArgIsMissing_ShouldNotbeParsedSuccessful() { var args = new[] { "--name", "beni" }; var builder = FluentArgsBuilder.New() .Parameter <int>("--age").IsRequired() .Call(age => { }); var parseSuccess = builder.Parse(args); parseSuccess.Should().BeFalse(); }
public static void GivenAnAmbiguousEnumParameter_ParsingShouldNotWork() { var args = new[] { "-m", "naMeB" }; var builder = FluentArgsBuilder.New() .Parameter <MyEnum>("-m").IsRequired() .Call(m => { }); var parseSuccess = builder.Parse(args); parseSuccess.Should().BeFalse(); }
public static void GivenARequiredParameterWithoutAValue_ShouldNotbeParsedSuccessful() { var args = new[] { "--name" }; var builder = FluentArgsBuilder.New() .Parameter("--name").IsRequired() .Call(name => { }); var parseSuccess = builder.Parse(args); parseSuccess.Should().BeFalse(); }
public static void IfTooManyArgumentsAreGiven_ShouldBeParsable() { var args = new[] { "a", "b" }; var called = false; var builder = FluentArgsBuilder.New() .Call(() => called = true); var parseSuccess = builder.Parse(args); parseSuccess.Should().BeTrue(); called.Should().BeTrue(); }
public static void GivenNoArgumentsAndNoParameters_ShouldBeParsable() { var done = false; var args = Array.Empty <string>(); var builder = FluentArgsBuilder.New() .Call(() => done = true); var parseSuccess = builder.Parse(args); parseSuccess.Should().BeTrue(); done.Should().BeTrue(); }
public static void GivenNoArgumentsButParameters_ShouldBeParsable() { var done = false; var args = new[] { "-a", "-b", "--bla" }; var builder = FluentArgsBuilder.New() .Call(() => done = true); var parseSuccess = builder.Parse(args); parseSuccess.Should().BeTrue(); done.Should().BeTrue(); }
public static void GivenNoArguments_UntypedCallsShouldBePossible() { var args = Array.Empty <string>(); IReadOnlyCollection <object?>?parameters = null; var builder = FluentArgsBuilder.New() .CallUntyped(p => parameters = p); var parseSuccess = builder.Parse(args); parseSuccess.Should().BeTrue(); parameters.Should().BeEmpty(); }
public static void Main(string[] args) { FluentArgsBuilder.New() .DefaultConfigs() .Parameter <int>("-b", "--binaryNumber") .WithDescription("A binary number which is greater or equal to 0 and smaller or equal to 100") .WithParser(BinaryNumberParser) .WithValidation(n => n >= 0 && n <= 100) .IsRequired() .Call(n => Console.WriteLine($"Number: {n}")) .Parse(args); }
public static void GivenARequiredListParameterWhichIsNotPresent_ShouldNotParseSuccessful() { var args = new[] { "-x" }; IReadOnlyList <int>?parsedN = default; var builder = FluentArgsBuilder.New() .ListParameter <int>("-n").IsRequired() .Call(n => parsedN = n); var parseSuccess = builder.Parse(args); parseSuccess.Should().BeFalse(); }
public static void Main(string[] args) { FluentArgsBuilder.New() .RegisterParsingErrorPrinter(new SimpleParsingErrorPrinter(Console.Out)) /* or */ .RegisterParsingErrorPrinter(new MyParsingErrorPrinter()) .PositionalArgument <int>().IsRequired() .Call(_ => { }) .Parse(args); }
public static void IfAParameterIsUsedAndRemoved_TheSurroundingElementsShouldNotProduceANewParameter() { var args = new[] { "--a", "--b", "b", "a" }; var builder = FluentArgsBuilder.New() .Parameter("--a").IsRequired() .Parameter("--b").IsRequired() .Call(b => a => { }); var parseSuccess = builder.Parse(args); parseSuccess.Should().BeFalse(); }
public static void GivenAllAssignmentOperatorsAreDisabled_ShouldNotUseThem() { var args = new[] { "-a=1" }; var builder = FluentArgsBuilder.New() .WithoutAssignmentOperators() .Parameter("-a").IsRequired() .Call(_ => { }); var parseSuccess = builder.Parse(args); parseSuccess.Should().BeFalse(); }
public static void NotGivenAFlag_ShouldNotRedirect() { bool?redirected = null; var args = new[] { "--anotherflag" }; var builder = FluentArgsBuilder.New() .Given.Flag("--silent").Then(() => redirected = true) .Call(() => redirected = false); var parseSuccess = builder.Parse(args); parseSuccess.Should().BeTrue(); redirected.Should().BeFalse(); }
public static void GivenNoParametersAreDefined_AllParametersShouldBeRemainingArguments() { var args = new[] { "-x", "a", "-y", "b" }; IReadOnlyList <string>?parsedArgs = default; var builder = FluentArgsBuilder.New() .LoadRemainingArguments() .Call(args => parsedArgs = args); var parseSuccess = builder.Parse(args); parseSuccess.Should().BeTrue(); parsedArgs.Should().BeEquivalentWithSameOrdering(new[] { "-x", "a", "-y", "b" }); }
public static void GivenTwoIdenticalParameterNames_ShouldNotThrow() { var called = false; var builder = FluentArgsBuilder.New() .Parameter("-x").IsOptional() .Parameter("-x").IsOptional() .Call(_ => _ => called = true); var parseSuccess = builder.Parse(); parseSuccess.Should().BeTrue(); called.Should().BeTrue(); }
public static void IfNotConfigured_AnyNonEmptyNameIsValid(string name) { var args = new[] { name }; var called = false; var builder = FluentArgsBuilder.New() .Flag(name) .Call(_ => called = true); var parseSuccess = builder.Parse(args); parseSuccess.Should().BeTrue(); called.Should().BeTrue(); }
public static void GivenACommandWithAnInvalidValue_ShouldNotParseSuccessful() { var args = new[] { "--type", "pi" }; var builder = FluentArgsBuilder.New() .Given.Command("--type") .HasValue("a").Then(() => { }) .ElseIsInvalid() .Call(() => { }); var parseSuccess = builder.Parse(args); parseSuccess.Should().BeFalse(); }
public static void GivenAnAlwaysInvalidCommandValue_ShouldNotParseSuccessful() { var args = new[] { "-c", "beni" }; var builder = FluentArgsBuilder.New() .Given.Command("-c") .Matches(_ => false).Then(() => { }) .ElseIsInvalid() .Call(() => { }); var parseSuccess = builder.Parse(args); parseSuccess.Should().BeFalse(); }