Graham Fawcett wrote:
> Here's a little toy for your amusement. On comp.lang.python today, I
> discovered that Twisted is building a next-generation templating
> system, called Nevow (a wordplay on "Woven", their earlier system, and
> "nouveau").
>
> This is what Nevow template code looks like. It's valid Python, though
> it looks more like an S-expression:
>
> document = html[
> body[
> form(action="")[ input(type="text", name="name") ],
> ]
> ]
It may look a bit weird but it's a very natural syntax to use. It's also
nice that you don't have to worry about closing HTML elements so there's
less to type in :). It's complete abuse of __getitem__ and __call__ but
I think it's worth it.
>
> Sneaky tricks with __call__ and __getitem__ are used to pull off this
> feat of syntactic sugaring. More (and better) examples can be seen at
>
> http://stewstuff.com/doc/nevow.xhtml
Actually, that link is somewhat out of date now, Nevow has been a moving
target until fairly recently. The best to start looking is the Nevow
Wiki ( http://divmod.org/users/dp.twistd/wiki/ ).
>
>
> I wrote a little Nevow implementation, just so I could see what the
> system felt like. It's a toy, of course, but I thought you might enjoy
> playing along.
>
> Attached are three files: server.py (a driver script employing the
> proposed quixote.server.medua patch), nevow.py (the nevow impl.) and
> ui.ptl (a sample PTL file). Of course, server.py is easily rewritten
> for your own server.
>
> Nevow uses keyword arguments to set tag attributes. I don't know how
> they are handling the 'class' attribute and its keyword conflict. As a
> workaround, I implemented tag attributes to allow a dict as an
> optional non-keyword argument, like so:
Any keyword arguments that begin with an underscore have the underscore
removed before the tag is renderer. So, no workaround needed just do this:
p(_class='jones', id='smith')['hello']
I understand the idea was to keep the tags as close to normal HTML as
possible which is probably why the dictionary solution was avoided.
I guess that since the Nevow's tag's __init__ uses kwargs you could just do:
p(**{'class':'jones', 'id': 'smith})
if you really wanted to but it's a bit ugly. Actually, it's very ugly ;-).
>
> p(id='smith')['hello'] # Nevow style
> renders as
> hello
>
> p({'class':'jones'}, id='smith')['hello'] # my impl. style
> renders as
> hello
Just another example to wet you appetite that also demonstrates Nevow's
support for Python sequences:
ul[[li[item] for item in ('one', 'two', 'three')]]
Would render as:
>
>
> Nevow also allows callables to be included within the 'list' section
> of a tag. For example:
>
> def hello_function():
> return p ['hi there']
>
> print div[
> h1['title'],
> hello_function,
> div['footer']
> ]
>
> would render as:
>
>
>
> Callables are lazy-evaluated (at render-time).
You can also include "directives" in the tag tree which are useful for
when you need to late bind the rendering functions. For instance:
class Page(renderer.Renderer):
def render_lookup(self, context, data):
return p['hello']
document = html[body[p(renderer=directive('lookup')]]
As you can probably guess, the directive('lookup') bit amounts to a
getattr call. You can do the same trick to find bits of data too:
class Page(renderer.Renderer):
def data_myName(self, context, data):
return 'Matt Goodall'
document = html[body[p(data=directive('myName'), renderer=str]]
Which would render 'Matt Goodall' as a string. Silly example but I'm
sure you get the idea. The directives are a very important part of Nevow
although not always useful.
Oh yeah, if you don't need to lookup the data_ at render time but you do
want to make use of the data_ mechanism you just do:
class Page(renderer.Renderer):
def data_myName(context, data):
return 'Matt Goodall'
document = html[body[p(data=render_myName, renderer=str]]
> Nevow passes a "request context" as a parameter to the callables;
Yes, this is how data (i.e. from a data_ method) is passed around and
can also be used to "remember" additional information or perhaps even
service object references for renderers to use.
The context is also used to pass the tag, as defined by you in the
document tag tree, to the renderer. The renderer can ignore the tag and
return something new or do things like clear the tag tree and insert
something new, lookup parts of the tree and remove/replace/repeat them etc.
> my toy implementation does not. They also use interfaces and component
> adaptation to adapt various Python types to Nevow "renderables", a
> very Twisted thing to do. (I used if..elif..else and some isinstance()
> checking instead, a very cheap thing to do. ;-)
>
> Not sure how they implemented the html/body/etc. "keywords" in the
> real Nevow, but I used a prototype-based approach.
Nevow is essentially the same. Everything is a prototype.
> html is an object; html['foo'] creates a copy of html, adds 'foo' to
> the copy's content, and returns the copy. You can use this yourself to
> build your own prototypes, like this Anchor derivative:
>
> biglink = a(style='font-size: 200%')
> print biglink(href='foo/')['Visit the Foo Site']
>
> displays:
>
>
Visit the Foo Site
>
> A last note: my implementation renders expressions into strings, not
> htmltext.
Nevow escapes character according to the XML rules. If you want to
include content as-is then there is an xml() tag which promises not to
change anything.
>
> * * * *
>
> Whether you try the code or not, it would be interesting to hear other
> people's opinions of the Nevow templating system: is it black magic to
> be shunned, the next best thing, or just YATS?
[snip]
Anothing useful thing Nevow lets you do is to define tag libraries.
These can be as simple as:
def header():
return div(_class='header')
of, perhaps more useful, you can create a tag prototype that
encapsulates the whole page but leaves it to the caller to fill in the
content area:
class page:
def __init__(self, theTitle):
self.content = div()
self.document = html[head[title[theTitle]],body[header(),
self.content]]
def __getitem__(self, obj):
self.content[obj]
return self.document
document = page('Page Title')[
p['hello there']
]
----
As you can probably tell, I'm very impressed with Nevow. It's very
natural for us Python programmers but it's also fairly close to HTML.
Some other things Nevow does:
* standard renderers: sequence, mapping, string and xml
* disk templates: parses a template from disk, turning it into a tag
tree
* form rendering and processing. you define what's on the form
* ... and probably more that I can't think of right now.
The way disk templates (renderer.HTMLRenderer) and tag tree renderers
(function, method, renderer.Renderer, etc) work together is wonderful.
You can switch between the two as much as you want while rendering a
page. That lets *you* decide where you want to do the work - choose the
right tool for the right job. The panacea of separation of content and
logic is all very well but sometimes that makes your code and/or
templates more complex than they need be.
The Nevow devlopers are planning on releasing it as a standalone package
so that it can be used in any application, not just inside a Twisted
application. I have no idea when that will actually happen but I would
recommend at least taking a closer look at Nevow when that happens. It's
possible that the dependence on Twisted will even be removed although it
only uses a very small part (interfaces and component) anyway.
I think Nevow is worth a serious look. From what I've seen, It seems to
fit quite nicely with the Quixote philosophy of letting you do
everything in Python if you want to.
Hope this helps.
Cheers, Matt
--
Matt Goodall, Pollenation Internet Ltd
w: http://www.pollenation.net
e: matt@pollenation.net