Make scopes available to lambda functions.

[ergoithz]

With something like changing the lambda render callable parameter from the current lamda function to a callable object, chevron could cleanly expose the current rendering context (chevron scope) to advanced callable contexts.

In the meantime, we're relying in ugly hacks like:

import threading
import chevron.renderer

def chevron_scopes_from_render(render, _lock=threading.Lock()):

    def capture(*args, **kwargs):
        if threading.get_ident() == ident:
            scopes[:] = kwargs['scopes']
            return ''
        return chevron_render(*args, **kwargs)

    scopes = []
    ident = threading.get_ident()
    with _lock:
        chevron_render = chevron.renderer.render
        chevron.renderer.render = capture
        render('')
        chevron.renderer.render = chevron_render
    return scopes

I'll take some time to make a PR for this.

[ergoithz]

I'm closing this based on the following reasons:

• This issue and related PR aren't getting any traction.
• It falls well outside of the Mustache standard and I've not seeing it in other library lambda implementation (edit: wrong, Mustache.js lambdas' this points to the rendering scope, see next comment)
• The standard approach of accessing the scope from inside a lambda is via render, e.g. parse_and_extract_value(render('{{.}}')) (strftime example), even tho it won't work on many situations.
• I came with a honky virtual scope property idea as a means to inject custom logic as scope property fallbacks on my own Mustache library, addressing the above issue without having to patch the entire scope tree.

Thanks for your time.

[ergoithz]

Some extra context if anyone reaches this issue.

Mustache.js exposes the rendering scope to lambda functions, and its lambdas look like this:

let scope = {
  mylambda(){
    return (content, render) => {
      return render(content);
    };
  }
}

Counterintuitively, the lambda is called inside the current rendering scope and not where gets defined, which is extremely useful as it allows referencing that scope via this.

An example (again, Mustache.js ):

let scope = {
  key: 1,
  nested: {
    key: 2,
    },
  lambda(){
    return (content, render) => {
      return render(`${render(content)}${this.key}`);
    };
  }
};
console.log(Mustache.render('{{#lambda}}value={{/lambda}}', scope));
// value=1
console.log(Mustache.render('{{#nested}}{{#lambda}}value={{/lambda}}{{/nested}}', scope))
// value=2

This essential lambda feature is missing in chevron as, again, there is no way of getting the current rendering scope during a lambda call.