five.intid 2.0.0

简介

使Zope环境中使用zope.intid成为可能。这包括依赖于它的其他包，如zope.keyreference

源代码

贡献者请参阅文档 Plone核心开发流程

源代码位于托管在Github的Plone代码存储库。

用法

首先，确保ofs实用程序提供了接口

>>> from Products.Five.tests.testing.simplecontent import (
...   manage_addSimpleContent)

>>> from zope.intid.interfaces import IIntIds
>>> from five.intid import site
>>> import five.intid.tests as tests
>>> from zope.interface.verify import verifyObject
>>> from zope.component import getAllUtilitiesRegisteredFor
>>> from zope.component.hooks import setSite
>>> tests.setUp(self.app)

在实用程序之前添加的内容将不会被注册（除非明确调用）。我们现在将设置一些供以后使用

>>> manage_addSimpleContent(self.folder, 'mycont1', "My Content")
>>> content1 = self.folder.mycont1

five.intid.site为添加、获取和删除IntId实用程序提供了便利函数：add_intid、get_intid、del_intid。

您可以在特定位置安装实用程序

>>> site.add_intids(self.folder)
>>> folder_intids = site.get_intids(self.folder)
>>> verifyObject(IIntIds, folder_intids)
True

您可以让add_intids找到站点根目录，并在那里安装。它将在任何地方都可用

>>> site.add_intids(self.folder, findroot=True)
>>> root_intids = site.get_intids(self.app)
>>> root_intids
<...IntIds ...>
>>> folder_intids is root_intids
False

最后，执行删除操作

>>> site.del_intids(self.folder, findroot=True)
>>> site.get_intids(self.app)
Traceback (most recent call last):
...
ComponentLookupError: (<InterfaceClass ....IIntIds>, '')

在我们查看intid事件之前，我们需要设置遍历钩子。一旦完成，当我们请求所有注册的Intids时，我们将从测试文件夹中获取实用程序

>>> setSite(self.folder)
>>> tuple(getAllUtilitiesRegisteredFor(IIntIds))
(<...IntIds ...>,)

当我们添加内容时，将触发事件以添加对象的键引用（目前，我们的内容和实用程序都已注册）

>>> manage_addSimpleContent(self.folder, 'mycont2', "My Content")
>>> content2 = self.folder.mycont2
>>> intid = site.get_intids(self.folder)
>>> len(intid.items()) == 1
True

如果将现有内容传递给intid实用程序，则会引发keyerror

>>> intid.getId(content1)
Traceback (most recent call last):
...
IntIdMissingError: <SimpleContent at /test_folder_1_/mycont1>

我们可以调用键引用并获取对象

>>> intid.items()[0][1]()
<SimpleContent at /test_folder_1_/mycont2>

我们可以像这样从实用程序中获取对象的intid

>>> ob_id = intid.getId(content2)

然后可以像这样获取对象

>>> intid.getObject(ob_id)
<SimpleContent at /test_folder_1_/mycont2>

这些对象在检索时被获取封装

>>> from Acquisition import IAcquirer
>>> IAcquirer.providedBy(intid.getObject(ob_id))
True

我们甚至可以通过解析它的intid将未封装的对象转换为封装对象，即使它是未封装的，intid工具也应该可以正常工作

>>> from Acquisition import aq_base
>>> resolved = intid.getObject(intid.getId(aq_base(content2)))
>>> IAcquirer.providedBy(resolved)
True
>>> unwrapped = aq_base(intid)
>>> unwrapped.getObject(ob_id) == resolved
True
>>> unwrapped.getId(content2) == ob_id
True

当对象被添加或删除时，订阅者将其添加到intid工具，并触发一个事件（zope.intid.interfaces.IIntIdAddedEvent，zope.intid.interfaces.IIntIdRemovedEvent分别）。

five.intid将这些事件连接起来作为对象事件重新分发。测试通过连接一个简单的订阅者来验证intid对象事件是否被触发（这些事件对于目录任务很有用）。

>>> tests.NOTIFIED[0]
'<SimpleContent at mycont2> <...IntIdAddedEvent object at ...'

注册和注销对象不会触发这些事件

>>> tests.NOTIFIED[0] = "No change"
>>> uid = intid.register(content1)
>>> intid.getObject(uid)
<SimpleContent at /test_folder_1_/mycont1>

>>> tests.NOTIFIED[0]
'No change'

>>> intid.unregister(content1)
>>> intid.getObject(uid)
Traceback (most recent call last):
...
ObjectMissingError: ...

>>> tests.NOTIFIED[0]
'No change'

重命名对象不应该破坏对象的重新封装

>>> self.setRoles(['Manager'])
>>> folder.mycont2.meta_type = 'Folder' # We need a metatype to move
>>> folder.manage_renameObject('mycont2','mycont_new')
>>> moved = intid.getObject(ob_id)
>>> moved
<SimpleContent at /test_folder_1_/mycont_new>
>>> [x.path for x in intid.ids]
['/test_folder_1_/mycont_new']

移动它也不应该

>>> from OFS.Folder import manage_addFolder
>>> manage_addFolder(self.folder, 'folder2', "folder 2")
>>> cut = folder.manage_cutObjects(['mycont_new'])
>>> ignore = folder.folder2.manage_pasteObjects(cut)
>>> moved = intid.getObject(ob_id)
>>> moved
<SimpleContent at /test_folder_1_/folder2/mycont_new>
>>> moved.aq_parent
<Folder at /test_folder_1_/folder2>

让我们把它移回来

>>> cut = folder.folder2.manage_cutObjects(['mycont_new'])
>>> ignore = folder.manage_pasteObjects(cut)
>>> folder.manage_renameObject('mycont_new','mycont2')

