support .Method

[davidB]

Hi,

Is it possible/planned to support calling method on "current context".

extracted from https://golang.org/pkg/text/template/ :

• The name of a niladic method of the data, preceded by a period,
  such as
  .Method
  The result is the value of invoking the method with dot as the
  receiver, dot.Method(). Such a method must have one return value (of
  any type) or two return values, the second of which is an error.
  If it has two and the returned error is non-nil, execution terminates
  and an error is returned to the caller as the value of Execute.
  Method invocations may be chained and combined with fields and keys
  to any depth:
  .Field1.Key1.Method1.Field2.Key2.Method2
  Methods can also be evaluated on variables, including chaining:
  $x.Method1.Field

My use case:
being able to call getter / lazy computed value from struct like Path / Uri (path(), filename(), hostname(), lazy value),
because computing those value before, could be costly and useless (if not used in the template).

(Thanks for your work)

[fiji-flo]

Right now there's only a workaround for this:
Write a custom function and pass the context as an argument.

I'll work on this. But I'm it didn't work enough with procedural macros to make any promises.

[davidB]

Thanks,

To be more precise, at least support of only zero args methods would be enought.
I integrated gtmpl into my WIP project https://github.com/davidB/git-find . Some new data (info about git repository) I want to expose are "long" to compute.

Maybe I'll open feature request (or PR) when I'll be more skilled in gtmpl.

[fiji-flo]

The template context is fully decoupled from the original data (Context::from basically clones everything to have clear ownership). Therefore, it's not possible to recover the context of the method invocation. Once #[prco_macro_attribute] is stable there a ways to make this happen in simple cases.

A somehow more basic approach would be exposing the context as first argument and invoking a Value::Function type when rendered. That's how it would look like. Syntactic sugar is missing, but again, this depends on #[prco_macro_attribute].

See my basic_method branch:

#[macro_use]
extern crate gtmpl;
#[macro_use]
extern crate gtmpl_derive;
extern crate gtmpl_value;

use gtmpl::Value;

fn plus_one(args: &[Value]) -> Result<Value, String> {
    if let Value::Object(ref o) = &args[0] {
        if let Some(Value::Number(ref n)) = o.get("num") {
            if let Some(i) = n.as_i64() {
                return Ok((i +1).into())
            }
        }
    }
    Err(format!("integer required, got: {:?}", args))
}

#[derive(Gtmpl)]
struct AddMe {
    num: u8,
    plus_one: Func
}

fn main() {
    let add_me = AddMe { num: 42, plus_one };
    let output = gtmpl::template("The answer is: {{ .plus_one }}", add_me);
    assert_eq!(&output.unwrap(), "The answer is: 43");
}

[fiji-flo]

Basic support is merged to master in #14

As the real thing depends on #[proc_macro_attribute] stabilization from rust-lang/rust#38356