1. Blaise Laflamme
  2. repoze.bfg.mako


repoze.bfg.mako / PKG-INFO

Metadata-Version: 1.0
Name: repoze.bfg.mako
Version: 0.3
Summary: Mako template bindings for repoze.bfg
Home-page: http://www.repoze.org
Author: Chris McDonough / Agendaless Consulting
Author-email: repoze-dev@lists.repoze.org
License: BSD-derived (http://www.repoze.org/LICENSE.txt)
Description: ``repoze.bfg`` bindings for `Mako <http://www.makotemplates.org/>`_
        These are bindings for the `Mako templating system
        <http://www.makotemplates.org/>`_ for the `repoze.bfg
        <http://bfg.repoze.org/`_ web framework.
        High-Level API
        The API follows the pattern of the "default" template API for
        ``repoze.bfg``, which includes three functions: ``get_template``,
        ``render_template``, and ``render_template_to_response``.  From within
        a repoze.bfg view function, you might do::
        from webob import Response
        from repoze.bfg.renderers import get_renderer
        template = get_renderer('templates/foo.mak')
        return Response(template.render_unicode(foo=1))
        from repoze.bfg.renderers import render
        s = render('templates/foo.mak', {foo:1})
        return Response(s)
        from repoze.bfg.renderers import render_to_response
        return render_to_response('templates/foo.mak', {foo:1})
        All of these examples are equivalent.  The first argument passed in to
        each of them (representing the template location) should be a file
        path relative to the lookup loader root.
        The value passed to ``render`` or ``render_to_response`` should be one
        of the following:
        - A *dictionary* representing the values passed to the template.
        - A *tuple*, consisting of two values in the form ``(function_name,
        values)``.  If a tuple is returned, the ``def`` named after
        ``function_name`` in the template is rendered instead of the entire
        template using the ``values`` provided, which must be a dictionary).
        Positional arguments to the function defined within the template are
        filled in by name using the same-named values within the ``values``
        Configuring the Loookup Loader
        In your bfg application's ``.ini`` file, use a ``mako.directories``
        use = egg:mypackage
        mako.directories = mypackage:templates
        reload_templates = true
        debug_authorization = false
        debug_notfound = false
        ``mako.directories`` should be a sequence of absolute directory names
        or resource specifications, one per line.
        Other values:
        Set the mako template input encoding.  The default is ``utf-8``.
        If this is ``True``, Mako templates will be checked for changes at
        every rendering boundary.  This slows down rendering but is
        convenient for development.
        Ensuring the Mako Renderer Extension is Active
        ``repoze.bfg.mako`` can also act as a "renderer" for a view when it is
        active in the ``repoze.bfg`` application you're developing::
        def aview(request):
        return {'foo':1}
        There are two ways to make sure that the mako extension is active.
        Both are completely equivalent.
        #) Ensure that some ZCML file with an analogue of the following
        contents is executed::
        <include package="repoze.bfg.mako"/>
        #) Call the ``add_renderer`` method of a Configurator in your
        from repoze.bfg.mako import renderer_factory
        config.add_renderer(.'mak', renderer_factory)
        config.add_renderer(.'mako', renderer_factory)
        In either case, files with the ``.mak`` and ``.mako`` extensions are
        now considered to be Mako templates.
        Note that when mako is used as a ``renderer`` in this fashion, the
        ``repoze.bfg`` context that is usually available as ``context`` within
        the template global namespace is available as ``_context`` (the
        ``context`` name without the underscore is reserved for internal Mako
        Install using setuptools, e.g. (within a virtualenv)::
        $ easy_install -i http://dist.repoze.org/bfg/dev/simple repoze.bfg.mako
        Creating a Mako ``repoze.bfg`` Project
        After you've got ``repoze.bfg.mako`` installed, you can invoke the
        following command to create a Mako-based ``repoze.bfg`` project::
        $ paster create -t bin/paster create -t bfg_mako_starter
        Reporting Bugs / Development Versions
        Visit http://bugs.repoze.org to report bugs.  Visit
        http://svn.repoze.org to download development or tagged versions.
        0.3 (2010-09-19)
        - A ``repoze.bfg.mako`` renderer may now be called with a *tuple*,
        consisting of two values in the form ``(function_name, values)``.
        If a tuple is provided to a renderer, the ``def`` named after
        ``function_name`` in the template is rendered instead of the entire
        template using the ``values`` provided, which must be a dictionary).
        0.2 (2010-09-06)
        - Removed ``repoze.bfg.mako`` functions named ``render_template``,
        ``render_template_to_response``, ``get_template`` and
        ``get_renderer``.  As of ``repoze.bfg`` 1.3a6, use of these
        functions should be replaced with usage of similarly-named functions
        present in the ``repoze.bfg.renderers`` module .
        - Added integration tests for imperative rendering and ZCML loading.
        0.1 (2010-07-24)
        - Initial release.
Keywords: web wsgi zope
Platform: UNKNOWN
Classifier: Intended Audience :: Developers
Classifier: Programming Language :: Python
Classifier: Framework :: BFG
Classifier: License :: Repoze Public License