ftw.builder 2.0.0

会话

BuilderSession为多个构建器保留配置。它由BUILDER_LAYER设置和销毁，可以通过set_builder_session_factory配置或替换为自定义会话。

def functional_session_factory():
    sess = BuilderSession()
    sess.auto_commit = True
    return sess

from ftw.builder.session import BuilderSession
from ftw.builder.testing import BUILDER_LAYER
from ftw.builder.testing import functional_session_factory
from ftw.builder.testing import set_builder_session_factory
from plone.app.testing import FunctionalTesting
from plone.app.testing import IntegrationTesting
from plone.app.testing import PLONE_FIXTURE
from plone.app.testing import PloneSandboxLayer


class MyPackageLayer(PloneSandboxLayer):
    defaultBases = (PLONE_FIXTURE, BUILDER_LAYER)

MY_PACKAGE_FIXTURE = MyPackageLayer()

MY_PACKAGE_INTEGRATION_TESTING = IntegrationTesting(
    bases=(MY_PACKAGE_FIXTURE, ),
    name="MyPackage:Integration")

MY_PACKAGE_FUNCTIONAL_TESTING = FunctionalTesting(
    bases=(MY_PACKAGE_FIXTURE,
           set_builder_session_factory(functional_session_factory)),
    name="MyPackage:Integration")

Plone对象构建器

创建Plone对象（Archetypes或Dexterity）时，有一些用于设置基本选项的方法。

• within(container) - 告诉构建器在哪里创建对象

• titled(title) - 命名对象

• having(field=value) - 设置对象上任何字段的值

• in_state(review_state) - 将对象设置为工作流配置的任何审阅状态

• providing(interface1, interface2, ...) - 允许对象提供接口

• with_property(name, value, value_type='string') - 设置属性

默认构建器

ftw.builder自带一些用于默认Plone内容类型的构建器，但理念是可以轻松地为您的类型创建自己的构建器或扩展现有构建器。

内置构建器包括：

• folder - 创建文件夹

• page（或document）- 创建页面（别名文档）

• file - 创建文件

• image - 创建图像

• 集合（或主题） - 创建一个集合

• 链接 - 创建一个链接

有两种构建实现，一种是（Plone < 5）实现，另一种是< Dexterity>（Plone >= 5）实现。当使用与Plone 4时，您可能想将构建器切换到< Dexterity>

from ftw.builder.content import at_content_builders_registered
from ftw.builder.content import dx_content_builders_registered
from ftw.builder.content import register_at_content_builders
from ftw.builder.content import register_dx_content_builders


# permanently
register_dx_content_builders(force=True)

# temporary
with dx_content_builders_registered():
    # do stuff

file1 = create(Builder('file')
               .with_dummy_content())

