z3c.menu.ready2go 2.0

全局菜单

让我们创建一些菜单并将它们注册为视图管理器

>>> from zope.viewlet.interfaces import IViewlet
>>> from zope.viewlet import manager
>>> from z3c.menu.ready2go import interfaces
>>> from z3c.menu.ready2go import IGlobalMenu
>>> from z3c.menu.ready2go import ISiteMenu
>>> from z3c.menu.ready2go import IContextMenu
>>> from z3c.menu.ready2go import IAddMenu
>>> from z3c.menu.ready2go.manager import MenuManager

我们配置我们的菜单项作为视图管理器。这通常是通过viewletManager ZCML指令完成的

>>> GlobalMenu = manager.ViewletManager('left', IGlobalMenu,
...     bases=(MenuManager,))

>>> SiteMenu = manager.ViewletManager('left', ISiteMenu,
...     bases=(MenuManager,))

>>> ContextMenu = manager.ViewletManager('left', IContextMenu,
...     bases=(MenuManager,))

>>> AddMenu = manager.ViewletManager('left', IAddMenu,
...     bases=(MenuManager,))

我们的菜单管理器实现了IMenuManager

>>> interfaces.IMenuManager.implementedBy(GlobalMenu)
True

>>> interfaces.IMenuManager.implementedBy(SiteMenu)
True

>>> interfaces.IMenuManager.implementedBy(ContextMenu)
True

>>> interfaces.IMenuManager.implementedBy(AddMenu)
True

我们还需要我们的检查适配器，它可以检查菜单项是否可用和/或选中

>>> from z3c.menu.ready2go import checker
>>> zope.component.provideAdapter(checker.GlobalSelectedChecker)
>>> zope.component.provideAdapter(checker.SiteSelectedChecker)
>>> zope.component.provideAdapter(checker.ContextSelectedChecker)

现在我们必须定义一个站点和一个上下文

>>> import zope.interface
>>> from zope.container import contained, btree
>>> from zope.location.interfaces import IContained
>>> from zope.component.interfaces import IPossibleSite
>>> from zope.site.site import SiteManagerContainer
>>> from zope.site.site import LocalSiteManager

>>> @zope.interface.implementer(IPossibleSite)
... class Site(btree.BTreeContainer, SiteManagerContainer):
...     def __init__(self):
...         super(Site, self).__init__()
...         self.setSiteManager(LocalSiteManager(self))

>>> @zope.interface.implementer(IContained)
... class Content(contained.Contained):
...     pass

>>> root['site'] = Site()
>>> site = root['site']

现在我们需要将站点对象设置为site。这通常由遍历器完成，但我们在这里使用hooks助手来完成，因为我们实际上并没有在发布器/遍历器中遍历到站点。

>>> from zope.component import hooks
>>> hooks.setSite(site)

>>> site['content'] = Content()
>>> content = site['content']

>>> from zope.publisher.browser import TestRequest
>>> request = TestRequest()

我们还需要一个了解其父级的视图。

>>> @zope.interface.implementer(IBrowserView)
... class View(contained.Contained):
...
...     def __init__(self, context, request):
...         self.__parent__ = context
...         self.context = context
...         self.request = request

>>> view = View(content, request)

我们的菜单可以适应上下文、请求和视图。有关此模式的更多信息，请参阅zope.viewlet中的IViewletManager。如果我们渲染它们，将返回一个空字符串。这意味着菜单没有找到要渲染的菜单项。

>>> globalMenu = GlobalMenu(content, request, view)
>>> globalMenu.update()
>>> globalMenu.render()
''

>>> siteMenu = SiteMenu(content, request, view)
>>> siteMenu.update()
>>> siteMenu.render()
''

>>> contextMenu = ContextMenu(content, request, view)
>>> contextMenu.update()
>>> contextMenu.render()
''

>>> addMenu = AddMenu(content, request, view)
>>> addMenu.update()
>>> addMenu.render()
''

全局菜单项

现在我们为我们的IGlobalMenu注册一个上下文菜单项。

>>> from z3c.menu.ready2go.item import GlobalMenuItem
>>> class MyGlobalMenuItem(GlobalMenuItem):
...
...     viewName = 'root.html'

