repoze.bfg 1.1a9 has been released

It may be installed via:

    easy_install -i http://dist.repoze.org/bfg/1.1/simple repoze.bfg

The documentation at http://docs.repoze.org/bfg/1.1/ have been updated.

This release is hopefully the last alpha release in the 1.1 series (hopefully 
only betas and a final will follow).

1.1a9 includes a number of important design changes.

- Root factories are now passed a "request" rather than a WSGI environ 
dictionary.

- Traversers are now passed a request rather than a WSGI environ dictionary.

- There is now such a thing as a "route predicate".

Note that there are no major backwards incompatibilities in passing a request 
to root factories and traversers, as the request has been equipped with a 
dictlike interface that queries and mutates the underlying environment (the 
request "acts like an environ").

The detailed changelog follows.

1.1a9 (2009-10-31)
==================

Bug Fixes
---------

- An incorrect ZCML conflict would be encountered when the
   ``request_param`` predicate attribute was used on the ZCML ``view``
   directive if any two otherwise same-predicated views had the
   combination of a predicate value with an ``=`` sign and one without
   (e.g. ``a`` vs. ``a=123``).

Features
--------

- In previous versions of BFG, the "root factory" (the ``get_root``
   callable passed to ``make_app`` or a function pointed to by the
   ``factory`` attribute of a route) was called with a "bare" WSGI
   environment.  In this version, and going forward, it will be called
   with a ``request`` object.  The request object passed to the factory
   implements dictionary-like methods in such a way that existing root
   factory code which expects to be passed an environ will continue to
   work.

- The ``__call__`` of a plugin "traverser" implementation (registered
   as an adapter for ``ITraverser`` or ``ITraverserFactory``) will now
   receive a *request* as the single argument to its ``__call__``
   method.  In previous versions it was passed a WSGI ``environ``
   object.  The request object passed to the factory implements
   dictionary-like methods in such a way that existing traverser code
   which expects to be passed an environ will continue to work.

- The ZCML ``route`` directive's attributes ``xhr``,
   ``request_method``, ``path_info``, ``request_param``, ``header`` and
   ``accept`` are now *route* predicates rather than *view* predicates.
   If one or more of these predicates is specified in the route
   configuration, all of the predicates must return true for the route
   to match a request.  If one or more of the route predicates
   associated with a route returns ``False`` when checked during a
   request, the route match fails, and the next match in the routelist
   is tried.  This differs from the previous behavior, where no route
   predicates existed and all predicates were considered view
   predicates, because in that scenario, the next route was not tried.

Documentation
-------------

- Various changes were made to narrative and API documentation
   supporting the change from passing a request rather than an environ
   to root factories and traversers.

Internal
--------

- The request implements dictionary-like methods that mutate and query
   the WSGI environ.  This is only for the purpose of backwards
   compatibility with root factories which expect an ``environ`` rather
   than a request.

- The ``repoze.bfg.request.create_route_request_factory`` function,
   which returned a request factory was removed in favor of a
   ``repoze.bfg.request.route_request_interface`` function, which
   returns an interface.

- The ``repoze.bfg.request.Request`` class, which is a subclass of
   ``webob.Request`` now defines its own ``__setattr__``,
   ``__getattr__`` and ``__delattr__`` methods, which override the
   default WebOb behavior.  The default WebOb behavior stores
   attributes of the request in ``self.environ['webob.adhoc_attrs']``,
   and retrieves them from that dictionary during a ``__getattr__``.
   This behavior was undesirable for speed and "expectation" reasons.
   Now attributes of the ``request`` are stored in ``request.__dict__``
   (as you otherwise might expect from an object that did not override
   these methods).

- The router no longer calls ``repoze.bfg.traversal._traverse`` and
   does its work "inline" (speed).

- Reverse the order in which the router calls the request factory and
   the root factory.  The request factory is now called first; the
   resulting request is passed to the root factory.

- The ``repoze.bfg.request.request_factory`` function has been
   removed.  Its functionality is no longer required.

- The "routes root factory" that wraps the default root factory when
   there are routes mentioned in the configuration now attaches an
   interface to the request via ``zope.interface.directlyProvides``.
   This replaces logic in the (now-gone)
   ``repoze.bfg.request.request_factory`` function.

- The ``route`` and ``view`` ZCML directives now register an interface
   as a named utility (retrieved from
   ``repoze.bfg.request.route_request_interface``) rather than a
   request factory (the previous return value of the now-missing
   ``repoze.bfg.request.create_route_request_factory``.

- The ``repoze.bfg.functional`` module was renamed to
   ``repoze.bfg.compat``.

Backwards Incompatibilities
---------------------------

- Explicitly revert the feature introduced in 1.1a8: where the name
   ``root`` is available as an attribute of the request before a
   NewRequest event is emitted.  This makes some potential future
   features impossible, or at least awkward (such as grouping traversal
   and view lookup into a single adapter lookup).

- The ``containment``, ``attr`` and ``renderer`` attributes of the
   ``route`` ZCML directive were removed.
_______________________________________________
Repoze-dev mailing list
Repoze-dev@lists.repoze.org
http://lists.repoze.org/listinfo/repoze-dev

Reply via email to