def traversePathElement(obj,
name,
further_path,
default=_marker,
traversable=None,
request=None):
"""Traverse a single step 'name' relative to the given object.
'name' must be a string. '.' and '..' are treated specially, as well as
names starting with '@' or '+'. Otherwise 'name' will be treated as a
single path segment.
'further_path' is a list of names still to be traversed. This method
is allowed to change the contents of 'further_path'.
You can explicitly pass in an ITraversable as the 'traversable'
argument. If you do not, the given object will be adapted to ITraversable.
'request' is passed in when traversing from presentation code. This
allows paths like @@foo to work.
Raises LocationError if path cannot be found and 'default' was
not provided.
"""
__traceback_info__ = (obj, name)
if name == '.':
return obj
if name == '..':
return obj.__parent__
if name and name[:1] in '@+':
ns, nm = nsParse(name)
if ns:
return namespaceLookup(ns, nm, obj, request)
else:
nm = name
if traversable is None:
traversable = ITraversable(obj, None)
if traversable is None:
raise LocationError('No traversable adapter found', obj)
try:
return traversable.traverse(nm, further_path)
except UnicodeEncodeError:
# If we're on Python 2, and nm was a unicode string, and the traversable
# tried to do an attribute lookup, the nm would have been encoded using the
# system encoding (usually ascii). Failure to encode means invalid attribute
# name.
if default is not _marker:
return default
raise LocationError(obj, name)
except LocationError:
if default is not _marker:
return default
raise
def traverse(self, name, ignored):
view = zope.component.queryMultiAdapter((self.context, self.request),
name=name)
if view is None:
raise LocationError(self.context, name)
return view
def set_skin(self):
'''Set the correct skin on the request
The request that leads to an email going out may be processed on a different
site to the site that the request is for. To handle this the ``emailSkin``
property of the ``DivisionConfiguration`` is looked up. If no skin is
specified then the defaults are used.
:raises: zope.component.interfaces.ComponentLookupError: if the skin cannot
be found.
.. seealso:: This code was based on the
:class:`zope.traversal.namespace.skin` class.'''
# 1. Look up the skin name
name = self.skin_name
if not(name):
return # Sorry, Dijkstra
# 2. Look up the interface with the skin-name
try:
skin = getUtility(IBrowserSkinType, name)
except ComponentLookupError:
raise LocationError("emailSkin %s" % name)
# 3. Apply the skin to the interface using
# zope.publisher.skinnable.applySkin
applySkin(self.request, skin)
def get_object_in_tree(obj, target):
"""Look up an object within the content tree of a particular mirror (or master).
Target may either be a mirror or a mirrored folder (master).
Object may be any content object. If part of the content tree referred to by the
requested target, it is returned as contained within the corresponding location. The
object may be passed as seen at any of its mirror (or master) locations.
If the object isn't part of the tree, LocationError is raised. If it looks like the
object is part of the tree but isn't found in the catalog as associated with this
target, IndexError is raised.
"""
if not getattr(target, MIRRORS_ATTR, None):
raise ValueError(f'{target} is neither a mirror nor a mirrored folder.')
info = placeless_mirror_info(obj)
if not (
aq_base(info.master) is aq_base(target)
or info.mirror_ids
and IUUID(target) in info.mirror_ids
):
raise LocationError(f'{obj} is not located in the content tree of {target}.')
return _get_object_in_tree(obj, target)
def traverse(self, name, ignored):
self.request.shiftNameToApplication()
try:
skin = zope.component.getUtility(IBrowserSkinType, name)
except ComponentLookupError:
raise LocationError("++skin++%s" % name)
applySkin(self.request, skin)
return self.context
def traverse(self, name, ignored):
utility = zope.component.queryUtility(IEtcNamespace, name)
if utility is not None:
return utility
ob = self.context
if name not in ('site',):
raise LocationError(ob, name)
method_name = "getSiteManager"
method = getattr(ob, method_name, None)
if method is None:
raise LocationError(ob, name)
try:
return method()
except ComponentLookupError:
raise LocationError(ob, name)
def __call__(self, context, location):
key = stringKey(context)
for container in self.containers:
if IQueryContent.providedBy(container):
parent = container.__parent__
container = container.query(location)
if parent is not None:
container.__parent__ = parent
if key in container:
return LocationProxy(context, container, key)
raise LocationError(key)
def traverse(self, name, furtherPath):
subject = self._subject
__traceback_info__ = (subject, name, furtherPath)
attr = getattr(subject, name, _marker)
if attr is not _marker:
return attr
if hasattr(subject, '__getitem__'):
try:
return subject[name]
except (KeyError, TypeError):
pass
raise LocationError(subject, name)
def traverse(self, name, ignored):
ttool = getToolByName(self.context, 'portal_types')
ti = ttool.getTypeInfo(name)
if ti is not None:
add_view = queryMultiAdapter((self.context, self.request, ti),
name=ti.factory)
if add_view is None:
add_view = queryMultiAdapter((self.context, self.request, ti))
if add_view is not None:
add_view.__name__ = ti.factory
return add_view.__of__(self.context)
raise LocationError(self.context, name)
def traverse(self, name, ignored):
ttool = getUtility(ITypesTool)
ti = ttool.getTypeInfo(name)
if ti is not None:
add_view = queryMultiAdapter((self.context, self.request, ti),
name=ti.factory)
if add_view is None:
add_view = queryMultiAdapter((self.context, self.request, ti))
if add_view is not None:
add_view.__name__ = ti.factory
return add_view
raise LocationError(self.context, name)
def traverse(self, name, furtherPath):
subject = self._subject
__traceback_info__ = (subject, name, furtherPath)
try:
attr = getattr(subject, name, _marker)
except UnicodeEncodeError:
# If we're on Python 2, and name was a unicode string the
# name would have been encoded using the system encoding
# (usually ascii). Failure to encode means invalid
# attribute name.
attr = _marker
if attr is not _marker:
return attr
if hasattr(subject, '__getitem__'):
try:
return subject[name]
except (KeyError, TypeError):
pass
raise LocationError(subject, name)
def traverse(self, name, ignored):
"""Adapter traversal adapter
This adapter provides traversal to named adapters registered
to provide IPathAdapter.
To demonstrate this, we need to register some adapters:
>>> def adapter1(ob):
... return 1
>>> def adapter2(ob):
... return 2
>>> zope.component.provideAdapter(
... adapter1, (None,), IPathAdapter, 'a1')
>>> zope.component.provideAdapter(
... adapter2, (None,), IPathAdapter, 'a2')
Now, with these adapters in place, we can use the traversal adapter:
>>> ob = object()
>>> adapter = adapter(ob)
>>> adapter.traverse('a1', ())
1
>>> adapter.traverse('a2', ())
2
>>> try:
... adapter.traverse('bob', ())
... except LocationError:
... print('no adapter')
no adapter
Clean up:
>>> from zope.testing.cleanup import cleanUp
>>> cleanUp()
"""
try:
return zope.component.getAdapter(self.context, IPathAdapter, name)
except ComponentLookupError:
raise LocationError(self.context, name)
def traverse(self, name, ignored):
ttool = api.portal.get_tool("portal_types")
fti = ttool.getTypeInfo(name)
if fti is None:
raise LocationError(self.context, name)
return ImmediateAddView(self.context, self.request, fti)
def traverse(self, nm, further_path):
self.called = True
raise LocationError()
def namespaceLookup(ns, name, object, request=None):
"""
Lookup a value from a namespace.
We look up a value by getting an adapter from the *object* to
:class:`~zope.traversing.interfaces.ITraversable` named *ns*. If
the *request* is passed, we get a multi-adapter on the *object*
and *request* (sometimes this is called a "view").
Let's start with adapter-based traversal::
>>> class I(zope.interface.Interface):
... 'Test interface'
>>> @zope.interface.implementer(I)
... class C(object):
... pass
We'll register a simple testing adapter::
>>> class Adapter(object):
... def __init__(self, context):
... self.context = context
... def traverse(self, name, remaining):
... return name+'42'
>>> zope.component.provideAdapter(Adapter, (I,), ITraversable, 'foo')
Then given an object, we can traverse it with a
namespace-qualified name::
>>> namespaceLookup('foo', 'bar', C())
'bar42'
If we give an invalid namespace, we'll get a not found error::
>>> namespaceLookup('fiz', 'bar', C()) # doctest: +ELLIPSIS
Traceback (most recent call last):
...
LocationError: (<zope.traversing.namespace.C object at 0x...>, '++fiz++bar')
We'll get the same thing if we provide a request::
>>> from zope.publisher.browser import TestRequest
>>> request = TestRequest()
>>> namespaceLookup('foo', 'bar', C(), request) # doctest: +ELLIPSIS
Traceback (most recent call last):
...
LocationError: (<zope.traversing.namespace.C object at 0x...>, '++foo++bar')
We need to provide a view::
>>> class View(object):
... def __init__(self, context, request):
... pass
... def traverse(self, name, remaining):
... return name+'fromview'
>>> from zope.traversing.testing import browserView
>>> browserView(I, 'foo', View, providing=ITraversable)
>>> namespaceLookup('foo', 'bar', C(), request)
'barfromview'
Clean up::
>>> from zope.testing.cleanup import cleanUp
>>> cleanUp()
"""
if request is not None:
traverser = zope.component.queryMultiAdapter((object, request),
ITraversable, ns)
else:
traverser = zope.component.queryAdapter(object, ITraversable, ns)
if traverser is None:
raise LocationError(object, "++%s++%s" % (ns, name))
return traverser.traverse(name, ())
def traversePathElement(obj,
name,
further_path,
default=_marker,
traversable=None,
request=None):
"""
Traverse a single step *name* relative to the given object.
This is used to implement
:meth:`zope.traversing.interfaces.ITraversalAPI.traverseName`.
:param str name: must be a string. '.' and '..' are treated
specially, as well as names starting with '@' or '+'.
Otherwise *name* will be treated as a single path segment.
:param list further_path: a list of names still to be traversed.
This method is allowed to change the contents of
*further_path*.
:keyword ITraversable traversable: You can explicitly pass in
an `~zope.traversing.interfaces.ITraversable` as the
*traversable* argument. If you do not, the given object will
be adapted to ``ITraversable``.
:keyword request: assed in when traversing from presentation
code. This allows paths like ``@@foo`` to work.
:raises zope.location.interfaces.LocationError: if *path* cannot
be found and '*default* was not provided.
"""
__traceback_info__ = (obj, name)
if name == '.':
return obj
if name == '..':
return obj.__parent__
if name and name[:1] in '@+':
ns, nm = nsParse(name)
if ns:
return namespaceLookup(ns, nm, obj, request)
else:
nm = name
if traversable is None:
traversable = ITraversable(obj, None)
if traversable is None:
raise LocationError('No traversable adapter found', obj)
try:
return traversable.traverse(nm, further_path)
except UnicodeEncodeError:
# If we're on Python 2, and nm was a unicode string, and the traversable
# tried to do an attribute lookup, the nm would have been encoded using the
# system encoding (usually ascii). Failure to encode means invalid attribute
# name.
if default is not _marker:
return default
raise LocationError(obj, name)
except LocationError:
if default is not _marker:
return default
raise
def traverse(self, name, remaining):
"""
Acquire a name
Let's set up some example data::
>>> @zope.interface.implementer(ITraversable)
... class testcontent(object):
... def traverse(self, name, remaining):
... v = getattr(self, name, None)
... if v is None:
... raise LocationError(self, name)
... return v
... def __repr__(self):
... return 'splat'
>>> ob = testcontent()
>>> ob.a = 1
>>> ob.__parent__ = testcontent()
>>> ob.__parent__.b = 2
>>> ob.__parent__.__parent__ = testcontent()
>>> ob.__parent__.__parent__.c = 3
And acquire some names:
>>> adapter = acquire(ob)
>>> adapter.traverse('a', ())
1
>>> adapter.traverse('b', ())
2
>>> adapter.traverse('c', ())
3
>>> adapter.traverse('d', ())
Traceback (most recent call last):
...
LocationError: (splat, 'd')
"""
i = 0
ob = self.context
while i < 200:
i += 1
traversable = ITraversable(ob, None)
if traversable is not None:
try:
# ??? what do we do if the path gets bigger?
path = []
next = traversable.traverse(name, path)
if path:
continue
except LocationError:
pass
else:
return next
ob = getattr(ob, '__parent__', None)
if ob is None:
raise LocationError(self.context, name)
raise ExcessiveDepth(self.context, name)
def getResource(context, name, request):
resource = queryResource(context, name, request)
if resource is None:
raise LocationError(context, name)
return resource
def traverse(self, name, furtherPath):
getattr(self, u'\u2019', None)
# The above actually works on Python 3
raise LocationError()