现在我们需要为我们的菜单项设置安全检查器。

>>> from zope.security.checker import NamesChecker, defineChecker
>>> viewletChecker = NamesChecker(('update', 'render'))
>>> defineChecker(MyGlobalMenuItem, viewletChecker)

然后我们为IGlobalMenu配置我们的菜单项。这通常是通过viewlet ZCML指令完成的。

>>> zope.component.provideAdapter(
...     MyGlobalMenuItem,
...     (zope.interface.Interface, IDefaultBrowserLayer,
...     IBrowserView, IGlobalMenu),
...     IViewlet, name='My Global')

现在让我们更新菜单管理器，看看这个管理器现在是否包含菜单项。

>>> globalMenu.update()
>>> myGlobalMenuItem = globalMenu.viewlets[0]
>>> myGlobalMenuItem
<MyGlobalMenuItem 'My Global'>

现在让我们渲染全局菜单管理器，你可以看到菜单项已被渲染。

>>> print(globalMenu.render())
<li>
  <a href="http://127.0.0.1/root.html"><span>My Global</span></a>
</li>

站点菜单项

现在我们为我们的ISiteMenu注册一个上下文菜单项。

>>> import zope.component
>>> from zope.publisher.interfaces.browser import IDefaultBrowserLayer

>>> from z3c.menu.ready2go.item import SiteMenuItem
>>> class MySiteMenuItem(SiteMenuItem):
...
...     viewName = 'site.html'

现在我们需要为我们的菜单项设置安全检查器。

>>> from zope.security.checker import NamesChecker, defineChecker
>>> viewletChecker = NamesChecker(('update', 'render'))
>>> defineChecker(MySiteMenuItem, viewletChecker)

然后我们为ISiteMenu配置我们的菜单项。这通常是通过viewlet ZCML指令完成的。

>>> zope.component.provideAdapter(
...     MySiteMenuItem,
...     (zope.interface.Interface, IDefaultBrowserLayer,
...     IBrowserView, ISiteMenu),
...     IViewlet, name='My Site')

现在让我们再次渲染站点菜单。你可以看到我们有一个菜单项，并且URL指向我们的站点。

>>> siteMenu.update()
>>> print(siteMenu.render())
<li>
  <a href="http://127.0.0.1/site/site.html"><span>My Site</span></a>
</li>

上下文菜单项

现在我们为我们的IContextMenu注册一个上下文菜单项。

>>> import zope.component
>>> from zope.publisher.interfaces.browser import IDefaultBrowserLayer

>>> from z3c.menu.ready2go.item import ContextMenuItem
>>> class MyContextMenuItem(ContextMenuItem):
...     viewName = 'context.html'
...     weight = 1

现在我们需要为我们的菜单项设置安全检查器。

>>> from zope.security.checker import NamesChecker, defineChecker
>>> viewletChecker = NamesChecker(('update', 'render'))
>>> defineChecker(MyContextMenuItem, viewletChecker)

然后我们为IContextMenu配置我们的菜单项。这通常是通过viewlet ZCML指令完成的。

>>> zope.component.provideAdapter(
...     MyContextMenuItem,
...     (zope.interface.Interface, IDefaultBrowserLayer,
...     IBrowserView, IContextMenu),
...     IViewlet, name='My Context')

现在让我们再次渲染上下文菜单。你可以看到我们有一个菜单项。另一个重要点是，此类上下文菜单项实现的URL指向视图的上下文。

>>> contextMenu.update()
>>> print(contextMenu.render())
<li>
  <a href="http://127.0.0.1/site/content/context.html"><span>My Context</span></a>
</li>

让我们将视图__name__设置为context.html。这将表明视图提供了与我们的上下文菜单需要渲染的所选名称相同的名称。

>>> view.__name__ = 'context.html'

现在再次尝试，看看上下文菜单项是否以选中状态渲染。

>>> contextMenu.update()
>>> print(contextMenu.render())
<li class="selected">
  <a href="http://127.0.0.1/site/content/context.html"><span>My Context</span></a>
</li>

