Changes between Version 12 and Version 13 of GenshiTutorial

Timestamp:

Aug 29, 2007, 2:01:59 PM (16 years ago)

Author:

cmlenz

Comment:

--

GenshiTutorial

@@ -452 +452 @@
 
 Now, all entered values are preserved when validation errors occur. Note that the form is populated as the template is being generated, there is no reparsing and reserialization of the output.
+
+== Factoring out the Templating ==
+
+By now, we already have some repetitive code when it comes to rendering templates: both the `Root.index()` and the `Root.submit()` methods look very similar in that regard: they load a specific template, call its `generate()` method passing it some data, and then call the `render()` method of the resulting stream. As we're going to be adding more controller methods, let's factor out those things into a library module.
+
+There's a special challenge here, though: we still want to be able to add the `HTMLFormFiller` or other stream filters to the template output stream, which needs to be done before that output stream is serialized. We'll use a combination of a decorator and a regular function to achieve that, which collaborate using the !CherryPy thread-local context.
+
+Create a directory called `lib` inside the `geddit` directory, and inside the `lib` directory create two files, named `__init__.py` and `template.py`, respectively. Leave the first one empty, and in the second one, insert the following code:
+
+{{{
+#!python
+import os
+
+import cherrypy
+from genshi.core import Stream
+from genshi.output import encode, get_serializer
+from genshi.template import TemplateLoader
+
+loader = TemplateLoader(
+    os.path.join(os.path.dirname(__file__), '..', 'templates'),
+    auto_reload=True
+)
+
+def output(filename, method=None, encoding='utf-8', **options):
+    """Decorator for exposed methods to specify what template the should use
+    for rendering, and which serialization method and options should be
+    applied.
+    """
+    def decorate(func):
+        def wrapper(*args, **kwargs):
+            cherrypy.thread_data.template = loader.load(filename)
+            serializer = get_serializer(method, **options)
+            stream = func(*args, **kwargs)
+            if not isinstance(stream, Stream):
+                return stream
+            return encode(serializer(stream), method=serializer,
+                          encoding=encoding)
+        return wrapper
+    return decorate
+
+def render(*args, **kwargs):
+    """Function to render the given data to the template specified via the
+    ``@output`` decorator.
+    """
+    if args:
+        assert len(args) == 1, \
+            'Expected exactly one argument, but got %r' % (args,)
+        template = loader.load(args[0])
+    else:
+        template = cherrypy.thread_data.template
+    return template.generate(**kwargs)
+}}}
+
+In the `genshi/controller.py` file, you can now remove the `from genshi.template import TemplateLoader` line, and also the instantiation of the `TemplateLoader`, as that is now done in our new library module. Of course, you'll have to import that library module instead:
+
+{{{
+#!python
+from geddit.lib import template
+}}}
+
+Now, we can change the `Root` class to match the following:
+
+{{{
+#!python
+class Root(object):
+
+    def __init__(self, data):
+        self.data = data
+
+    @cherrypy.expose
+    @template.output('index.html', method='html', doctype='html')
+    def index(self):
+        return template.render(submissions=self.data)
+
+    @cherrypy.expose
+    @template.output('submit.html', method='html', doctype='html')
+    def submit(self, cancel=False, **data):
+        if cherrypy.request.method == 'POST':
+            if cancel:
+                raise cherrypy.HTTPRedirect('/')
+            form = SubmissionForm()
+            try:
+                data = form.to_python(data)
+                submission = Submission(**data)
+                self.data.append(submission)
+                raise cherrypy.HTTPRedirect('/')
+            except Invalid, e:
+                errors = e.unpack_errors()
+        else:
+            errors = {}
+
+        return template.render(errors=errors) | HTMLFormFiller(data=data)
+}}}
+
+There's still some duplication of code in the decorators: the need to specify the serialization method and the doctype over and over again is suboptimal, and should ideally be made configurable in a central location.