public void Value_Getters_Should_Be_Ordered_Correctly()
{
var settings = new RendererSettingsBuilder()
.BuildSettings();
settings.OrderedValueGetters.Should().BeInAscendingOrder(TypeBySubclassAndAssignableImpl.Default);
}
public void It_Ignores_Tags_It_Cant_Find()
{
const string result = "";
var setingsBuilder = new RendererSettingsBuilder();
setingsBuilder.SetPartialTemplateLoader(new DictionaryLoader(new Dictionary<string, string>()
{
{ "bar", "{{bar}}" }
}));
var settings = setingsBuilder.BuildSettings();
var context = new Context(
new
{
bar = "Bar"
},
settings,
settings.RenderSettings);
var stringRenderer = new StringRender(StreamWriter, settings.RendererPipeline);
var partialTokenRenderer = new PartialTokenRenderer();
partialTokenRenderer.Write(
stringRenderer,
new PartialToken
{
Content = new StringSlice("foo"),
}, context);
StreamWriter.Flush();
MemStream.Position = 0;
var sr = new StreamReader(MemStream);
var myStr = sr.ReadToEnd();
Assert.Equal(result, myStr);
}
public void It_Renders_Inverted_Tags_When_Falsey_Bool()
{
const string result = "I'm false";
var settings = new RendererSettingsBuilder().BuildSettings();
var context = new Context(
new
{
check = false
},
settings,
settings.RenderSettings);
var stringRenderer = new StringRender(StreamWriter, settings.RendererPipeline);
var sectionTokenRenderer = new InvertedSectionTokenRenderer();
sectionTokenRenderer.Write(
stringRenderer,
new InvertedSectionToken
{
SectionName = "check",
Children = new List<MustacheToken>
{
new LiteralToken { Content = new[] { new StringSlice("I'm false") } }
}
},
context);
StreamWriter.Flush();
MemStream.Position = 0;
var sr = new StreamReader(MemStream);
var myStr = sr.ReadToEnd();
Assert.Equal(result, myStr);
}
public void ItShouldCallHelperWhenExistsWithArgumentFromParent()
{
var writer = new StringWriter();
var settings = new RendererSettingsBuilder().BuildSettings();
var renderSettings = new RenderSettings();
var stringRenderer = new StringRender(writer, settings.RendererPipeline);
var helpers = ImmutableDictionary.CreateBuilder <string, HelperRef>();
var helper = new Func <HelperContext, int, int, string>((helperContext, count, count2) =>
{
return($"<{count}-{count2}>");
});
helpers.Add("MyHelper", new HelperRef(helper));
var tagRenderer = new HelperTagRenderer(helpers.ToImmutable());
var token = new HelperToken
{
Name = "MyHelper",
Args = ImmutableArray.Create(new HelperArgument("Count"), new HelperArgument("Count2"))
};
var context = new Context(new { Count = 10 }, settings, renderSettings)
.Push(new { Count2 = 20 });
tagRenderer.Write(stringRenderer, token, context);
var res = writer.ToString();
Assert.Equal("<10-20>", res);
}
public void It_Can_Render_InterpolationTag_Lambda_Tag()
{
const string result = "Bar";
var settings = new RendererSettingsBuilder().BuildSettings();
var context = new Context(
new
{
foo = new Func <string>(() => "{{bar}}"),
bar = "Bar"
},
settings,
settings.RenderSettings);
var stringRenderer = new StringRender(StreamWriter, settings.RendererPipeline);
var interpolationTokenRenderer = new InterpolationTokenRenderer();
interpolationTokenRenderer.Write(
stringRenderer,
new InterpolationToken
{
Content = new StringSlice("foo"),
EscapeResult = true,
}, context);
StreamWriter.Flush();
MemStream.Position = 0;
var sr = new StreamReader(MemStream);
var myStr = sr.ReadToEnd();
Assert.Equal(result, myStr);
}
public void ItShouldApplyTheCultureOfTheRenderer()
{
var writer = new StringWriter();
var settings = new RendererSettingsBuilder().BuildSettings();
var renderSettings = new RenderSettings
{
CultureInfo = new CultureInfo("ru-RU")
};
var stringRenderer = new StringRender(writer, settings.RendererPipeline);
var helpers = ImmutableDictionary.CreateBuilder <string, HelperRef>();
var helper = new Func <HelperContext, decimal>((helperContext) =>
{
return(helperContext.Lookup <decimal>("Count"));
});
helpers.Add("MyHelper", new HelperRef(helper));
var tagRenderer = new HelperTagRenderer(helpers.ToImmutable());
var token = new HelperToken
{
Name = "MyHelper",
Args = ImmutableArray <HelperArgument> .Empty
};
var context = new Context(new { Count = 1.21m }, settings, renderSettings);
tagRenderer.Write(stringRenderer, token, context);
var res = writer.ToString();
Assert.Equal("1,21", res);
}
public void ItShouldHandleNullReturnFromHelper()
{
var writer = new StringWriter();
var settings = new RendererSettingsBuilder().BuildSettings();
var renderSettings = new RenderSettings();
var stringRenderer = new StringRender(writer, settings.RendererPipeline);
var helpers = ImmutableDictionary.CreateBuilder <string, HelperRef>();
var helper = new Func <HelperContext, object>((helperContext) =>
{
return(null);
});
helpers.Add("MyHelper", new HelperRef(helper));
var tagRenderer = new HelperTagRenderer(helpers.ToImmutable());
var token = new HelperToken
{
Name = "MyHelper",
Args = ImmutableArray <HelperArgument> .Empty
};
var context = new Context(new { Count = 1.21m }, settings, renderSettings);
tagRenderer.Write(stringRenderer, token, context);
var res = writer.ToString();
Assert.Equal("", res);
}
public void ItShouldRenderWhenTypesNotMatchCanBeConverted()
{
var writer = new StringWriter();
var settings = new RendererSettingsBuilder().BuildSettings();
var renderSettings = new RenderSettings();
var stringRenderer = new StringRender(writer, settings.RendererPipeline);
var helpers = ImmutableDictionary.CreateBuilder <string, HelperRef>();
var helper = new Func <HelperContext, int, string>((helperContext, count) =>
{
return($"<{count}>");
});
helpers.Add("MyHelper", new HelperRef(helper));
var tagRenderer = new HelperTagRenderer(helpers.ToImmutable());
var token = new HelperToken
{
Name = "MyHelper",
Args = ImmutableArray.Create(new HelperArgument("Count"))
};
var context = new Context(new { Count = "10" }, settings, renderSettings);
tagRenderer.Write(stringRenderer, token, context);
var res = writer.ToString();
Assert.Equal("<10>", res);
}
public void ItShouldRenderAllowHelpersWithNoArguments()
{
var writer = new StringWriter();
var settings = new RendererSettingsBuilder().BuildSettings();
var renderSettings = new RenderSettings();
var stringRenderer = new StringRender(writer, settings.RendererPipeline);
var helpers = ImmutableDictionary.CreateBuilder <string, HelperRef>();
var helper = new Func <HelperContext, string>((helperContext) =>
{
return($"<{helperContext.Lookup<int>("Count")}>");
});
helpers.Add("MyHelper", new HelperRef(helper));
var tagRenderer = new HelperTagRenderer(helpers.ToImmutable());
var token = new HelperToken
{
Name = "MyHelper",
Args = ImmutableArray <HelperArgument> .Empty
};
var context = new Context(new { Count = 10 }, settings, renderSettings);
tagRenderer.Write(stringRenderer, token, context);
var res = writer.ToString();
Assert.Equal("<10>", res);
}
public void It_Can_Render_LiteralTags()
{
StringSlice content = new StringSlice("I'm a literal tag");
var settings = new RendererSettingsBuilder().BuildSettings();
var context = new Context(
new { },
settings,
settings.RenderSettings);
var stringRenderer = new StringRender(StreamWriter, settings.RendererPipeline);
var rawTokenRenderer = new LiteralTokenRenderer();
rawTokenRenderer.Write(
stringRenderer,
new LiteralToken()
{
Content = new[] { content }
}, context);
StreamWriter.Flush();
MemStream.Position = 0;
var sr = new StreamReader(MemStream);
var myStr = sr.ReadToEnd();
Assert.Equal(content.ToString(), myStr);
}
public void ItShouldRenderNothingWhenHelperDoesntExist()
{
var writer = new StringWriter();
var settings = new RendererSettingsBuilder().BuildSettings();
var renderSettings = new RenderSettings();
var stringRenderer = new StringRender(writer, settings.RendererPipeline);
var helpers = ImmutableDictionary.Create <string, HelperRef>();
var tagRenderer = new HelperTagRenderer(helpers);
var token = new HelperToken
{
Name = "MyHelper",
Args = ImmutableArray <HelperArgument> .Empty
};
var context = new Context(new { Count = 10 }, settings, renderSettings);
tagRenderer.Write(stringRenderer, token, context);
var res = writer.ToString();
Assert.Equal("", res);
}
public void It_Can_Render_InterpolationTag_Escaped_SimpleValue()
{
const string result = "A & B";
var settings = new RendererSettingsBuilder().BuildSettings();
var context = new Context(
new { foo = "A & B" },
settings,
settings.RenderSettings);
var stringRenderer = new StringRender(StreamWriter, settings.RendererPipeline);
var interpolationTokenRenderer = new InterpolationTokenRenderer();
interpolationTokenRenderer.Write(
stringRenderer,
new InterpolationToken
{
Content = new StringSlice("foo"),
EscapeResult = true,
}, context);
StreamWriter.Flush();
MemStream.Position = 0;
var sr = new StreamReader(MemStream);
var myStr = sr.ReadToEnd();
Assert.Equal(result, myStr);
}
/// <inheritdoc/>
public StubbleVisitorRenderer Build()
{
var builder = new RendererSettingsBuilder();
ConfigureSettings?.Invoke(builder);
return(new StubbleVisitorRenderer(builder.BuildSettings()));
}
public void It_Can_Render_LambdaTags_WithContext()
{
const string result = "1 Bar";
var settings = new RendererSettingsBuilder().BuildSettings();
var context = new Context(
new
{
lambda = new Func <dynamic, string, object>((dyn, str) => $"1 {dyn.bar}"),
bar = "Bar"
},
settings,
settings.RenderSettings);
var stringRenderer = new StringRender(StreamWriter, settings.RendererPipeline);
var sectionTokenRenderer = new SectionTokenRenderer();
sectionTokenRenderer.Write(
stringRenderer,
new SectionToken
{
SectionName = "lambda",
Children = new List <MustacheToken>
{
}
},
context);
StreamWriter.Flush();
MemStream.Position = 0;
var sr = new StreamReader(MemStream);
var myStr = sr.ReadToEnd();
Assert.Equal(result, myStr);
}
public void It_Can_Use_Truthy_Checks()
{
var builder = new RendererSettingsBuilder();
builder
.AddTruthyCheck <string>((val) =>
{
return(val.Equals("Foo"));
})
.AddTruthyCheck <uint>((val) =>
{
return(val > 0);
});
var context = new Context(
new StronglyTypedChildTestClass()
{
Field = 1,
Property = 1,
ChildField = 2,
ChildProperty = 2
},
builder.BuildSettings(),
RenderSettings.GetDefaultRenderSettings());
Assert.True(context.IsTruthyValue("Foo"));
Assert.True(context.IsTruthyValue((uint)5));
Assert.True(context.IsTruthyValue(true));
}
public void It_Can_Render_LambdaTags_UsingOriginalTemplate()
{
const string result = "<b>a b c Bar d e f</b>";
var settings = new RendererSettingsBuilder().BuildSettings();
var context = new Context(
new
{
lambda = new Func <string, object>(str => $"<b>{str}</b>"),
bar = "Bar"
},
settings,
settings.RenderSettings);
var stringRenderer = new StringRender(StreamWriter, settings.RendererPipeline);
var sectionTokenRenderer = new SectionTokenRenderer();
sectionTokenRenderer.Write(
stringRenderer,
new SectionToken
{
SectionName = "lambda",
SectionContent = new StringSlice("a b c {{bar}} d e f")
},
context);
StreamWriter.Flush();
MemStream.Position = 0;
var sr = new StreamReader(MemStream);
var myStr = sr.ReadToEnd();
Assert.Equal(result, myStr);
}
public MustacheTemplateEngine()
{
var settings = new RendererSettingsBuilder()
//.SetEncodingFunction(s => s) // No HTML encoding of content.
.BuildSettings();
_compiler = new StubbleVisitorRenderer(settings);
}
public static RendererSettingsBuilder AddJsonNet(this RendererSettingsBuilder builder)
{
foreach (var getter in ValueGetters)
{
builder.AddValueGetter(getter.Key, getter.Value);
}
return(builder);
}
public void It_Can_Override_ParserPipeline()
{
var pipeline = new ParserPipelineBuilder().Build();
var settings = new RendererSettingsBuilder()
.SetParserPipeline(pipeline)
.BuildSettings();
Assert.Equal(pipeline, settings.ParserPipeline);
}
public void It_Can_Override_DefaultTags()
{
var tags = new Tags(":|", "|:");
var settings = new RendererSettingsBuilder()
.SetDefaultTags(tags)
.BuildSettings();
Assert.Equal(tags, settings.DefaultTags);
}
public void It_Can_Override_Parser()
{
var parser = new InstanceMustacheParser();
var settings = new RendererSettingsBuilder()
.SetMustacheParser(parser)
.BuildSettings();
Assert.IsType <InstanceMustacheParser>(settings.Parser);
Assert.Equal(parser, settings.Parser);
}
public static RendererSettingsBuilder AddJsonNet(this RendererSettingsBuilder builder)
{
foreach (var getter in ValueGetters)
{
builder.AddValueGetter(getter.Key, getter.Value);
}
builder.AddSectionBlacklistType(typeof(JObject));
return(builder);
}
public void It_Can_Add_To_Section_Blacklist()
{
var settings = new RendererSettingsBuilder()
.AddSectionBlacklistType(typeof(FactAttribute))
.BuildSettings();
Assert.NotEmpty(settings.SectionBlacklistTypes);
Assert.Contains(typeof(FactAttribute), settings.SectionBlacklistTypes);
Assert.Contains(typeof(string), settings.SectionBlacklistTypes);
Assert.Contains(typeof(IDictionary), settings.SectionBlacklistTypes);
}
public void It_Can_Render_IEnumerables_As_Lists()
{
const string result = "1 Bar\n2 Bar\n3 Bar\n4 Bar\n";
var settings = new RendererSettingsBuilder().BuildSettings();
var context = new Context(
new
{
list = new[]
{
new { a = 1 },
new { a = 2 },
new { a = 3 },
new { a = 4 }
},
bar = "Bar"
},
settings,
settings.RenderSettings);
var stringRenderer = new StringRender(StreamWriter, settings.RendererPipeline);
var sectionTokenRenderer = new SectionTokenRenderer();
sectionTokenRenderer.Write(
stringRenderer,
new SectionToken
{
SectionName = "list",
Children = new List <MustacheToken>
{
new InterpolationToken {
Content = new StringSlice("a")
},
new LiteralToken {
Content = new [] { new StringSlice(" ") }
},
new InterpolationToken {
Content = new StringSlice("bar")
},
new LiteralToken {
Content = new [] { new StringSlice("\n") }
},
}
},
context);
StreamWriter.Flush();
MemStream.Position = 0;
var sr = new StreamReader(MemStream);
var myStr = sr.ReadToEnd();
Assert.Equal(result, myStr);
}
public void It_Can_Configure_ParserPipeline()
{
var settings = new RendererSettingsBuilder()
.ConfigureParserPipeline(pipe => pipe
.Remove <InterpolationTagParser>()
.Remove <PartialTagParser>())
.BuildSettings();
Assert.Equal(
new[] { typeof(CommentTagParser), typeof(DelimiterTagParser) },
settings.ParserPipeline.InlineParsers.Select(x => x.GetType()));
}
public void It_Can_Override_Section_Blacklist()
{
var set = new HashSet <Type> {
typeof(FactAttribute)
};
var settings = new RendererSettingsBuilder()
.SetSectionBlacklistTypes(set)
.BuildSettings();
Assert.NotEmpty(settings.SectionBlacklistTypes);
Assert.Equal(typeof(FactAttribute), settings.SectionBlacklistTypes.First());
}
public void It_Should_Be_Able_To_Set_Ignore_Case_On_Key_Lookup()
{
var builder = new StubbleBuilder()
.Configure(b =>
{
b.SetIgnoreCaseOnKeyLookup(true);
});
var settingsBuilder = new RendererSettingsBuilder();
builder.ConfigureSettings(settingsBuilder);
Assert.True(settingsBuilder.IgnoreCaseOnKeyLookup);
}
public void It_Can_Add_Add_Value_Getters()
{
var builder = new StubbleBuilder()
.Configure(b =>
{
b.AddValueGetter(typeof(string), (o, s, i) => null);
});
var settingsBuilder = new RendererSettingsBuilder();
builder.ConfigureSettings(settingsBuilder);
Assert.Contains(typeof(string), settingsBuilder.ValueGetters.Keys);
Assert.Null(settingsBuilder.ValueGetters[typeof(string)](null, null, false));
}
public void It_Can_Add_Enumeration_Converters()
{
var builder = new StubbleBuilder()
.Configure(b =>
{
b.AddEnumerationConversion(typeof(NameValueCollection), (obj) => null);
});
var settingsBuilder = new RendererSettingsBuilder();
builder.ConfigureSettings(settingsBuilder);
Assert.Contains(typeof(NameValueCollection), settingsBuilder.EnumerationConverters.Keys);
Assert.Null(settingsBuilder.EnumerationConverters[typeof(NameValueCollection)](null));
}
public void It_Can_Set_A_Partial_Template_Loader()
{
var builder = new StubbleBuilder()
.Configure(b =>
{
b.SetPartialTemplateLoader(new DictionaryLoader(new Dictionary <string, string> {
{ "test", "{{foo}}" }
}));
});
var settingsBuilder = new RendererSettingsBuilder();
builder.ConfigureSettings(settingsBuilder);
Assert.NotNull(settingsBuilder.PartialTemplateLoader);
Assert.True(settingsBuilder.PartialTemplateLoader is DictionaryLoader);
}