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); }