此外，让我们检查即使我们提供了@@context.html表单中的viewName，菜单项是否也标记为选中。

>>> MyContextMenuItem.viewName = '@@context.html'
>>> contextMenu.update()
>>> print(contextMenu.render())
<li class="selected">
  <a href="http://127.0.0.1/site/content/@@context.html"><span>My Context</span></a>
</li>

好的，将viewName改回context.html，以便进行进一步测试。

>>> MyContextMenuItem.viewName = 'context.html'

现在添加第二个上下文菜单项，并检查我们是否可以使用通常为空字符串的cssInActive参数。

>>> class InActiveMenuItem(ContextMenuItem):
...     viewName = 'inActive.html'
...     cssInActive = 'inActive'
...     weight = 2

>>> defineChecker(InActiveMenuItem, viewletChecker)

>>> zope.component.provideAdapter(
...     InActiveMenuItem,
...     (zope.interface.Interface, IDefaultBrowserLayer,
...     IBrowserView, IContextMenu),
...     IViewlet, name='In Active')

现在更新并再次渲染。

>>> contextMenu.update()
>>> print(contextMenu.render())
<li class="selected">
  <a href="http://127.0.0.1/site/content/context.html"><span>My Context</span></a>
</li>
<li class="inActive">
  <a href="http://127.0.0.1/site/content/inActive.html"><span>In Active</span></a>
</li>

添加菜单

添加菜单可用于为每个上下文提供任何类型的添加表单的链接。这允许我们提供独立的添加表单链接，不管使用的是哪个表单框架。现在让我们定义一个简单的指向添加表单URL的AddMenuItem。注意；添加表单及其URL在此测试中不存在。这也意味着如果配置了添加菜单项，不能保证存在表单。

>>> from z3c.menu.ready2go.item import AddMenuItem
>>> class MyAddMenuItem(AddMenuItem):
...
...     viewName = 'addSomething.html'

现在我们需要为我们的菜单项设置安全检查器。

>>> from zope.security.checker import NamesChecker, defineChecker
>>> viewletChecker = NamesChecker(('update', 'render'))
>>> defineChecker(MyAddMenuItem, viewletChecker)

然后我们为IAddMenu配置我们的菜单项。这通常是通过viewlet ZCML指令完成的。

>>> zope.component.provideAdapter(
...     MyAddMenuItem,
...     (zope.interface.Interface, IDefaultBrowserLayer,
...     IBrowserView, IAddMenu),
...     IViewlet, name='My AddMenu')

现在我们可以更新并渲染我们的添加菜单。

>>> addMenu.update()
>>> print(addMenu.render())
<li>
  <a href="http://127.0.0.1/site/content/addSomething.html"><span>My AddMenu</span></a>
</li>

菜单组

全局和站点菜单项是分组菜单项。这意味着如果选择了上下文菜单项，则应该将此类菜单项渲染为选中状态。这反映了菜单层次结构。让我们展示如何解决这个不太简单的问题。我们提供了一个ISelectedChecker适配器，可以决定菜单是否渲染为选中状态。这非常有用，因为通常菜单被注册后，我们添加视图，不能更改菜单项实现。让我们看看这样的适配器如何处理现有的菜单、上下文和视图设置，并更改选中渲染。我们为我们的站点菜单项注册一个选中检查器。

>>> zope.component.provideAdapter(checker.TrueSelectedChecker,
...     (IContained, IDefaultBrowserLayer, None, ISiteMenu, MySiteMenuItem),
...     interfaces.ISelectedChecker)

现在我们可以再次渲染站点菜单。注意，我们的上下文仍然是示例内容对象。

>>> siteMenu.update()
>>> print(siteMenu.render())
<li class="selected">
  <a href="http://127.0.0.1/site/site.html"><span>My Site</span></a>
</li>

这表明站点菜单是一个分组菜单，内容对象的上下文菜单项也被选中。

>>> contextMenu.update()
>>> print(contextMenu.render())
<li class="selected">
  <a href="http://127.0.0.1/site/content/context.html"><span>My Context</span></a>
</li>
<li class="inActive">
  <a href="http://127.0.0.1/site/content/inActive.html"><span>In Active</span></a>
