v1.0 - Finally!

Nothing

Well nothing substantial after that last few alphas. We're happy enough with Stubble's current state that we're releasing 1.0.

For an idea of what else I may work on next, please read the blog post here

1.0.0 Alpha 20 - I've got standards!

• Update to move from using netstandard1.3 to netstandard2.0. This shouldn't affect many people since netstandard 2.0 is the recommended version and brings back some missing APIs from before. This mean's we've dropped explict support for net46 (since the lowest supported by netstandard2.0 is net461) however net45 will work just fine.

1.0.0 Alpha 19 - Trust me, I'm a developer

• Added the ability to skip HTML encoding by default without using triple {{{ tags. We're trusting you developers! (thanks to @elringus for the request) #23
  To use this feature when passing render settings to the render method add the following:

var stubble = new StubbleBuilder().Build();
var result = await stubble.RenderAsync("{{Html}}\n{{{Html}}}", new { Html = "<b>Bold!</b>"}, new RenderSettings
{
    SkipHtmlEncoding = true
});

Assert.Equal("<b>Bold!</b>\n<b>Bold!</b>", result);

• Migrated to portable PDBs which allow debugging on unix systems and now you can use sourcelink to debug the source on github! #11

1.0.0 Alpha 18 - Greatest Hits

Compilation

So we now have a compilation renderer which will allow you to compile your mustache templates to strongly typed functions. This currently doesn't work with the Lambda portion of the spec however has massive speed improvements over standard rendering for templates that don't change too often. This is exposed as an extension package and can be included my going to nuget and looking for Stubble.Compilation. For more details on this feature please checkout the readme or look at the docs here.

Configuration Rework

Configuring a renderer has now changed and there is a specific settings builder class which is configured in a Configure method on the renderer builder itself. We recommend that all extensions adding extension methods for settings add them to IRendererSettingsBuilder since they will be easily discoverable by users. For more details on this please see the extension docs here.

Migration from the old method to the new method would look something like this

var loader = // Setup custom template loader here
var builder = new StubbleBuilder()
    .SetTemplateLoader(loader)
    .SetPartialTemplateLoader(loader)
    .Build();
// Becomes
var builder = new StubbleBuilder()
    .Configure(settings =>
        settings.SetTemplateLoader(loader)
                .SetPartialTemplateLoader(loader);
    )
    .Build();

Strong Naming

I've removed the strong naming from the core Stubble.Core package due to it requiring people to add binding redirects which can cause all kinds of problems. If you require strong naming we suggest you use strongnamer to resolve anything requiring strong naming to be present.

1.0.0 Alpha 17 - Swing and a Miss

A small release containing two small fixes. I'm currently at work for some changes and then we'll be in Beta and the API will stabilise.

• Accessing nested values didn't return the correct values on data misses #17 (Thanks to @schmitch)
• Accessing nested values with Throw on Data Miss flag being set didn't work

1.0.0 Alpha 16 - Reboot?

Well it's been awhile since I last made a release and this one is quite the change.
I've pretty much overhauled the whole underlying architecture for parsing and rendering.

Most of the public facing interfaces have stayed the same or gained new functionality so you should just be able to update and have the exact same experience unless you're using custom extensions for parsing or rendering.

Full Spec compatibility!

Stubble is now fully spec compliant including the often ignored tests regarding whitespace in a template.
This shouldn't affect your rendering in the slightest but perhaps make them look slightly better, however those expecting specific whitespace in their templates may have porting issues.

Non-regex parser

We've gotten rid of our old Regex based parser and replaced it with a good old fashioned string scanner.
This means that our parsing creates less garbage, is much faster (without caching) and allowed us to fix the ignored whitespace spec tests making us fully compliant.

Visitor pattern based renderer

We've also adjusted our rendering based on this new parser.
Since we can register new tag parsers with our parser we needed a way to render these efficiently.

The new renderer works on registering tag renderers with a core rendering engine.
In the box we have our standard string renderer which will be the default, we do however provide extension points for users to change the renderer.

Did anyone say function compilation rendering engine?

Benchmark Overhaul

In the beginning we rolled our own benchmarks because we didn't know any better.
Now in the future we've found BenchmarkDotNet which is an excellent library for micro-benchmarking and handles a lot of the complicated work of fair and effective benchmarking.
Because of this our benchmarks are now fairer and closer to reality and allow us to easily test our progress over time.

Mentions

Much of the work in this release was inspired heavily by Markdig.
We even borrowed some of their internal pieces to make our renderer as efficient as we possibly could.
If you like the work we've done in this release perhaps you'd like to go star their project too as its pretty great.

1.0.0 Alpha 15 - Performance Improvements

This release improves the internal speed of core Stubble processes resulting in less garbage created and less CPU wasted

1.0.0 Alpha 14 - DotNet Core

Update Stubble to work with the RTM of Dotnet core!

1.0.0 Alpha 13

• Feature: Expose the ignore case on key lookup value on the builder

1.0.0 Alpha 12

• Feature: You can now lookup values in context without case sensitivity. This is useful if coming from javascript to C# #7