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();
if(user)
vibe.http.server.render!(templateName, Params, user)(res, req);
else
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.
Usage:
// the first value is the view
routes.get("/test", &inject!(test, injectUser, injectA, injectB,
injectC))
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;
}
else
{
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.