</li>

EmptyMenuManager

有一个空的菜单管理器，可以用来覆盖现有的菜单管理器。

>>> from z3c.menu.ready2go.manager import EmptyMenuManager
>>> emptyMenu = EmptyMenuManager(None, None, None)

我们的空菜单管理器实现了IMenuManager。

>>> interfaces.IMenuManager.providedBy(emptyMenu)
True

这个空菜单管理器在渲染时始终返回空字符串。

>>> emptyMenu.update()
>>> emptyMenu.render()
''

特殊用途案例

由于Zope的内部机制，我们有一些特殊的用例。其中一个重要部分是，我们的菜单高度依赖于上下文及其到Zope应用程序根的__parent__链。这不是Zope默认设置所支持的。一部分是集成不良的应用程序控制部分，它伪造了一个根对象，这个根对象不知道从ZODB的真实根（例如应用程序根）的真实子对象。现在我们将向您展示，如果得到这样一个伪造的根，我们的菜单默认不会显示任何项目，这会破坏我们的菜单结构。

让我们定义一个不知道任何__parent__的对象。

>>> nirvana = Content()
>>> nirvanaView = View(nirvana, request)

现在我们可以检查在将无父对象的环境上下文更新并渲染菜单后，菜单会发生什么。您可以看到，全局菜单不包含任何菜单项。这是因为全局菜单项试图通过上下文到根的__parent__链遍历以找到根，而我们不支持我们的无父对象中的任何父对象。

>>> globalMenu = GlobalMenu(nirvana, request, nirvanaView)
>>> globalMenu.update()
>>> globalMenu.render()
''

由于无父对象，SiteMenu也不包含任何菜单项。

>>> siteMenu = SiteMenu(nirvana, request, nirvanaView)
>>> siteMenu.update()
>>> siteMenu.render()
''

>>> contextMenu = ContextMenu(nirvana, request, nirvanaView)
>>> contextMenu.update()
>>> contextMenu.render()
''

>>> addMenu = AddMenu(nirvana, request, nirvanaView)
>>> addMenu.update()
>>> addMenu.render()
''

2.0 (2023-02-07)

• 支持Python 3.8、3.9、3.10、3.11。

• 放弃对Python 2.7、3.5、3.6的支持。

• 放弃对已弃用的python setup.py test的支持。

1.1.0 (2018-10-09)

• 支持Python 3.7。

• 删除所有弃用警告。

1.0.0 (2017-04-17)

• 将Python支持锁定在2.7、3.5、3.6和PyPy上。

1.0.0a1 (2013-03-03)

• 添加了对Python 3.3的支持。

• 由于zope.testbrowser尚未移植，将zope.testbrowser测试更改为WebTest。

• 将已弃用的zope.interface.implements使用替换为等效的zope.interface.implementer装饰器。

• 放弃对Python 2.4和2.5的支持。

0.8.0 (2010-07-12)

• 将zope.app.pagetemplate测试依赖项替换为zope.browserpage，因为所需的metaconfigure.registerType最近已移至那里，而没有留下BBB导入。

0.7.1 (2009-12-26)

• 通过声明z3c MessageFactory本地，取消对z3c.i18n的依赖。

• 使用python doctest模块代替已弃用的zope.testing.doctestunit。

0.7.0 (2009-11-30)

• 调整依赖项和导入，以反映zope包的变化。

0.6.0 (2009-02-07)

• 将zope.app.component替换为zope.site。

• 将zope.app.container替换为zope.container。

• zope.app.pagetemplate仅是一个测试依赖项。

0.5.1 (2009-01-04)

• 添加了对以@@开头的viewNames的支持。现在它们被ViewNameSelectedChecker正确处理。

• 在Pypi主页上添加了文档。

0.5.0 (2008-04-11)

• bugfix：修复了cssInActive的使用。这已被破坏，并导致不使用cssInActive CSS类参数。

• 增加了更多测试，现在覆盖率达到100%

• 使ISiteMenu仅对ISite有效，而不是对IContainmentRoot有效

• 使用z3c.template模式使模板可插拔

• 初始发布