Metadata-Version: 1.0
Name: repoze.bfg.skins
Version: 0.20
Summary: Skin support for BFG.
Home-page: UNKNOWN
Author: UNKNOWN
Author-email: UNKNOWN
License: BSD
Description: Overview
        ========
        
        .. role:: mod(emphasis)
        .. role:: term(emphasis)
        
        This package provides a simple framework to integrate code with
        templates and resources.
        
        See full documentation at:
        http://packages.python.org/repoze.bfg.skins/.
        
        About
        -----
        
        The package is written and maintained by `Malthe Borch
        <mailto:mborch@gmail.com>`_ and `Stefan Eletzhofer
        <stefan.eletzhofer@inquant.de>`_. Available as-is under the BSD
        license.
        
        To contribute or get support for this package, please visit the
        #repoze channel on freenode irc or write to the `repoze-dev
        mailinglist <repoze-dev@lists.repoze.org>`_.
        
        
        Changelog
        =========
        
        0.20 (2009-12-14)
        
        - Compatibility fixes for BFG 1.2.
        
        0.19 (2009-11-27)
        
        - Use the ``MacFSEvents`` module instead of ``pyfsevents``.
        
        0.18 (2009-11-26)
        
        - Added discovery support (Mac OS X and Linux).
        
        - Allow hyphens in the skin expression translator.
        
        - Do not set charset on binary responses.
        
        - Add content length to static responses.
        
        0.17 (2009-11-16)
        
        - Skin objects used as descriptors now pass on the class instance
        dict as the keyword argument dictionary.
        
        - Skin templates may now be used as macros.
        
        - Make sure expression syntax is correct.
        
        0.16 (2009-11-14)
        
        - Acquisition-like skin object lookup from within templates,
        e.g. ``skin: main_template`` will try to acquire the object from
        the current skin object path (if applicable), while ``skin:
        /main_template`` will always use an absolute (direct) lookup.
        
        0.15 (2009-11-12)
        
        - Make ``name`` attribute public.
        
        - Normalize path (ZCML does this, but we might be used
        imperatively).
        
        - Raise runtime-error if view is attempted registered for unknown
        skin object (should never happen, but did because of an internal
        bug).
        
        0.14 (2009-11-09)
        
        - Look up skin object on call if object has not been resolved.
        
        - Added index view registration option.
        
        - Use ``Chameleon`` egg.
        
        - Pin package versions for testing.
        
        0.13 (2009-10-30)
        
        - Rewrite. Backwards-compatibility broken.
        
        Migration path:
        
        Skins registrartion directive renamed to <bfg:skins>.
        
        To register views for skin objects, the <bfg:view> directive
        should be used inside a <bfg:skins> declaration. See
        documentation.
        
        Previous users should consult documentation for more information.
        
        - Made compatible with repoze.bfg 1.1a4.
        
        - Disuse ``component.adapts`` (unuseable in any BFG app), to make
        compatible with repoze.bfg 1.1a6+.
        
        0.12 (2009-02-12)
        
        - Added convenience method ``get_skin_template_view``. [malthe]
        
        - The ``get_skin_template`` method now accepts an optional
        ``request_type`` parameter, which takes priority in
        adaptation. [malthe]
        
        - The ``provides`` parameter has been retired; instead, a ``class``
        parameter may be provided. By default this is set to the
        ``SkinTemplate`` class; to register a view, simply set it to
        ``SkinTemplateView`` (full module path required). [malthe]
        
        0.11 (2009-02-09)
        
        - View permission is now only registered if a view must be
        provided. [malthe]
        
        - Multiple interfaces may be specified as ``provides``. [malthe]
        
        0.10 (2009-01-28)
        
        - Added parameter ``content_type`` which will set the content type
        of the view response. [malthe]
        
        - Added ``macros`` attribute to the template object. [malthe]
        
        0.9 (2008-12-05)
        
        - Updated signatures for skin template factory lookup
        functions. [malthe]
        
        - Added support for skin api methods. [malthe]
        
        0.8 (2008-12-05)
        
        - Provide ``ISkinMacro`` unless ``provides`` is set; however, always
        provide ``ISkinTemplate``. Meanwhile, the macro accessor looks
        only for skin templates registered for the ``ISkinMacro``
        interface. [malthe]
        
        0.7 (2008-12-04)
        
        - If ``provides`` is set, do not automatically provide the
        ``ISkinTemplate`` interface as well; this behavior made it
        difficult to program cascading rendering schemes. [malthe]
        
        - Keyword-arguments are now accepted by the utility methods for
        rendering skin templates using Python. [malthe]
        
        - Added security assertions to macro rendering function to prevent
        infinite loop if a template tries to render itself. [malthe]
        
        0.6 (2008-12-03)
        
        - Do not register macro components separately, but make them
        available from the ``macro`` attribute of a skin
        template. [malthe]
        
        0.5 (2008-12-03)
        
        - Added component lookup scheme for the bound skin template object
        which makes skin API components available using ``get_<name>``
        where <name> is the component name. [malthe]
        
        - Restructured package and changed look up scheme for skin APIs and
        macros. A symbol ``template`` is now available to skin templates;
        from this object, methods ``get_api`` and ``get_macro`` can be
        used to look up skin APIs and macros, respectively. [malthe]
        
        - Added render_skin_template_to_response and render_skin_template
        methods for general template rendering. [fairwinds]
        
        0.4 (2008-11-13)
        
        - Added ``name`` attribute to skin template interface. [malthe]
        
        - No longer provide ``repoze.bfg.interfaces.IView`` by default; the
        ``provides`` attribute may now be used to specify an additional
        interface which the skin templates will provide. [malthe]
        
        0.3 (2008-10-29)
        
        - Fix performance issue where template objects would be instantiated
        at every call. [malthe]
        
        - Pass keyword arguments to skin template callable. [malthe]
        
        - Instantiate page template directly. [malthe]
        
        0.2 (2008-10-03)
        
        - Templates located in subdirectories are now named by replacing the
        operating system path separator with a forward slash symbol (often
        this will be the same character); before a dot '.' was
        used. [malthe]
        
        - Added Template API base class. [malthe]
        
        - Renamed ``IApi`` to ``ITemplateAPI``. [malthe]
        
        - Template API components should adapt (context, request, template),
        where ``template`` is the skin template object (such an API might
        need to provide access to the template file itself, in order to
        get a path to resources local to the template). [malthe]
        
        - Added ``render`` method to skin template class to allow rendering
        to a string instead of to a WebOb response. [malthe]
        
        - Renamed package to ``repoze.bfg.skins`` [seletz]
        
        - Added logic to allow registering and acquiring template API
        components from templates. [malthe]
        
        - Changed the Skin Template View to be a class, and added a minimal
        interface ISkinTemplate to access the template path [seletz]
        
        - Fixed a bug where we did not tear down the tests correctly
        [seletz]
        
        - Fixed bug where the INewRequest event handler would call templates
        when checking for their existence [seletz]
        
        0.1 (2008-09-25)
        
        - Initial release [malthe]
        
        - Added support to dynamically register templates if they are added
        to a registered template directory [seletz]
        
        
Keywords: zope3 repoze bfg
Platform: UNKNOWN
Classifier: Development Status :: 4 - Beta
Classifier: Environment :: Web Environment
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: Zope Public License
Classifier: Programming Language :: Python
Classifier: Natural Language :: English
Classifier: Operating System :: OS Independent
Classifier: Topic :: Internet :: WWW/HTTP
Classifier: Framework :: BFG