我们可以创建一个没有获取的对象，这样我们就可以将其添加到intid中

>>> from five.intid.tests import DemoPersistent
>>> demo1 = DemoPersistent()
>>> demo1.__parent__ = self.app
>>> from zope.event import notify
>>> from zope.lifecycleevent import ObjectAddedEvent
>>> notify(ObjectAddedEvent(demo1))
>>> nowrappid = intid.getId(demo1)
>>> demo1 == intid.getObject(nowrappid)
True

现在是查看键引用的好时机，这是这个系统的核心部分。

Zope2中的键引用

键引用是IKeyReference返回的可哈希对象。产生的哈希值是对象所引用的内容的唯一标识符（另一个zodb对象，sqlobject的钩子等）。

在intid中进行对象检索是通过调用键引用来实现的。由于获取的原因，这种实现与zope.intid略有不同。

IKeyReference返回的工厂必须持久化，这要求我们特别注意对获取封装对象的引用，以及通常在zope2中期望返回获取封装对象。

>>> ref = intid.refs[ob_id]
>>> ref
<five.intid.keyreference.KeyReferenceToPersistent object at ...>

引用对象持有对未封装目标对象的引用以及一个属性来获取应用程序（同样，也不是封装的，即）

>>> ref.object
<SimpleContent at mycont2>

>>> type(ref.object)
<class 'Products.Five.tests.testing.simplecontent.SimpleContent'>

>>> ref.root
<Application at >

调用引用对象（或封装的属性wrapped_object）将返回一个获取封装的对象封装对象（按照创建时的方式封装）

>>> ref.wrapped_object == ref()
True

>>> ref()
<SimpleContent at /test_folder_1_/mycont2>

>>> IAcquirer.providedBy(ref())
True

解析机制将尽力在获取链的末尾结束当前请求，就像在正常情况下一样

>>> ref.wrapped_object.aq_chain[-1]
<ZPublisher.BaseRequest.RequestContainer object at ...>

哈希计算是数据库名称和对象的持久对象ID（oid）的组合

>>> ref.dbname
'unnamed'

>>> hash((ref.dbname, ref.object._p_oid)) == hash(ref)
True

>>> tests.tearDown()

获取循环

five.intid在aq_parent和__parent__中检测获取链中的循环。

设置循环

>>> import Acquisition
>>> class Acq(Acquisition.Acquirer): pass
>>> foo = Acq()
>>> foo.bar = Acq()
>>> foo.__parent__ = foo.bar

在一个具有获取循环的对象上查找根将引发错误

>>> from five.intid import site
>>> site.get_root(foo.bar)
Traceback (most recent call last):
...
AttributeError: __parent__ loop found

在一个具有获取循环的对象上查找连接将简单地返回None

>>> from five.intid import keyreference
>>> keyreference.connectionOfPersistent(foo.bar)

不可引用

一些对象实现了IPersistent但从未实际持久化，或包含对这种对象的引用。具体来说，CMFCore目录视图包含从未持久化的FSObjects，以及包含对这种对象引用的DirectoryViewSurrogates。由于FSObjects从未实际持久化，five.intid假设它可以添加

对于这样的对象，不可引用模块提供无操作订阅者和适配器，以从five.intid处理中排除此类对象。

>>> from zope import interface, component
>>> from five.intid import unreferenceable

>>> from Products.CMFCore import FSPythonScript
>>> foo = FSPythonScript.FSPythonScript('foo', __file__)
>>> self.app._setObject('foo', foo)
'foo'

>>> keyref = unreferenceable.KeyReferenceNever(self.app.foo)
Traceback (most recent call last):
...
NotYet
>>> foo in self.app._p_jar._registered_objects
False

没有id的对象

尝试为一个尚未正确添加到容器中的对象获取键引用是可能的，但该对象有一个路径。在这种情况下，我们将引发NotYet异常，让调用代码根据需要延迟，因为键引用否则会解析错误的对象（确切地说，是父对象）从错误的路径。

>>> from zope.keyreference.interfaces import IKeyReference
>>> from five.intid.keyreference import KeyReferenceToPersistent
>>> from zope.component import provideAdapter
>>> provideAdapter(KeyReferenceToPersistent)

>>> from OFS.SimpleItem import SimpleItem
>>> item = SimpleItem('').__of__(self.folder)
>>> '/'.join(item.getPhysicalPath())
'/test_folder_1_/'

>>> IKeyReference(item)
Traceback (most recent call last):
...
NotYet: <SimpleItem at >

如果对象被放置在循环包含中，IKeyReference(object)应该不能适配，让调用代码根据需要延迟。此外，任何对象访问都会被击败并引发RuntimeError。

这种情况发生在具有Plone4网站five.intid启用（five.intid.site.add_intids(site)）并尝试通过@@manage-portlets添加小部件时。plone.portlet.static.static.Assignment似乎在某个时间有一个循环路径。

创建具有循环包含的项目

>>> item_b = SimpleItem().__of__(self.folder)
>>> item_b.id = "b"
>>> item_c = SimpleItem().__of__(item_b)
>>> item_c.id = "c"
>>> item_b.__parent__ = item_c

>>> assert item_b.__parent__.__parent__ == item_b

>>> item_b.id
Traceback (most recent call last):
...
RuntimeError: Recursion detected in acquisition wrapper

>>> try:
...     IKeyReference(item_c)
... except RuntimeError as exc:
...     # expected with zope.interface 5.1+:
...     # Recursion detected in acquisition wrapper
...     print("Error")
... except TypeError as exc:
...     # before zope.interface 5.1 it was not able to lets non-AttributeErrors
...     # propagate from descriptors which resultet in a Could Not Adapt TypeError
...     print("Error")
Error

变更日志