file2 = create(Builder('file')
               .attach_file_containing('File content', name='filename.pdf')

image1 = create(Builder('image')
               .with_dummy_content())

john = create(Builder('user'))
john.getId() == "john.doe"
john.getProperty('fullname') == "Doe John"
john.getProperty('email') == "john@doe.com"
john.getRoles() == ['Member', 'Authenticated']

folder = create(Builder('folder'))
hugo = create(Builder('user')
              .named('Hugo', 'Boss')
              .with_roles('Contributor')
              .with_roles('Editor', on=folder))

hugo.getId() == 'hugo.boss'
hugo.getProperty('fullname') == 'Boss Hugo'
hugo.getProperty('email') == 'hugo@boss.com'
hugo.getRoles() == ['Contributor', 'Authenticated']
hugo.getRolesInContext(folder) == ['Contributor', 'Authenticated', 'Editor']

folder = create(Builder('folder'))
user = create(Builder('user'))
group = create(Builder('group')
               .titled('Administrators')
               .with_roles('Site Administrator')
               .with_roles('Editor', on=folder)
               .with_members(user))

创建新构建器

想法是您为您的应用程序创建自己的构建器。这可能是创建单个Plone对象（Archetypes或Dexterity）的构建器，或者使用其他构建器创建一组对象的构建器。

class PersonBuilder(object):

    def __init__(self, session):
        self.session = session
        self.children_names = []
        self.arguments = {}

    def of_age(self):
        self.arguments['age'] = 18
        return self

    def with_children(self, children_names):
        self.children_names = children_names
        return self

    def having(self, **kwargs):
        self.arguments.update(kwargs)
        return self

    def create(self, **kwargs):
        person = Person(
            self.arguments.get('name'),
            self.arguments.get('age'))

        for name in self.children_names:
            person.add_child(
                create(Builder('person').having(name=name, age=5))
            )

        return person

builder_registry.register('person', PersonBuilder)

from ftw.builder.archetypes import ArchetypesBuilder
from ftw.builder import builder_registry

class NewsBuilder(ArchetypesBuilder):
    portal_type = 'News Item'

    def containing(self, text):
        self.arguments['text'] = text
        return self

builder_registry.register('news', NewsBuilder)

from ftw.builder.dexterity import DexterityBuilder
from ftw.builder import builder_registry

class DocumentBuilder(DexterityBuilder):
    portal_type = 'dexterity.document'

    def with_dummy_content(self):
        self.arguments["file"] = NamedBlobFile(data='Test data', filename='test.doc')
        return self

class MyBuilder(ArchetypesBuilder):

    def before_create(self):
        super(NewsBuilder, self).before_create()
        do_something()

    def after_create(self):
        do_something()
        super(NewsBuilder, self).after_create()

builder_registry.register('file', CustomFileBuilder, force=True)

在创建时向前移动冻结时钟

使用可以冻结时间。

在冻结时间并创建多个对象时，它们都将具有相同的创建日期。这可能会导致排序顺序不一致。

为了解决这个问题，提供了一个，每次创建对象时都会将时钟向前移动。这意味着我们有不同的、一致的创作日期。

使用示例

from datetime import datetime
from ftw.builder import Builder
from ftw.builder import ticking_creator
from ftw.testing import freeze

with freeze(datetime(2010, 1, 1)) as clock:
    create = ticking_creator(clock, days=1)
    self.assertEquals(DateTime(2010, 1, 1),
                      create(Builder('folder')).created())
    self.assertEquals(DateTime(2010, 1, 2),
                      create(Builder('folder')).created())
    self.assertEquals(DateTime(2010, 1, 3),
                      create(Builder('folder')).created())

全局安装ticking creator很方便，这样如果构建器使用另一个构建器创建对象，它也会为嵌套构建器调用计时。这可以通过使用ticking creator作为上下文管理器来实现

from datetime import datetime
from ftw.builder import Builder
from ftw.builder import create
from ftw.builder import ticking_creator
from ftw.testing import freeze

with freeze(datetime(2010, 1, 1)) as clock:
    with ticking_creator(clock, days=1):
        self.assertEquals(DateTime(2010, 1, 1),
                          create(Builder('folder')).created())
        self.assertEquals(DateTime(2010, 1, 2),
                          create(Builder('folder')).created())
        self.assertEquals(DateTime(2010, 1, 3),
                          create(Builder('folder')).created())

Python包构建器

Python包构建器在文件系统上构建Python包。

• 创建setup.py

• 支持命名空间包

• 构建egg-info

• 按需创建configure.zcml

示例

>>> import tempfile
>>> tempdir = tempfile.mkdtemp()

>>> package = create(Builder('python package')
...                  .at_path(tempdir)
...                  .named('my.package')
...
...                  .with_root_directory('docs')
...                  .with_root_file('docs/HISTORY.txt', 'CHANGELOG...')
...                  .with_file('resources/print.css', 'body {}', makedirs=True)
...
...                  .with_subpackage(Builder('subpackage')
...                                   .named('browser')))
>>>
>>> with package.imported() as module:
...     print module
...
<module 'my.package' from '...../tmpcAZhM2/my/package/__init__.py'>

还可以创建/加载ZCML，您只需要一个堆叠的配置上下文。Plone的测试层提供配置上下文，但请注意，组件注册表不是隔离的。您可能想使用隔离组件注册表。

package = create(
    Builder('python package')
    .named('the.package')
    .at_path(self.layer['temp_directory'])

    .with_subpackage(
        Builder('subpackage')
        .named('browser')

        .with_file('hello_world.pt', '"Hello World"')
        .with_zcml_node('browser:page',
                        **{'name': 'hello-world.json',
                           'template': 'hello_world.pt',
                           'permission': 'zope2.View',
                           'for': '*'})))

with package.zcml_loaded(self.layer['configurationContext']):
    self.assertEqual('"Hello World"',
                     self.layer['portal'].restrictedTraverse('hello-world.json')())

通用设置配置文件构建器

“通用设置配置文件”构建器帮助在Python包内构建配置文件

create(Builder('python package')
       .named('the.package')
       .at_path(self.layer['temp_directory'])

       .with_profile(Builder('genericsetup profile')
                     .with_fs_version('3109')
                     .with_dependencies('collective.foo:default')
                     .with_file('types/MyType.xml', '<object></object>',
                                makedirs=True)))

Plone升级步骤构建器

为包构建通用设置升级步骤

create(Builder('python package')
       .named('the.package')
       .at_path(self.layer['temp_directory'])

       .with_profile(Builder('genericsetup profile')
                     .with_upgrade(Builder('plone upgrade step')
                                   .upgrading('1000', '1001')
                                   .titled('Add some actions...')
                                   .with_description('Some details...'))))

ZCML文件构建器

ZCML构建器构建ZCML文件

create(Builder('zcml')
       .at_path('/path/to/my/package/configure.zcml')
       .with_i18n_domain('my.package')

       .include('.browser')
       .include('Products.GenericSetup', file='meta.zcml')
       .include(file='profiles.zcml')

       .with_node('i18n:registerTranslations', directory='locales'))

组件构建器

附带一些Plone部件的构建器，但想法是您可以轻松地为您的部件或扩展现有的构建器创建自己的构建器。

示例

from ftw.builder import builder_registry
from ftw.builder.portlets import PlonePortletBuilder
from my.package.portlets import my_portlet

class MyPortletBuilder(PlonePortletBuilder):
    assignment_class = my_portlet.Assignment

builder_registry.register('my portlet', MyPortletBuilder)

内置构建器包括：

• 静态部件 - 创建一个静态部件

• 导航部件 - 创建一个导航部件