[jifty-devel] Difference Between alias and import_templates in Template::Declare
David E. Wheeler
david at kineticode.com
Fri Oct 9 22:20:30 EDT 2009
On Oct 8, 2009, at 5:17 PM, David E. Wheeler wrote:
> It's actually `alias` that has the difference, and only when you alias
> a class that inherits templates from a parent class. I could find a
> place to carp about that case, yes.
>> Does that seem like a reasonable way forward?
> Works for me, yes.
Looking more closely, I don't think it's possible to identify when the
user will get one thing but expect the other. Let me see if I can
explain with a very simple example.
Template class Foo defines template "hello".
Template class Foo::Bar inherits from Foo.
Template class Wifty::UI aliases Foo::Bar under /bar.
So what this means is that Wifty::UI has the template /bar/hello.
Now, everything is nearly the same as it was before: the code in the
"hello" template can access package variables (if any were set) via `
The *only* difference is that $self is now "Foo", whereas before it
would have been "Foo::Bar". This has no effect on the package
variables that can be fetched.
The only way in which I can imagine that this would bit a user is if
they were expecting Foo::Bar. Maybe Foo::Bar had another class method
that they would want access to. That makes no sense to me, though,
because the "hello" template is defined in the Foo class, and
therefore should have no knowledge of its subclasses. Maybe Foo::Bar
overrode a method defined in Foo. That might lead to something
unexpected. But I have a hard time believing that anyone would have
done this, not least because these are classes with class attributes,
not objects. So there isn't really much in the way of state.
So, the only way I could put in a cluck would be when someone did
something with the class name passed to the template. The overwhelming
majority of the time, such use would be legitimate. There is no way
for me to tell, in the code, that the user was expecting "Foo::Bar"
but got "Foo".
Make sense? Sorry to be a bit long-winded; I was honestly trying to
keep it simple. :-)
All that said, I could, with a bit of added complexity, restore the
passing of Foo::Bar to the hello template defined in Foo, but as I've
said, I can't really imagine that this wasn't a mistake, given its
inconsistency compared to `import_templates` and lack of any real
reason for it being so that I can ascertain.
Sorry, there I go again…
More information about the jifty-devel