public void It_Doesnt_Error_When_Partial_Is_Used_But_None_Are_Given()
{
var stubble = new StubbleVisitorRenderer();
var output = stubble.Render("{{> inner}}", new { Foo = "Bar" });
Assert.Equal("", output);
}
public async Task It_Can_Render_With_LambdaToken_Interpolation_NoDynamic_Async()
{
var stubble = new StubbleVisitorRenderer();
var output = await stubble.RenderAsync("{{Foo}}", new { Foo = new Func <object>(() => "{{Bar}}"), Bar = "FooBar" });
Assert.Equal("FooBar", output);
}
public void It_Can_Render_With_LambdaToken_NoDynamic()
{
var stubble = new StubbleVisitorRenderer();
var output = stubble.Render("{{Foo}}", new { Foo = new Func <object>(() => "Bar") });
Assert.Equal("Bar", output);
}
public void SetupBenchmark()
{
var loader = new DictionaryLoader(new Dictionary <string, string>()
{
{ "tweet", TweetMustache },
{ "entities", EntitiesMustache },
{ "timeline", TimelineMustache },
});
Tweet = JsonConvert.DeserializeObject <Tweet>(TweetJson);
Timeline = new Timeline {
tweets = Enumerable.Range(0, 20).Select(i => Tweet).ToList()
};
StubbleVisitorRenderer = new StubbleBuilder()
.SetBuilderType <StubbleVisitorBuilder>()
.SetTemplateLoader(loader)
.SetPartialTemplateLoader(loader)
.Build();
TweetTemplate = new Template();
TweetTemplate.Load(new StringReader(TweetMustache));
EntitiesTemplate = new Template();
EntitiesTemplate.Load(new StringReader(EntitiesMustache));
}
public void It_Can_Render_WithoutData()
{
var stubble = new StubbleVisitorRenderer();
var output = stubble.Render("I Have No Data :(", null);
Assert.Equal("I Have No Data :(", output);
}
public void It_Can_Render_With_LambdaSection_NoDynamic()
{
var stubble = new StubbleVisitorRenderer();
var output = stubble.Render("{{#Foo}}Foo{{/Foo}}", new { Foo = new Func <string, object>((str) => str + " Bar") });
Assert.Equal("Foo Bar", output);
}
public void It_Can_Render_With_LambdaToken_Dynamic()
{
var stubble = new StubbleVisitorRenderer();
var output = stubble.Render("{{Foo}}", new { BarValue = "Bar", Foo = new Func <dynamic, object>((context) => context.BarValue) });
Assert.Equal("Bar", output);
}
public StubleRenderer()
{
_stubble = new StubbleBuilder().Configure(opts =>
{
opts.SetIgnoreCaseOnKeyLookup(true);
}).Build();
}
public void It_Can_Render_WithoutPartials()
{
var stubble = new StubbleVisitorRenderer();
var output = stubble.Render("{{Foo}}", new { Foo = "Bar" });
Assert.Equal("Bar", output);
}
private static async Task Main(string[] args)
{
var stopwatch = new Stopwatch();
stopwatch.Start();
await using var dictionaryStream = File.OpenRead(@"English (American).dic");
await using var affixStream = File.OpenRead(@"English (American).aff");
_dictionary = await WordList.CreateFromStreamsAsync(dictionaryStream, affixStream);
_schema = await GetPlotlySchemaAsync();
_stubble = new StubbleBuilder().Configure(settings =>
{
settings.SetIgnoreCaseOnKeyLookup(true);
settings.SetEncodingFunction(s => s);
})
.Build();
Parallel.Invoke(CreateAnimation, CreateTransforms, CreateFrames, CreateLayout, CreateConfig, CreateTraces);
foreach (var(key, value) in Jobs)
{
Console.WriteLine($"Generating {key}.cs");
await value.Execute(_stubble);
}
await File.WriteAllLinesAsync("UnknownWords.txt", Helper.UnknownWords.Distinct());
stopwatch.Stop();
Console.WriteLine($"[PERFORMANCE] Generation took {stopwatch.ElapsedMilliseconds/1000.0}s");
}
public async Task It_Can_Render_Enumerators_Async()
{
var stubble = new StubbleVisitorRenderer();
var output = await stubble.RenderAsync("{{#Items}}{{.}}{{/Items}}", new { Items = "abcdefg".ToCharArray().GetEnumerator() });
Assert.Equal("abcdefg", output);
}
public async Task It_Can_Render_With_SectionLambda_WithContext_Async()
{
var stubble = new StubbleVisitorRenderer();
var output = await stubble.RenderAsync("{{#Foo}}{{/Foo}}", new { Foo = new Func <dynamic, string, object>((ctx, str) => ctx.Bar), Bar = "FooBar" });
Assert.Equal("FooBar", output);
}
public EmailService(IBaseRepository <EmailEntity> mailRepository, IEmailSender emailSender, ILogger <EmailService> logger)
{
_mailRepository = mailRepository;
_emailSender = emailSender;
_logger = logger;
_stubble = new StubbleBuilder().Build();
}
public MustacheTemplateEngine()
{
var settings = new RendererSettingsBuilder()
//.SetEncodingFunction(s => s) // No HTML encoding of content.
.BuildSettings();
_compiler = new StubbleVisitorRenderer(settings);
}
public void It_Can_Render_WithPartials()
{
var stubble = new StubbleVisitorRenderer();
var output = stubble.Render("{{> inner}}", new { Foo = "Bar" }, new Dictionary <string, string> {
{ "inner", "{{Foo}}" }
});
Assert.Equal("Bar", output);
}
public string FillInputPy(StubbleVisitorRenderer renderer, string v, Dictionary <string, string> dictionary)
{
return(renderer.Render(v, dictionary, new RenderSettings
{
SkipHtmlEncoding = true,
SkipRecursiveLookup = false,
ThrowOnDataMiss = true
}));
}
public async Task StringRendererSpecTest_Async(SpecTest data)
{
OutputStream.WriteLine(data.Name);
var stubble = new StubbleVisitorRenderer();
var output = await(data.Partials != null ? stubble.RenderAsync(data.Template, data.Data, data.Partials) : stubble.RenderAsync(data.Template, data.Data));
OutputStream.WriteLine("Expected \"{0}\", Actual \"{1}\"", data.Expected, output);
Assert.Equal(data.Expected, output);
}
public void It_Can_Pass_Spec_Tests(SpecTest data)
{
OutputStream.WriteLine(data.name);
var stubble = new StubbleVisitorRenderer();
var output = data.partials != null?stubble.Render(data.template, data.data, data.partials) : stubble.Render(data.template, data.data);
OutputStream.WriteLine("Expected \"{0}\", Actual \"{1}\"", data.expected, output);
Assert.Equal(data.expected, output);
}
public MustacheTemplateService(ILogger <MustacheTemplateService> logger)
{
_stubble = new StubbleBuilder()
.Configure(settings => settings.AddJsonNet())
.Build();
_logger = logger;
_templatePath = Path.Join(AppDomain.CurrentDomain.BaseDirectory, "templates", "Mustache");
_mustacheConfig = new MustacheConfig(_logger, _templatePath);
}
public void It_Should_Error_After_N_Recursions()
{
const string rowTemplate = @"
<div class='row'>
{{#content}}
{{#is_column}}
{{>column}}
{{/is_column}}
{{/content}}
</div>";
const string columnTemplate = @"
<div class='column'>
{{#content}}
{{#is_text}}
{{>text}}
{{/is_text}}
{{#is_row}}
{{>row}}
{{/is_row}}
{{/content}}
</div>";
const string textTemplate = @"
<span class='text'>
{{text}}
</span>";
var treeData = new
{
is_row = true,
content = new
{
is_column = true,
content = new[]
{
new
{
is_text = true,
text = "Hello World!"
}
}
}
};
var stubble = new StubbleVisitorRenderer();
var ex =
Assert.Throws <StubbleException>(() => stubble.Render(rowTemplate, treeData, new Dictionary <string, string>
{
{ "row", rowTemplate },
{ "column", columnTemplate },
{ "text", textTemplate }
}));
Assert.Equal("You have reached the maximum recursion limit of 256.", ex.Message);
}
/* ----------------------------------------------------------------- *
* constructors *
* ----------------------------------------------------------------- */
/// <summary>
/// Initializes a new instance of the <see cref="StubbleProjectGenerator"/> class.
/// </summary>
/// <param name="projectTemplateRegistry">Injected template registry.</param>
/// <param name="logger">Injected logger.</param>
public StubbleProjectGenerator(
IProjectTemplateRegistry projectTemplateRegistry,
ILogger<StubbleProjectGenerator> logger)
: base(logger)
{
_projectTemplateRegistry = projectTemplateRegistry;
_renderer = new StubbleBuilder()
.Configure(settings => { settings.SetIgnoreCaseOnKeyLookup(true); })
.Build();
}
public MustacheTemplateService(ILogger <MustacheTemplateService> logger)
{
_stubble = new StubbleBuilder()
.Configure(settings => settings.AddJsonNet())
.Build();
_logger = logger;
_templatePath = AppDomain.CurrentDomain.BaseDirectory + "templates" + Path.DirectorySeparatorChar +
"Mustache";
_mustacheConfig = new MustacheConfig();
}
public void It_Can_Render_With_LambdaSection_Dynamic()
{
var stubble = new StubbleVisitorRenderer();
var output = stubble.Render("{{#Foo}}Foo{{/Foo}}", new
{
BarValue = "Bar",
Foo = new Func <dynamic, string, object>((context, str) => str + " " + context.BarValue)
});
Assert.Equal("Foo Bar", output);
}
private static void SubstituteName(FileSystemInfo info, StubbleVisitorRenderer stubble, Dictionary <string, string> variables)
{
var substitutedPath = stubble.Render(info.FullName, variables);
if (substitutedPath.Equals(info.FullName))
{
return;
}
(info as DirectoryInfo)?.MoveTo(substitutedPath);
(info as FileInfo)?.MoveTo(substitutedPath);
}
public async Task StringRendererSpecTest_Async(SpecTest data)
{
var settings = RenderSettings.GetDefaultRenderSettings();
settings.CultureInfo = data.CultureInfo ?? settings.CultureInfo;
OutputStream.WriteLine(data.Name);
var stubble = new StubbleVisitorRenderer();
var output = await(data.Partials != null ? stubble.RenderAsync(data.Template, data.Data, data.Partials, settings) : stubble.RenderAsync(data.Template, data.Data, settings));
OutputStream.WriteLine("Expected \"{0}\", Actual \"{1}\"", data.Expected, output);
Assert.Equal(data.Expected, output);
}
/// <summary>
/// Default constructor.
/// </summary>
/// <param name="logger">
/// The logger.
/// </param>
/// <param name="elementDataFactory">
/// The element data factory.
/// </param>
/// <param name="endpoint">
/// Set the endpoint which will be queried on the host. e.g /api/v4/json
/// </param>
/// <param name="objectName">
/// The default name of the object instantiated by the client
/// JavaScript.
/// </param>
/// <param name="enableCookies">
/// Set whether the client JavaScript stored results of client side
/// processing in cookies.
/// </param>
/// <param name="minify">
/// If true, the resulting JavaScript will be minified
/// </param>
/// <param name="host">
/// The host that the client JavaScript should query for updates.
/// If null or blank then the host from the request will be used
/// </param>
/// <param name="protocol">
/// The protocol (HTTP or HTTPS) that the client JavaScript will use when
/// querying for updates.
/// If null or blank then the protocol from the request will be used
/// </param>
public JavaScriptBuilderElement(
ILogger <JavaScriptBuilderElement> logger,
Func <IPipeline,
FlowElementBase <IJavaScriptBuilderElementData, IElementPropertyMetaData>,
IJavaScriptBuilderElementData> elementDataFactory,
string endpoint,
string objectName,
bool enableCookies,
bool minify,
string host = null,
string protocol = null)
: base(logger, elementDataFactory)
{
// Set the evidence key filter for the flow data to use.
_evidenceKeyFilter = new EvidenceKeyFilterWhitelist(
new List <string>()
{
Constants.EVIDENCE_HOST_KEY,
Constants.EVIDENCE_PROTOCOL,
Constants.EVIDENCE_OBJECT_NAME
});
_properties = new List <IElementPropertyMetaData>()
{
new ElementPropertyMetaData(
this,
"javascript",
typeof(string),
true)
};
Host = host;
Endpoint = endpoint;
Protocol = protocol;
ObjName = string.IsNullOrEmpty(objectName) ? Constants.DEFAULT_OBJECT_NAME : objectName;
EnableCookies = enableCookies;
_minify = minify;
_stubble = new StubbleBuilder().Build();
_assembly = Assembly.GetExecutingAssembly();
_renderSettings = new RenderSettings()
{
SkipHtmlEncoding = true
};
using (Stream stream = _assembly.GetManifestResourceStream(Constants.TEMPLATE))
using (StreamReader streamReader = new StreamReader(stream, Encoding.UTF8))
{
_template = streamReader.ReadToEnd();
}
}
public async Task It_Should_Allow_Async_Lambda_Method_Without_Context_In_Async_Renderer()
{
var stubble = new StubbleVisitorRenderer();
var output = await stubble.RenderAsync("{{#TestMethodAsync}}Hello World!{{/TestMethodAsync}}", new {
TestMethodAsync = new Func <string, Task <object> >(async str =>
{
await Task.Delay(TimeSpan.FromMilliseconds(100));
return(str.ToLower());
}),
});
Assert.Equal("hello world!", output);
}
public YamlReportModel(string yamlTemplateContent)
{
_yamlTemplateContent = yamlTemplateContent;
var helpers = new Stubble.Helpers.Helpers()
.Register("PrintListWithComma", (context) => string.Join(", ", context.Lookup <int[]>("List")));
_stubbleRenderer = new StubbleBuilder()
.Configure(settings => {
settings.SetIgnoreCaseOnKeyLookup(true);
settings.SetMaxRecursionDepth(512);
settings.AddHelpers(helpers);
settings.AddJsonNet();
})
.Build();
}
/// <summary>
/// Executes the job.
/// </summary>
/// <param name="stubble">Stubble to use for file generation.</param>
/// <returns>Awaitable task.</returns>
public async Task Execute(StubbleVisitorRenderer stubble)
{
var templatePath = type switch
{
JobType.Class => @".\Templates\Class\Class.txt",
JobType.Flag => @".\Templates\Flag\Flag.txt",
JobType.Enumerated => @".\Templates\Enumerated\Enumerated.txt",
JobType.Interface => @".\Templates\Interface\Interface.txt",
_ => throw new ArgumentException()
};
var outputDir = data.Namespace.GetOutputPathByNameSpace();
Directory.CreateDirectory(outputDir);
using var streamReader = new StreamReader(templatePath, Encoding.UTF8);
var output = await stubble.RenderAsync(await streamReader.ReadToEndAsync(), data);
await File.WriteAllTextAsync($"{outputDir}\\{data.Name}.cs", output);
}
}
public void It_Should_Be_Able_To_Skip_Recursive_Lookups()
{
var settings =
new RenderSettings
{
SkipRecursiveLookup = true
};
var stubble = new StubbleVisitorRenderer();
var output = stubble.Render(
"{{FooValue}} {{#Foo}}{{FooValue}}{{BarValue}}{{/Foo}}",
new
{
FooValue = "Foo",
Foo = new
{
BarValue = "Bar"
}
},
settings);
Assert.Equal("Foo Bar", output);
}
