- The ``repoze.bfg.location.LocationProxy`` class and the

  ``repoze.bfg.location.ClassAndInstanceDescr`` class have both been
  removed in order to be able to eventually shed a dependency on
  ``zope.proxy``.  Neither of these classes was ever an API.

- In all previous releases, the ``repoze.bfg.location.locate``
  function worked like so: if a model did not explicitly provide the
  ``repoze.bfg.interfaces.ILocation`` interface, ``locate`` returned a
  ``LocationProxy`` object representing ``model`` with its
  ``__parent__`` attribute assigned to ``parent`` and a ``__name__``
  attribute assigned to ``__name__``.  In this release, the
  ``repoze.bfg.location.locate`` function simply jams the ``__name__``
  and ``__parent__`` attributes on to the supplied model
  unconditionally, no matter if the object implements ILocation or
  not, and it never returns a proxy.  This was done because the
  LocationProxy behavior has now moved into an add-on package
  (``repoze.bfg.traversalwrapper``), in order to eventually be able to
  shed a dependency on ``zope.proxy``.

- In all previous releases, by default, if traversal was used (as
  opposed to URL-dispatch), and the root object supplied
  the``repoze.bfg.interfaces.ILocation`` interface, but the children
  returned via its ``__getitem__`` returned an object that did not
  implement the same interface, :mod:`repoze.bfg` provided some
  implicit help during traversal.  This traversal feature wrapped
  subobjects from the root (and thereafter) that did not implement
  ``ILocation`` in proxies which automatically provided them with a
  ``__name__`` and ``__parent__`` attribute based on the name being
  traversed and the previous object traversed.  This feature has now
  been removed from the base ``repoze.bfg`` package for purposes of
  eventually shedding a dependency on ``zope.proxy``.

  In order to re-enable the wrapper behavior for older applications
  which cannot be changed, register the "traversalwrapper"
  ``ModelGraphTraverser`` as the traversal policy, rather than the
  default ``ModelGraphTraverser``. To use this feature, you will need
  to install the ``repoze.bfg.traversalwrapper`` package (an add-on
  package, available at
  http://svn.repoze.org/repoze.bfg.traversalwrapper) Then change your
  application's ``configure.zcml`` to include the following stanza:

    <adapter
        factory="repoze.bfg.traversalwrapper.ModelGraphTraverser"
        provides="repoze.bfg.interfaces.ITraverserFactory"
        for="*"
        />

   When this ITraverserFactory is used instead of the default, no
   object in the graph (even the root object) must supply a
   ``__name__`` or ``__parent__`` attribute.  Even if subobjects
   returned from the root *do* implement the ILocation interface,
   these will still be wrapped in proxies that override the object's
   "real" ``__parent__`` and ``__name__`` attributes.

   See also changes to the "Models" chapter of the documentation (in
   the "Location-Aware Model Instances") section.

1 files changed, 0 insertions, 54 deletions

diff --git a/repoze/bfg/traversal.py b/repoze/bfg/traversal.py
index 901368bba..f4f64484f 100644
--- a/repoze/bfg/traversal.py
+++ b/repoze/bfg/traversal.py
@@ -9,7 +9,6 @@ from zope.deferredimport import deprecated
 from zope.interface import classProvides
 from zope.interface import implements
 
-from repoze.bfg.location import LocationProxy
 from repoze.bfg.location import lineage
 
 from repoze.bfg.lru import lru_cache
@@ -421,59 +420,6 @@ class ModelGraphTraverser(object):
 
         return ob, '', [], traversed, vroot, vroot_path
 
-class WrappingModelGraphTraverser(ModelGraphTraverser):
-    """ A model graph traverser that should be used (for convenience)
-    when no object in the graph supplies either a ``__name__`` or a
-    ``__parent__`` attribute (ie. no object 'provides ILocation') ."""
-    classProvides(ITraverserFactory)
-    implements(ITraverser)
-    def __init__(self, root):
-        self.root = root
-
-    def __call__(self, environ, _marker=_marker):
-        try:
-            path = environ['PATH_INFO']
-        except KeyError:
-            path = '/'
-        try:
-            vroot_path_string = environ[VH_ROOT_KEY]
-        except KeyError:
-            vroot_path = []
-            vroot_idx = 0
-        else:
-            vroot_path = list(traversal_path(vroot_path_string))
-            vroot_idx = len(vroot_path)
-            path = vroot_path_string + path
-
-        path = list(traversal_path(path))
-
-        traversed = []
-
-        ob = vroot = LocationProxy(self.root)
-        name = ''
-
-        i = 1
-
-        for segment in path:
-            if segment[:2] =='@@':
-                return ob, segment[2:], path[i:], traversed, vroot, vroot_path
-            try:
-                getitem = ob.__getitem__
-            except AttributeError:
-                return ob, segment, path[i:], traversed, vroot, vroot_path
-            try:
-                next = getitem(segment)
-            except KeyError:
-                return ob, segment, path[i:], traversed, vroot, vroot_path
-            next = LocationProxy(next, ob, segment)
-            if vroot_idx == i-1:
-                vroot = ob
-            traversed.append(segment)
-            ob = next
-            i += 1
-
-        return ob, '', [], traversed, vroot, vroot_path
-
 class TraversalContextURL(object):
     """ The IContextURL adapter used to generate URLs for a context
     object obtained via graph traversal"""