On Thu, 31 May 2012 10:04:17 +0200, simendsjo simendsjo@gmail.com wrote:

I cannot find a good way to pass parameters to templates, but I have
several sub-optimal ways of doing it...

One is wrapper that adds a parameter:
void auth(alias View)(Request req, Response res) {
auto user = getLoggedInUser();
view(req, res, user);

This doesn't scale well, as all views needs this field, and I haven't
found a way to nest several wrappers.

Another way is to hijack the render method to add fields:
void render(string templateName, Params)(Response res, Request req) {
auto user = getLoggedInUser();

 vibe.http.server.render!(templateName, Params, user)(res, req);


 vibe.http.server.render!(templateName, Params)(res, req);


As you see, this allows me to only add the parameter if it makes sense.
A static if in the diet template could check if it's passed in (could
share a layout with a login/logout view even for static templates)
But I don't know how to do this for several parameters either.

The "best" way I've found is passing in the Request, and let the views
call helper methods in the application. I don't really like this
approach as I would like the static typing present, and want to keep my
views as dumb as possible.

So.. What's a good way to pass parameters to diet templates?

I found an acceptable way to handle this, but it requires some cleanup.

I store all "injectors", as I called them, in template parameters, and
each injector adds it's values, pops off it's own method pointer and calls
the next.
The last method pointer is the actual view.

// the first value is the view
routes.get("/test", &inject!(test, injectUser, injectA, injectB,

The inject method:
// We need to add a variant as I didn't find a way to allow default values
when using variadic arguments. I just add the request..
void inject(alias view, Injectors...)(Request req, Response res)

 static if(Injectors.length == 0)
     alias view!(Request, "req") Fn;
 else static if(Injectors.length == 1)
     alias Injectors[0] Injector;
     alias Injector!(view, Request, "req") Fn;
     alias Injectors[0] Injector;
     alias Injectors[1..$] Rest;
     alias Injector!(Rest, view, Request, "req") Fn;
 Fn(req, res, [Variant(req)]);


Each inject method looks like this:
void injectA(Params...)(Request req, Response res, Variant[] args...)

 int a = 10;

 alias Params[0] next;
 next!(Params[1..$], int, "a")(req, res, args~Variant(a));


And the view:
void test(Params...)(Request req, Response res, Variant[] args...)

 res.renderCompat!("test.dt", Params)(args);


This way, each injector can choose to store a default value, or not add
the value at all.
For diet templates, this means you'll have to check if a variable exists
if you choose to use an injector that doesn't always add a default value.