public void Work_With_Letters()
{
// arrange
var builder = DefaultBuilder.CreateDefaultBuilder();
var root = builder.Context.ParserRepository.Get("util");
string value = null;
var sut = new SeparatedSwitch(root, 'v', "value", (o, s) => { value = s; })
{
Separator = ":"
};
var info = new IterationInfo("-v:a".Split(' '));
// act
// assert
var canConsumeResult = sut.CanConsume("", info);
canConsumeResult.ConsumingParameter.Should().BeSameAs(sut);
canConsumeResult.NumConsumed.Should().Be(1);
canConsumeResult.ParseExceptions.Should().BeEmpty();
canConsumeResult.Info.Index.Should().Be(1);
var consumeResult = sut.Consume("", new ConsumptionRequest(info));
consumeResult.ConsumingParameter.Should().BeSameAs(sut);
consumeResult.NumConsumed.Should().Be(1);
consumeResult.ParseExceptions.Should().BeEmpty();
consumeResult.Info.Index.Should().Be(1);
}
public void Allow_Auto_Help_To_Be_Registered()
{
// arrange
var mockRenderer = new Mock <ITemplateRenderer>();
mockRenderer.SetupAllProperties();
var isHelpRequested = false;
var builder = DefaultBuilder.CreateDefaultBuilder()
.RegisterExtensions()
.AddAutoHelp((results, exceptions) =>
{
isHelpRequested = true;
var first = results.Keys.OfType <UtilOptions>().FirstOrDefault();
if (first != null && first.IsHelpRequested)
{
return(results[first].Id);
}
return(null);
}, factory =>
{
factory.TemplateRenderer = mockRenderer.Object;
return(factory);
});
// act
builder.Parse("-h".Split(' '));
// assert
isHelpRequested.Should().BeTrue();
}
public void Not_Throw_If_An_Unexpected_Argument_Is_Found()
{
// arrange
var builder = DefaultBuilder.CreateDefaultBuilder();
var strat = new ParseStrategy(builder.Context);
var mock = new Mock <IPotentialConsumerStrategy>();
mock.SetupAllProperties();
mock.Setup(s => s.IdentifyPotentialConsumer(It.IsAny <PotentialConsumerRequest>())).Returns(
new PotentialConsumerResult(builder.Context.PathToRoot("util"), new ConsumptionResult[0],
new IterationInfo("-h".Split(' '))));
strat.PotentialConsumerStrategy = mock.Object;
IParseResult res = null;
Action mightThrow = () => res = strat.Parse("-h".Split(' '));
// act
// assert
mightThrow.Should().NotThrow();
var isParsed = false;
res.WhenError(exceptions =>
{
exceptions.Single().Should().BeOfType <UnexpectedArgException>();
isParsed = true;
});
isParsed.Should().BeTrue();
}
public void Return_The_Children_Of_The_Requested_Node()
{
// arrange
var builder = DefaultBuilder.CreateDefaultBuilder();
// act
// assert
builder.Context.HierarchyRepository.GetChildren("util").Should()
.Contain("clipboard convert firewall".Split(' '));
}
public void Not_Throw_If_Asking_For_An_Unregistered_Context()
{
// arrange
var builder = DefaultBuilder.CreateDefaultBuilder();
Action mightThrow0 = () => builder.Context.ToExtensionContext();
// act
// assert
mightThrow0.Should().NotThrow();
}
public void Allow_Themes_To_Be_Set_After_They_Have_Been_Created()
{
// arrange
var builder = DefaultBuilder.CreateDefaultBuilder()
.SetTheme("util", Theme.Cool)
.SetTheme("util", Theme.Warm);
// act
// assert
ContextBuilderExtensions.ParserThemes[builder.Context.ParserRepository.Get("util")].Should().Be(Theme.Warm);
}
public void Only_Group_If_The_Entire_Arg_Matches_And_Not_When_A_Subtring_Matches()
{
// arrange
var builder = DefaultBuilder.CreateDefaultBuilder();
var request = new MutateArgsRequest("--help".Split(' '), builder.Context.ParserRepository.Get("util").ToEnumerableOfOne(), builder.Context);
var mutator = new ArgsMutator(builder.Context);
// act
// assert
mutator.Mutate(request).Should().BeEquivalentTo("--help".ToEnumerableOfOne(), "Although the arg contains -h, it is not the entire arg and thus does not match");
}
public void Create_A_Theme_Repository_With_All_Added_Themes()
{
// arrange
var builder = DefaultBuilder.CreateDefaultBuilder();
builder.SetTheme("util", Theme.Cool);
// act
var res = builder.Context.ToExtensionContext();
// assert
res.ThemeRepository.Get("util").Should().BeSameAs(Theme.Cool);
}
public void Not_Do_Anything_For_Positionals()
{
// arrange
var builder = DefaultBuilder.CreateDefaultBuilder();
builder.SetSwitchTokens("#", "##");
// act
builder.AddParser("whatever").WithPositional((o, s) => { });
// assert
builder.Context.ParserRepository.Get("whatever").Should().NotBeNull();
}
public void Consume_Everything_After_The_Separator_As_A_Single_Value0()
{
// arrange
var builder = DefaultBuilder.CreateDefaultBuilder();
var root = builder.Context.ParserRepository.Get("util");
string value = null;
var sut = new SeparatedSwitch(root, 'v', "value", (o, s) => { value = s; });
// act
var info = new IterationInfo("-v=a".Split(' '));
var res = sut.Consume("", new ConsumptionRequest(info));
// assert
res.ConsumingParameter.Should().BeSameAs(sut);
value.Should().Be("a");
}
public void Only_Consume_Until_The_Mutated_Args_No_Longer_Match()
{
// arrange
var builder = DefaultBuilder.CreateDefaultBuilder();
var fac = new IterationInfoFactory(builder.Context);
var parsers = builder.Context.PathToRoot("firewall").Reverse();
var res = new ChainIdentificationResult(parsers, new[] { "firewall" });
var req = new IterationInfoRequest(res, "firewall -s -l".Split(' '), "firewall -h -h -h".Split(' '));
// act
var result = fac.Create(req);
// assert
result.Args.Should().BeEquivalentTo("firewall -s -l".Split(' '));
result.Index.Should().Be(1);
}
public void Recognize_Parser_Chains()
{
// arrange
var builder = DefaultBuilder.CreateDefaultBuilder();
var fac = new IterationInfoFactory(builder.Context);
var parsers = builder.Context.PathToRoot("firewall").Reverse();
var res = new ChainIdentificationResult(parsers, new [] { "firewall" });
var req = new IterationInfoRequest(res, "firewall -h".Split(' '), "firewall -h -h -h".Split(' '));
// act
var result = fac.Create(req);
// assert
result.Args.Should().BeEquivalentTo("firewall -h".Split(' '));
result.Index.Should().Be(1);
}
public void Make_The_Index_Reflect_The_Intersection_Of_The_Original_And_Mutated_Args()
{
// arrange
var builder = DefaultBuilder.CreateDefaultBuilder();
var fac = new IterationInfoFactory(builder.Context);
var parsers = builder.Context.ParserRepository.Get("util").ToEnumerableOfOne();
var res = new ChainIdentificationResult(parsers, new string[0]);
var req = new IterationInfoRequest(res, "-h".Split(' '), "-h -h -h".Split(' '));
// act
var result = fac.Create(req);
// assert
result.Args.Should().BeEquivalentTo("-h".Split(' '));
result.Index.Should().Be(0);
}
public void Correctly_Parse_A_Single_Help_Request()
{
// arrange
var parseCount = 0;
var builder = DefaultBuilder.CreateDefaultBuilder();
// act
var result = builder.Parse("-h".Split(' '));
// assert
result.When <UtilOptions>((options, parser) =>
{
options.IsHelpRequested.Should().BeTrue();
parseCount++;
});
parseCount.Should().Be(1);
}
public void Return_The_Same_Extension_Context_When_Asked_Multiple_Times()
{
// arrange
var builder = DefaultBuilder.CreateDefaultBuilder()
.RegisterExtensions();
// act
// assert
var set = new HashSet <ExtensionContext>();
for (var i = 0; i < 10; i++)
{
set.Add(builder.Context.ToExtensionContext());
}
set.Should().HaveCount(1);
}
public void Defer_To_The_Inner_Factory_For_Creation()
{
// arrange
var builder = DefaultBuilder.CreateDefaultBuilder();
var mock = new Mock <IParseResultFactory>();
mock.SetupAllProperties();
mock.Setup(f => f.Create(It.IsAny <Dictionary <object, Parser> >(), It.IsAny <IEnumerable <ParseException> >()))
.Returns(new ParseResult(null, null));
var fac = new HelpRequestedParseResultFactory(mock.Object, (parsers, exceptions) => null, builder.Context);
// act
fac.Create(null, null);
// assert
mock.Verify(f => f.Create(It.IsAny <Dictionary <object, Parser> >(), It.IsAny <IEnumerable <ParseException> >()),
Times.Once);
}
public void Return_Any_Errors_That_Occurred_During_Processing()
{
// arrange
var builder = DefaultBuilder.CreateDefaultBuilder();
// act
var res = builder.Parse("firewall -p -h".Split(' '));
// assert
var isParsed = false;
res.WhenError(exceptions =>
{
exceptions.Should().HaveCount(1);
isParsed = true;
});
isParsed.Should().BeTrue();
}
public void Throw_If_Cannot_Find_Parser()
{
// arrange
var builder = DefaultBuilder.CreateDefaultBuilder();
var strat = new ConsumerSelectionStrategy(builder.Context);
var info = new IterationInfo("firewall -h".Split(' '));
var parameter = new BooleanSwitch(new Parser("fake"), 'h', "help", o => { });
var result = new PotentialConsumerResult(builder.Context.PathToRoot("firewall").Reverse().ToList(),
new[]
{
new ConsumptionResult(info, 0, parameter)
}, info);
Action mightThrow = () => strat.Select(result);
// act
// assert
mightThrow.Should().Throw <ForwardProgressException>();
}
public void Create_A_Document()
{
// arrange
var builder = DefaultBuilder.CreateDefaultBuilder()
.RegisterExtensions();
var parser = builder.Context.ParserRepository.Get("util");
var parserVm = new ParserViewModel(parser, Theme.Default);
var template = new ParserHelpTemplate(builder.Context, "util")
{
ViewModel = new ParserHelpTemplateViewModel(parserVm.ToEnumerableOfOne().ToList(),
new List <ParameterViewModel>(), new List <ParserViewModel>())
};
// act
var doc = template.Create();
// assert
doc.Should().NotBeNull();
}
public void Return_No_Consumption_Result_If_Doesnt_Match()
{
// arrange
var builder = DefaultBuilder.CreateDefaultBuilder();
var root = builder.Context.ParserRepository.Get("util");
string value = null;
var sut = new SeparatedSwitch(root, 'v', "value", (o, s) => { value = s; })
{
Separator = ":"
};
var info = new IterationInfo("-x:a".Split(' '));
// act
// assert
var res = sut.CanConsume("", info);
res.ConsumingParameter.Should().Be(sut);
res.NumConsumed.Should().Be(0);
res.ParseExceptions.Should().BeEmpty();
}
public void Generate_The_Correct_Prefix_For_BooleanSwitches()
{
// arrange
var mock = new Mock <IInlineSequence>();
mock.SetupAllProperties();
var builder = DefaultBuilder.CreateDefaultBuilder();
var parameter = new BooleanSwitch(builder.Context.ParserRepository.Get("util"), 'v', "value", o => { });
parameter.Help.ValueAlias = "val";
var vm = new ParameterViewModel(parameter, Theme.Default);
var usage = new ParameterUsage
{
ViewModel = vm
};
// act
// assert
usage.GenerateValueAlias(parameter).Should().Be("");
}
public void Set_Sub_Component_Contexts_When_The_Context_Changes()
{
// arrange
var builder = DefaultBuilder.CreateDefaultBuilder();
var strat = new ParseStrategy(builder.Context);
var newGuy = new Context();
// act
strat.Context = newGuy;
// assert
strat.Context.Should().BeSameAs(newGuy);
strat.ArgsMutator.Context.Should().BeSameAs(newGuy);
strat.ChainIdentificationStrategy.Context.Should().BeSameAs(newGuy);
strat.ConsumerSelectionStrategy.Context.Should().BeSameAs(newGuy);
strat.ConsumptionRequestFactory.Context.Should().BeSameAs(newGuy);
strat.IterationInfoFactory.Context.Should().BeSameAs(newGuy);
strat.ParseResultFactory.Context.Should().BeSameAs(newGuy);
strat.PotentialConsumerStrategy.Context.Should().BeSameAs(newGuy);
}
public void Render_Convert_Help()
{
// arrange
var builder = DefaultBuilder.CreateDefaultBuilder();
var sut = new ParserHelpTemplate(builder.Context, "convert");
// act
var doc = sut.Create();
var text = ConsoleRenderer.RenderDocumentToText(doc, new TextRenderTarget(),
new Rect(0, 0, 80, Size.Infinity));
// assert
text.Should().Be(@" __
_______ ___ _ _____ ____/ /_
/ __/ _ \/ _ \ |/ / -_) __/ __/
\__/\___/_//_/___/\__/_/ \__/
convert - Convert files to another format
────────────────────────────────────────────────────────────────────────────────
util convert [-h, --help][--version][-f, --format:png][file1..fileN]
┌───────────┬──────────────────────────────────────────────────────────────────┐
│Sub Command│Description │
└───────────┴──────────────────────────────────────────────────────────────────┘
┌──────────────────┬───┬───────┬───────────────────────────────────────────────┐
│Parameter │Req│Default│Description │
├──────────────────┼───┼───────┼───────────────────────────────────────────────┤
│[-h, --help] │ │false │Get help on commands │
├──────────────────┼───┼───────┼───────────────────────────────────────────────┤
│[--version] │ │false │Display the current version │
├──────────────────┼───┼───────┼───────────────────────────────────────────────┤
│[-f, --format:png]│ ✓ │ │What format to conver the files to │
├──────────────────┼───┼───────┼───────────────────────────────────────────────┤
│[file1..fileN] │ ✓ │ │Input files to convert │
└──────────────────┴───┴───────┴───────────────────────────────────────────────┘
Examples:
Image files - Convert some images to png
util convert -f png file0.jpg file1.gif
Converted (2) files to .png
");
}
public void Generate_The_Correct_Output_For_A_Single_Value_Switch()
{
// arrange
var mock = new Mock <IInlineSequence>();
mock.SetupAllProperties();
var builder = DefaultBuilder.CreateDefaultBuilder();
var parameter = new SingleValueSwitch(builder.Context.ParserRepository.Get("util"), 'v', "value",
(o, s) => { });
var vm = new ParameterViewModel(parameter, Theme.Default);
var usage = new ParameterUsage
{
ViewModel = vm
};
// act
usage.GenerateSequence(mock.Object);
// assert
usage.StringBuilder.ToString().Should().Be("[-v, --value v]");
}
public void Render_Util_Help()
{
// arrange
var builder = DefaultBuilder.CreateDefaultBuilder();
var sut = new ParserHelpTemplate(builder.Context, "util");
// act
var doc = sut.Create();
var text = ConsoleRenderer.RenderDocumentToText(doc, new TextRenderTarget(),
new Rect(0, 0, 80, Size.Infinity));
// assert
text.Should().Be(@" __ _ __
__ __/ /_(_) /
/ // / __/ / /
\_,_/\__/_/_/
util - 1.0.0.0 - General utility tool
────────────────────────────────────────────────────────────────────────────────
util [-h, --help][--version]
┌───────────┬──────────────────────────────────────────────────────────────────┐
│Sub Command│Description │
├───────────┼──────────────────────────────────────────────────────────────────┤
│clip │Interact with the clipboard │
├───────────┼──────────────────────────────────────────────────────────────────┤
│firewall │Interact with the the local firewall │
├───────────┼──────────────────────────────────────────────────────────────────┤
│convert │Convert files to another format │
└───────────┴──────────────────────────────────────────────────────────────────┘
┌────────────┬───┬───────┬─────────────────────────────────────────────────────┐
│Parameter │Req│Default│Description │
├────────────┼───┼───────┼─────────────────────────────────────────────────────┤
│[-h, --help]│ │false │Get help on commands │
├────────────┼───┼───────┼─────────────────────────────────────────────────────┤
│[--version] │ │false │Display the current version │
└────────────┴───┴───────┴─────────────────────────────────────────────────────┘
Examples:
");
}
public void Generate_The_Correct_Prefix_For_Positionals()
{
// arrange
var mock = new Mock <IInlineSequence>();
mock.SetupAllProperties();
var builder = DefaultBuilder.CreateDefaultBuilder();
var parameter = new Positional(builder.Context.ParserRepository.Get("util"), (o, strings) => { }, 1, 1);
parameter.Help.ValueAlias = "val";
var vm = new ParameterViewModel(parameter, Theme.Default);
var usage = new ParameterUsage
{
ViewModel = vm
};
// act
usage.GenerateSequence(mock.Object);
// assert
usage.StringBuilder.ToString().Should().Be("[val]");
}
public void Allow_The_Letter_And_Word_Token_To_Be_Changed()
{
// arrange
var builder = DefaultBuilder.CreateDefaultBuilder()
.RegisterExtensions()
.SetSwitchTokens("#", "#~#");
// act
bool isParsed = false;
builder
.Parse("#h #~#version".Split(' '))
.When <UtilOptions>((options, parser) =>
{
isParsed = true;
options.IsHelpRequested.Should().BeTrue();
options.IsVersionRequested.Should().BeTrue();
});
// assert
isParsed.Should().BeTrue();
}
public void Generate_The_Correct_Prefix_For_Switches()
{
// arrange
var mock = new Mock <IInlineSequence>();
mock.SetupAllProperties();
var builder = DefaultBuilder.CreateDefaultBuilder();
var parameter = new ValuesSwitch(builder.Context.ParserRepository.Get("util"), 'v', "value",
(o, strings) => { }, 1, 3);
parameter.Help.ValueAlias = "val";
var vm = new ParameterViewModel(parameter, Theme.Default);
var usage = new ParameterUsage
{
ViewModel = vm
};
// act
usage.GenerateSequence(mock.Object);
// assert
usage.GeneratedText.Should().Be("[-v, --value val1..val3]");
}
public void Generate_The_Correct_Output_For_A_Separated_Switch_With_No_Word()
{
// arrange
var mock = new Mock <IInlineSequence>();
mock.SetupAllProperties();
var builder = DefaultBuilder.CreateDefaultBuilder();
var parameter = new SeparatedSwitch(builder.Context.ParserRepository.Get("util"), 'v', null,
(o, s) => { });
parameter.Help.ValueAlias = "val";
var vm = new ParameterViewModel(parameter, Theme.Default);
var usage = new ParameterUsage
{
ViewModel = vm
};
// act
usage.GenerateSequence(mock.Object);
// assert
usage.StringBuilder.ToString().Should().Be("[-v:val]");
}
private static void Main(string[] args)
{
Console.WriteLine("Enter commands for the fake tool `util` e.g. firewall -h");
while (true)
{
var builder = DefaultBuilder.CreateDefaultBuilder()
.RegisterExtensions()
.AddAutoHelp((parseResults, exceptions) =>
{
foreach (var kvp in parseResults)
{
if (kvp.Key is UtilOptions casted && casted.IsHelpRequested)
{
return(kvp.Value.Id);
}
}
var missingValues = exceptions.OfType <MissingValueException>();
var first = missingValues.FirstOrDefault();
return(first?.Parser.Id);
})
.SetTheme("util",
Theme.Create(FiggleFonts.Doom, ConsoleColor.Green, ConsoleColor.DarkGreen, ConsoleColor.Yellow, ConsoleColor.Red,
ConsoleColor.Yellow))
.SetTheme("clipboard",
Theme.Create(FiggleFonts.Alpha, ConsoleColor.Yellow, ConsoleColor.DarkYellow, ConsoleColor.Gray, ConsoleColor.Red,
ConsoleColor.Gray))
.SetTheme("sort",
Theme.Create(FiggleFonts.Banner3D, ConsoleColor.Cyan, ConsoleColor.DarkCyan, ConsoleColor.Green, ConsoleColor.Red,
ConsoleColor.Green))
.SetTheme("zip",
Theme.Create(FiggleFonts.Banner3D, ConsoleColor.Blue, ConsoleColor.DarkBlue, ConsoleColor.Cyan, ConsoleColor.Red,
ConsoleColor.Cyan))
.SetTheme("convert",
Theme.Create(FiggleFonts.Banner3D, ConsoleColor.Red, ConsoleColor.DarkRed, ConsoleColor.Magenta, ConsoleColor.Red,
ConsoleColor.Magenta))
.SetTheme("firewall",
Theme.Create(FiggleFonts.FireFontK, ConsoleColor.Red, ConsoleColor.White, ConsoleColor.Yellow, ConsoleColor.DarkRed,
ConsoleColor.DarkYellow))
.SetTheme("block",
Theme.Create(FiggleFonts.Banner3D, ConsoleColor.Green, ConsoleColor.DarkBlue, ConsoleColor.Yellow, ConsoleColor.Red,
ConsoleColor.Yellow))
.SetTheme("unblock",
Theme.Create(FiggleFonts.Ghost, ConsoleColor.White, ConsoleColor.Cyan, ConsoleColor.DarkCyan, ConsoleColor.Red,
ConsoleColor.DarkCyan));
Console.Write($"$ util ");
var line = Console.ReadLine();
if (line.IsNullOrWhiteSpace())
{
continue;
}
args = CommandLineToArgs(line).Where(x => !x.IsNullOrWhiteSpace()).ToArray();
if (args.Length == 0)
{
continue;
}
var result = builder.Parse(args);
result.When <UtilOptions>((options, parser) =>
{
Console.WriteLine(options.GetType().FullName);
Console.WriteLine(JsonConvert.SerializeObject(options, Formatting.Indented));
});
result.WhenError(exceptions =>
{
exceptions = exceptions.ToList();
Console.Error.WriteLine("Error");
foreach (var ex in exceptions)
{
Console.Error.WriteLineAsync($"Parse Error: {ex.Message}");
}
});
}
}
