From a7a6d7568546dcc88d836653cce8e69916f1e442 Mon Sep 17 00:00:00 2001 From: Chris McDonough Date: Fri, 1 May 2009 08:02:55 +0000 Subject: - 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: 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. --- repoze/bfg/traversal.py | 54 ------------------------------------------------- 1 file changed, 54 deletions(-) (limited to 'repoze/bfg/traversal.py') 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""" -- cgit v1.2.3