diff options
| -rw-r--r-- | CHANGES.txt | 19 | ||||
| -rw-r--r-- | docs/narr/renderers.rst | 4 | ||||
| -rw-r--r-- | docs/narr/templates.rst | 45 | ||||
| -rw-r--r-- | docs/narr/testing.rst | 2 | ||||
| -rw-r--r-- | pyramid/chameleon_text.py | 2 | ||||
| -rw-r--r-- | pyramid/chameleon_zpt.py | 17 | ||||
| -rw-r--r-- | pyramid/renderers.py | 13 | ||||
| -rw-r--r-- | pyramid/tests/fixtures/withmacro.pt | 3 | ||||
| -rw-r--r-- | pyramid/tests/test_renderers.py | 27 |
9 files changed, 112 insertions, 20 deletions
diff --git a/CHANGES.txt b/CHANGES.txt index c414ab74c..bb726738c 100644 --- a/CHANGES.txt +++ b/CHANGES.txt @@ -103,10 +103,21 @@ Features and ``HTTPMovedPermanently`` exceptions, so these can be caught by the NotFound view (and other exception views). -- The mako renderer now accepts a def name and returns the template def - result for the view being called. The uri format using an asset spec is - package:path/to/template#defname.mako. The old way of returning a tuple - from the view is supported for backward compatibility, ('defname', {}). +- The Mako renderer now accepts a def name in an asset spect. When the def + name is present in the asset spec, the system will render the template def + within the template and will return the result. An example asset spec is + ``package:path/to/template#defname.mako``. This will render the def named + ``defname`` inside the ``template.pt`` package instead of rendering the + entire template. The old way of returning a tuple from the view is + supported for backward compatibility, ('defname', {}). + +- The Chameleon ZPT renderer now accepts a macro name in an asset spec. When + the macro name is present in the asset spec, the system will render the + macro listed as a ``define-macro`` and return the result instead of + rendering the entire template. An example asset spec: + ``package:path/to/template#macroname.pt``. This will render the macro + defined as ``macroname`` within the ``template.pt`` template instead of the + entire templae. - When there is a predicate mismatch exception (seen when no view matches for a given request due to predicates not working), the exception now contains diff --git a/docs/narr/renderers.rst b/docs/narr/renderers.rst index 57b5bc65b..63287e2cd 100644 --- a/docs/narr/renderers.rst +++ b/docs/narr/renderers.rst @@ -306,7 +306,9 @@ See :class:`pyramid.renderers.JSON` and JSONP Renderer ~~~~~~~~~~~~~~ -.. note:: This feature is new in Pyramid 1.1. +.. note:: + + This feature is new in Pyramid 1.1. :class:`pyramid.renderers.JSONP` is a `JSONP <http://en.wikipedia.org/wiki/JSONP>`_ renderer factory helper which diff --git a/docs/narr/templates.rst b/docs/narr/templates.rst index 860010a1a..656cf4773 100644 --- a/docs/narr/templates.rst +++ b/docs/narr/templates.rst @@ -534,6 +534,33 @@ And ``templates/mytemplate.pt`` might look like so: </span> </html> + +Using A Chameleon Macro Name Within a Renderer Name +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Sommetime you'd like to render a macro inside of a Chameleon ZPT template +instead of the full Chameleon ZPT template. To render the content of a +``define-macro`` field inside a Chameleon ZPT template, given a Chameleon +template file named ``foo.pt`` and a macro named ``bar`` defined within it +(e.g. ``<div metal:define-macro="bar">...</div>``, you can configure the +template as a :term:`renderer` like so: + +.. code-block:: python + :linenos: + + from pyramid.view import view_config + + @view_config(renderer='foo#bar.pt') + def my_view(request): + return {'project':'my project'} + +The above will render the ``bar`` macro from within the ``foo.pt`` template +instead of the entire template. + +.. note:: + + This feature is new in Pyramid 1.4. + .. index:: single: Chameleon text templates @@ -714,12 +741,13 @@ This template doesn't use any advanced features of Mako, only the :term:`renderer globals`. See the `the Mako documentation <http://www.makotemplates.org/>`_ to use more advanced features. -Using def inside Mako Templates -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Using A Mako def name Within a Renderer Name +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -To use a def inside a Mako template, given a :term:`Mako` template file named -``foo.mak`` and a def named ``bar``, you can configure the template as a -:term:`renderer` like so: +Sommetime you'd like to render a ``def`` inside of a Mako template instead of +the full Mako template. To render a def inside a Mako template, given a +:term:`Mako` template file named ``foo.mak`` and a def named ``bar``, you can +configure the template as a :term:`renderer` like so: .. code-block:: python :linenos: @@ -730,6 +758,13 @@ To use a def inside a Mako template, given a :term:`Mako` template file named def my_view(request): return {'project':'my project'} +The above will render the ``bar`` def from within the ``foo.mak`` template +instead of the entire template. + +.. note:: + + This feature is new in Pyramid 1.4. + .. index:: single: automatic reloading of templates single: template automatic reload diff --git a/docs/narr/testing.rst b/docs/narr/testing.rst index 5ce2c8a66..50e9d5604 100644 --- a/docs/narr/testing.rst +++ b/docs/narr/testing.rst @@ -52,7 +52,7 @@ The suggested mechanism for unit and integration testing of a :app:`Pyramid` application is the Python :mod:`unittest` module. Although this module is named :mod:`unittest`, it is actually capable of driving both unit and integration tests. A good :mod:`unittest` tutorial is available within `Dive -Into Python <http://diveintopython.nfshost.com/unit_testing/index.html>`_ by Mark +Into Python <http://www.diveintopython.net/unit_testing/index.html>`_ by Mark Pilgrim. :app:`Pyramid` provides a number of facilities that make unit, integration, diff --git a/pyramid/chameleon_text.py b/pyramid/chameleon_text.py index 872d3b920..20f614857 100644 --- a/pyramid/chameleon_text.py +++ b/pyramid/chameleon_text.py @@ -27,7 +27,7 @@ def renderer_factory(info): @implementer(ITemplateRenderer) class TextTemplateRenderer(object): - def __init__(self, path, lookup): + def __init__(self, path, lookup, macro=None): self.path = path self.lookup = lookup diff --git a/pyramid/chameleon_zpt.py b/pyramid/chameleon_zpt.py index aa6f89e07..9f9e09850 100644 --- a/pyramid/chameleon_zpt.py +++ b/pyramid/chameleon_zpt.py @@ -26,19 +26,26 @@ def renderer_factory(info): @implementer(ITemplateRenderer) class ZPTTemplateRenderer(object): - def __init__(self, path, lookup): + def __init__(self, path, lookup, macro=None): self.path = path self.lookup = lookup + self.macro = macro @reify # avoid looking up reload_templates before manager pushed def template(self): if sys.platform.startswith('java'): # pragma: no cover raise RuntimeError( 'Chameleon templates are not compatible with Jython') - return PageTemplateFile(self.path, - auto_reload=self.lookup.auto_reload, - debug=self.lookup.debug, - translate=self.lookup.translate) + tf = PageTemplateFile(self.path, + auto_reload=self.lookup.auto_reload, + debug=self.lookup.debug, + translate=self.lookup.translate) + if self.macro: + # render only the portion of the template included in a + # define-macro named the value of self.macro + macro_renderer = tf.macros[self.macro].include + tf._render = macro_renderer + return tf def implementation(self): return self.template diff --git a/pyramid/renderers.py b/pyramid/renderers.py index e526f9997..fe9df33d1 100644 --- a/pyramid/renderers.py +++ b/pyramid/renderers.py @@ -1,5 +1,6 @@ import json import os +import re import pkg_resources import threading @@ -426,7 +427,7 @@ class ChameleonRendererLookup(object): raise ValueError('Missing template file: %s' % spec) renderer = registry.queryUtility(ITemplateRenderer, name=spec) if renderer is None: - renderer = self.impl(spec, self) + renderer = self.impl(spec, self, macro=None) # cache the template try: self.lock.acquire() @@ -438,6 +439,14 @@ class ChameleonRendererLookup(object): # spec is a package:relpath asset spec renderer = registry.queryUtility(ITemplateRenderer, name=spec) if renderer is None: + p = re.compile( + r'(?P<asset>[\w_.:/]+)' + r'(?:\#(?P<defname>[\w_]+))?' + r'(\.(?P<ext>.*))' + ) + asset, macro, ext = p.match(spec).group( + 'asset', 'defname', 'ext') + spec = '%s.%s' % (asset, ext) try: package_name, filename = spec.split(':', 1) except ValueError: # pragma: no cover @@ -450,7 +459,7 @@ class ChameleonRendererLookup(object): if not pkg_resources.resource_exists(package_name, filename): raise ValueError( 'Missing template asset: %s (%s)' % (spec, abspath)) - renderer = self.impl(abspath, self) + renderer = self.impl(abspath, self, macro=macro) settings = info.settings if not settings.get('reload_assets'): # cache the template diff --git a/pyramid/tests/fixtures/withmacro.pt b/pyramid/tests/fixtures/withmacro.pt new file mode 100644 index 000000000..bb80475c0 --- /dev/null +++ b/pyramid/tests/fixtures/withmacro.pt @@ -0,0 +1,3 @@ +<metal:m define-macro="foo"> + Hello! +</metal:m> diff --git a/pyramid/tests/test_renderers.py b/pyramid/tests/test_renderers.py index 495d7dc23..cc3d73fb7 100644 --- a/pyramid/tests/test_renderers.py +++ b/pyramid/tests/test_renderers.py @@ -292,7 +292,32 @@ class TestChameleonRendererLookup(unittest.TestCase): if path.endswith('.pyc'): # pragma: no cover path = path[:-1] self.assertTrue(factory.path.startswith(path)) - self.assertEqual(factory.kw, {}) + self.assertEqual(factory.kw, {'macro':None}) + + def test___call__spec_withmacro(self): + import os + from pyramid import tests + module_name = tests.__name__ + relpath = 'fixtures/withmacro#foo.pt' + renderer = {} + factory = DummyFactory(renderer) + spec = '%s:%s' % (module_name, relpath) + info = DummyRendererInfo({ + 'name':spec, + 'package':None, + 'registry':self.config.registry, + 'settings':{}, + 'type':'type', + }) + lookup = self._makeOne(factory) + result = lookup(info) + self.assertTrue(result is renderer) + path = os.path.join( + os.path.dirname(os.path.abspath(__file__)), + 'fixtures', + 'withmacro.pt') + self.assertTrue(factory.path.startswith(path)) + self.assertEqual(factory.kw, {'macro':'foo'}) def test___call__reload_assets_true(self): import pyramid.tests |