Skin support for BFG.
This package provides a simple framework to integrate code with templates and resources.
See full documentation at: http://packages.python.org/repoze.bfg.skins/.
To contribute or get support for this package, please visit the #repoze channel on freenode irc or write to the repoze-dev mailinglist.
Allow request-specific skin registration (using the request_type parameter to the skins directive). The request is retrieved from the thread-local manager at lookup-time.
Add imperative configuration utility method.
Compatibility fixes for BFG 1.2.
Use the MacFSEvents module instead of pyfsevents.
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.
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.
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.
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).
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.
Rewrite. Backwards-compatibility broken.
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+.
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]
View permission is now only registered if a view must be provided. [malthe]
Multiple interfaces may be specified as provides. [malthe]
Added parameter content_type which will set the content type of the view response. [malthe]
Added macros attribute to the template object. [malthe]
Updated signatures for skin template factory lookup functions. [malthe]
Added support for skin api methods. [malthe]
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]
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]
Do not register macro components separately, but make them available from the macro attribute of a skin template. [malthe]
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]
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]
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]
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]
Initial release [malthe]
Added support to dynamically register templates if they are added to a registered template directory [seletz]
Release history Release notifications | RSS feed
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.