context dependent blocks

[cloudfy]

can any provide a sample for rendering a

{{#switch propertyValue}}
  {{#case "a"}}the value is a{{/case}}
  {{#case "b"}}the value is a{{/case}}
  {{#case else}}the value is not provided{{/case}}
{{/switch}}

Before 2.0x we could add to the context, which we cannot now.

(with 1.11.5)
context.Add("switchValue", value);

[oformaniuk]

Hi @cloudfy
I may assume your context is ExpandoObject or something similar. If so you should be able to do it in a simple way:

((dynamic)context.Value).Add("switchValue", value);

Here's an example how I would approach this using new features. It works for any input data. You can inline helpers declaration to Handlebars.RegisterHelper("switch", (writer, options, context, arguments) => {...}) I just like class-per-helper more.

[Fact]
public void SwitchCaseTest()
{
    const string template = @"
        {{~#switch propertyValue}}
            {{~#case 'a'}}a == {{@switchValue}}{{/case~}}
            {{~#case 'b'}}b == {{@switchValue}}{{/case~}}
            {{~#default}}the value is not provided{{/default~}}
        {{/switch~}}";

    var handlebars = Handlebars.Create();
    handlebars.RegisterHelper(new CaseHelper());
    handlebars.RegisterHelper(new SwitchHelper());
    handlebars.RegisterHelper(new DefaultCaseHelper());

    var handlebarsTemplate = handlebars.Compile(template);

    var a = handlebarsTemplate(new {propertyValue = "a"});
    var b = handlebarsTemplate(new {propertyValue = "b"});
    var c = handlebarsTemplate(new {propertyValue = "c"});
    
    Assert.Equal("a == a", a);
    Assert.Equal("b == b", b);
    Assert.Equal("the value is not provided", c);
}

private class SwitchHelper : IHelperDescriptor<BlockHelperOptions>
{
    public PathInfo Name { get; } = "switch";
    
    public object Invoke(in BlockHelperOptions options, in Context context, in Arguments arguments)
    {
        return this.ReturnInvoke(options, context, arguments);
    }

    public void Invoke(in EncodedTextWriter output, in BlockHelperOptions options, in Context context, in Arguments arguments)
    {
        var value = arguments[0];
        var switchFrame = options.CreateFrame(value);
        var data = new DataValues(switchFrame);
        data["switchValue"] = value;
        data["__switchBlock"] = BoxedValues.True;
        data["__switchCaseMatched"] = BoxedValues.False;
        options.Template(output, switchFrame);
    }
}

private class CaseHelper : IHelperDescriptor<BlockHelperOptions>
{
    public PathInfo Name { get; } = "case";
    
    public object Invoke(in BlockHelperOptions options, in Context context, in Arguments arguments)
    {
        return this.ReturnInvoke(options, context, arguments);
    }

    public void Invoke(in EncodedTextWriter output, in BlockHelperOptions options, in Context context, in Arguments arguments)
    {
        if (!(bool) options.Data["__switchBlock"]) throw new InvalidOperationException();
        if((bool) options.Data["__switchCaseMatched"]) return;
        
        var value = options.Data["switchValue"];
        if(!Equals(value, arguments[0])) return;
        var data = new DataValues(options.Frame);
        data["__switchCaseMatched"] = BoxedValues.True;
        
        options.Template(output, options.Frame); // execute `case` in switch context
    }
}

private class DefaultCaseHelper : IHelperDescriptor<BlockHelperOptions>
{
    public PathInfo Name { get; } = "default";
    
    public object Invoke(in BlockHelperOptions options, in Context context, in Arguments arguments)
    {
        return this.ReturnInvoke(options, context, arguments);
    }

    public void Invoke(in EncodedTextWriter output, in BlockHelperOptions options, in Context context, in Arguments arguments)
    {
        if (!(bool) options.Data["__switchBlock"]) throw new InvalidOperationException();
        if((bool) options.Data["__switchCaseMatched"]) return;
        
        options.Template(output, options.Frame); // execute `case` in switch context
    }
}

[oformaniuk]

Some more explanation:
execute 'case' in switch context - new context for a case helper would not be created. Instead it is executed in parent context (switchContext in this case). You can still do options.Template(output, context) as before but it would add one more layer to expressions like ../../some-value.