Ejemplo n.º 1
0
    def _register(name, category, schema, klass, title, description):
        ConfigletClass = configlettype.ConfigletType(
            str(name), schema, klass, title, description)
        interface.classImplements(ConfigletClass, schema)

        # register behavior for configlet
        bname = 'memphis.controlpanel-%s'%name

        # behavior
        bfactory = configlet.BehaviorFactory(name, bname)
        storage.registerBehavior(
            bname, schema, bfactory, schema = IConfigletData,
            title=title, description=description, configContext=None)

        # set additional attributes
        ConfigletClass.__category__ = category

        # configlet instance
        inst = ConfigletClass()

        # register configlet as utility
        config.registerUtility(inst, schema, '')

        # register configlet in control panel
        getUtility(IControlPanel).addConfiglet(inst)
        inst.__behavior__ = storage.getBehavior(schema)
Ejemplo n.º 2
0
def check_testcase_implements_trial_reporter(done=[]):
    if done:
        return
    from zope.interface import classImplements
    from twisted.trial.itrial import IReporter
    classImplements(TestCaseFunction, IReporter)
    done.append(1)
Ejemplo n.º 3
0
    def __call__(aspect, origin=None, *args, **kw):
        if kw.get('pdb'):
            import pdb;pdb.set_trace()

        # if called without positional arg, return partially applied
        # aspect
        if origin is None:
            if not kw:
                raise NeedKw
            return Partial(aspect, **kw)

        workbench = Workbench(origin, **kw)
        Instructions(aspect)(workbench)

            #raise AspectCollision(instr.name, aspect, target)

            # in case of instances functions need to be bound
            # if not x_is_class and (type(instr) is types.FunctionType):
            #     instr = instr.__get__(x)

        # build a new class, with the same name and bases as the
        # target class, but a new dictionary with the aspect applied.
        cls = workbench.type(workbench.name, workbench.baseclasses,
                             workbench.dct)
        if ZOPE_INTERFACE_AVAILABLE:
            classImplements(cls, *tuple(implementedBy(aspect)))
        if isclass(origin):
            if type(cls) is AspectMeta and kw:
                return Partial(cls, **kw)
            return cls
        return cls()
Ejemplo n.º 4
0
def patch():
    CMFCatalogTool.unindexObject = unindexObjectCMF
    setattr(CMFCatalogTool, '__old_unindexObject', original_unindexObjectCMF)

    CatalogMultiplex.unindexObject = unindexObject
    setattr(CatalogMultiplex, '__old_unindexObject', original_unindexObject)

    DefaultOrdering.moveObjectsByDelta = moveObjectsByDelta
    setattr(DefaultOrdering, '__old_moveObjectsByDelta',
            original_moveObjectsByDelta)

    PloneSite.moveObjectsByDelta = PloneSite_moveObjectsByDelta
    setattr(PloneSite, '__old_moveObjectsByDelta',
            original_PloneSite_moveObjectsByDelta)

    prefix = '__old_'
    for patch in patches:
        klass = patch.kls
        if not IElasticSearchCatalog.implementedBy(klass):
            patched[klass] = {}
            for name, method in patch.method_map.items():
                classImplements(klass, IElasticSearchCatalog)
                old = getattr(klass, name, method)
                patched[klass][name] = old
                setattr(klass, prefix + name, old)
                setattr(klass, name, method)
                info('patched %s', str(getattr(klass, name)))
Ejemplo n.º 5
0
    def execute(self, renderer, config, layer, name,
                macro, target, template, configuration, **kw):
        """Register a renderer.
        """        
        provides = (name == DEFAULT and interfaces.IStructuredDefaultRenderer
                    or interfaces.IStructuredRenderer)

        renderer.__view_name__ = name
        renderer.__renderer_macro__ = macro
        templates = renderer.module_info.getAnnotation(
            'grok.templates', None
            )

        if configuration is not None:
            classImplements(renderer, interfaces.IConfigurableRenderer)
        
        if templates is not None:
            config.action(
                discriminator=None,
                callable=self.checkTemplates,               
                args=(templates, renderer.module_info, renderer)
                )

        for context in target:
            adapts = (context, layer)
            config.action(
                discriminator=('adapter', adapts, provides, name),
                callable=zope.component.provideAdapter,
                args=(renderer, adapts, provides, name),
                )
        return True
Ejemplo n.º 6
0
def Portlet(name, class_=None, title='', description='',
            template=None, schema=None, **kw):
    cdict = {}
    cdict.update(kw)
    cdict['__name__'] = name
    cdict['title'] = title
    cdict['description'] = description

    if template:
        cdict['template'] = ViewPageTemplateFile(template)

    if class_ is not None:
        class_name = 'Portlet<%s:%s>'%(class_.__name__, name)
    else:
        class_name = 'Portlet<%s>'%name

    if class_ is None:
        bases = (PortletBase,)
    else:
        bases = (class_, PortletBase)

    PortletClass = type(str(class_name), bases, cdict)

    if schema is not None:
        for f_id in getFields(schema):
            if not hasattr(PortletClass, f_id):
                setattr(PortletClass, f_id, ConfigurationProperty(schema[f_id]))

        PortletClass.__schema__ = schema
        interface.classImplements(PortletClass, schema)

    return PortletClass
Ejemplo n.º 7
0
def create_interface_mock(interface_class):
    '''given a Zope Interface class
    return a Mock sub class
    that implements the given Zope interface class.

    Mock objects created from this InterfaceMock will
    have Attributes and Methods required in the Interface
    will not have Attributes or Methods that are not specified
    '''

    # the init method, automatically spec the interface methods
    def init(self, *args, **kwargs):
        Mock.__init__(self, spec=interface_class.names(),
                      *args, **kwargs)

    # subclass named '<interface class name>Mock'
    name = interface_class.__name__ + "Mock"

    # create the class object and provide the init method
    klass = types.TypeType(name, (Mock, ), {"__init__": init})

    # the new class should implement the interface
    classImplements(klass, interface_class)

    return klass
Ejemplo n.º 8
0
    def prepareContent(self):
        
        classImplements(ATNewsItem, ITestTaggable)
        provideAdapter(TestExtender, name=u"archetypes.schemaextender.test.adapter")

        self.portal.invokeFactory('News Item', 'taggable-news')
        self.taggable_news = getattr(self.portal, 'taggable-news')
 def testNoViewOnClassicClassException(self):
     from zope.interface import Interface
     from types import ClassType
     class ClassicError:
         __metaclass__ = ClassType
     class IClassicError(Interface):
         pass
     classImplements(ClassicError, IClassicError)
     support.setDefaultViewName(IClassicError, 'name',
                                self.presentation_type)
     view_text = 'You made a classic error ;-)'
     def _view(obj, request):
         return lambda: view_text
     component.provideAdapter(
         _view, (ClassicError, self.presentation_type), Interface,
         name='name')
     try:
         raise ClassicError
     except:
         pass
     self.publication.handleException(
         self.object, self.request, sys.exc_info(), retry_allowed=False)
     # check we don't get the view we registered
     self.failIf(''.join(self.request.response._result) == view_text)
     # check we do actually get something
     self.failIf(''.join(self.request.response._result) == '')
Ejemplo n.º 10
0
def PortletManager(
    name, class_=None, provides=(),
    title='', description='', schema=None, portlettype=IPortlet, **kw):

    # configuration schema
    if schema is None:
        schema = IPortletManagerConfiguration

    cdict = {}
    cdict.update(kw)
    cdict['__name__'] = name
    cdict['__schema__'] = schema
    cdict['title'] = title
    cdict['description'] = description
    cdict['portlettype'] = portlettype

    class_name = 'PortletManager<%s>'%name

    if class_ is None:
        bases = (PortletManagerBase,)
    else:
        bases = (class_, PortletManagerBase)

    ManagerClass = type(str(class_name), bases, cdict)

    if provides:
        interface.classImplements(ManagerClass, *provides)

    for f_id in getFields(schema):
        if not hasattr(ManagerClass, f_id):
            setattr(ManagerClass, f_id, ConfigurationProperty(schema[f_id]))

    interface.classImplements(ManagerClass, schema)

    return ManagerClass
Ejemplo n.º 11
0
 def updateSchema(self):
     sch = getUtility(ISchemaType, self.__context__.oid)
     sch.spec = self.schema
     sch.Type.__schema__ = self.schema
     interface.classImplements(sch.Type, self.schema)
     
     self.model = unicode(supermodel.serializeSchema(self.schema))
Ejemplo n.º 12
0
def findViewletManager(self, name):
    managerObj = queryMultiAdapter((self.context, self.request, self), IViewletManager, name)
    if not managerObj:
        # Here's where we go totally off the deep end...
        # Since we can't find this viewlet manager with the basic (self.context, self.request, self)
        # multiadapter lookup, this must be some sort of custom manager, registered to other interfaces.
        # In order to find it, we need to do a bit of reverse engineering...

        # Since Plone's generic setup process for viewlets constrains us to one viewlet manager / name,
        # we're going to assume that the adapter with this name, and a provided interface that is or extends IViewletManger
        # is the one we're looking for.
        # So, start with a search of the adapter registry...

        reg = [reg for reg in getGlobalSiteManager().registeredAdapters() if reg.name == name][0]

        # So far, I think we're stuck with context and request being the first two interfaces.
        providedClasses = [self.context, self.request]

        # Now, we take a look at the required interfaces...
        # And create some dummy classes that implement them.
        for iface in reg.required[2:]:
            tempClass = classobj("dummy", (object,), {})
            classImplements(tempClass, iface)
            providedClasses.append(tempClass())

        # Now just do a basic multiadapter lookup using our new objects providing the correct interfaces...
        managerObj = queryMultiAdapter(tuple(providedClasses), reg.provided, name)
    return managerObj
Ejemplo n.º 13
0
    def afterSetUp(self):
        """ After setup
        """
        setSite(self.portal)

        provideAdapter(ThemeTaggableMerged)
        provideAdapter(AttributeAnnotations, provides=IAnnotations,
                       adapts=[IThemeTaggable])
        classImplements(ATNewsItem, IThemeTaggable)
        self.setRoles('Manager')

        wftool = self.portal.portal_workflow
        # create a swedish themecentre, an english feed folder and
        # a swedish feed
        self.portal.invokeFactory('Folder', id='svthemecentre')
        obj = self.portal.svthemecentre
        # turn the folder into a themecentre by calling the promote view
        # and setting a theme tag
        obj.unrestrictedTraverse('@@promote2ThemeCentre')()
        IThemeCentreSchema(obj).tags = 'climate'
        obj.setLanguage('sv')
        obj.intro.setLanguage('sv')
        wftool.doActionFor(obj, 'publish')
        obj.reindexObject()

        self.portal.invokeFactory('Folder', id='feedfolder')
        self.portal.feedfolder.setLanguage('en')
        self.portal.feedfolder.reindexObject()

        self.portal.portal_languages.addSupportedLanguage('sv')
        self.basic_auth = '%s:%s' % (default_user, default_password)
Ejemplo n.º 14
0
 def afterSetUp(self):
     classImplements(ATDocument, IOrderable)
     # have to delete previously created content manually
     # because of test isolation problems
     if 'test' in self.portal:
         del self.portal['test']
         transaction.commit()
Ejemplo n.º 15
0
    def test_builtins(self):
        # Setup

        intspec = implementedBy(int)
        olddeclared = intspec.declared

        classImplements(int, I1)
        class myint(int):
            implements(I2)

        x = 42
        self.assertEqual([i.getName() for i in providedBy(x)],
                         ['I1'])

        x = myint(42)
        directlyProvides(x, I3)
        self.assertEqual([i.getName() for i in providedBy(x)],
                         ['I3', 'I2', 'I1'])

        # cleanup
        intspec.declared = olddeclared
        classImplements(int)

        x = 42
        self.assertEqual([i.getName() for i in providedBy(x)],
                         [])
Ejemplo n.º 16
0
def apply_customization_workflow(name, ti):
    """Apply customizations, features as per configuration from a workflow. 
    Must (currently) be run after db setup.
    """
    # support to infer/get the domain class from the type key
    from bungeni.models import domain, orm
    def get_domain_kls(name):
        """Infer the target domain kls from the type key, following underscore 
        naming to camel case convention.
        """
        return getattr(domain, naming.camel(name))
    
    # get the domain class, and associate with type
    kls = get_domain_kls(name)
    ti.domain_model = kls
    
    # We "mark" the domain class with IWorkflowed, to be able to 
    # register/lookup adapters generically on this single interface.
    classImplements(kls, IWorkflowed)
    
    # dynamic features from workflow
    wf = ti.workflow
    # decorate/modify domain/schema/mapping as needed
    kls = domain.configurable_domain(kls, wf)
    orm.configurable_mappings(kls)
    
    # !+ following should be part of the domain.feature_audit(kls) logic
    if wf.has_feature("audit"):
        # create/set module-level dedicated auditor singleton for auditable kls
        bungeni.core.audit.set_auditor(kls)
Ejemplo n.º 17
0
def load_contenttype(_context, contenttype):
    conf = contenttype['config']
    klass = contenttype['klass']
    if 'schema' in conf:
        classImplements(klass, conf['schema'])

    Factory = resolve_dotted_name(
        conf.get('factory', 'guillotina.content.ResourceFactory')
    )

    factory = Factory(
        klass,
        title='',
        description='',
        type_name=conf['type_name'],
        schema=resolve_dotted_name(conf.get('schema', Interface)),
        behaviors=[resolve_dotted_name(b) for b in conf.get('behaviors', []) or ()],
        add_permission=conf.get('add_permission') or DEFAULT_ADD_PERMISSION,
        allowed_types=conf.get('allowed_types', None)
    )
    component.utility(
        _context,
        provides=IResourceFactory,
        component=factory,
        name=conf['type_name'],
    )
 def infoClass(self, data, ds=False):
     '''build info class'''
     if ds == True:  self.infoclass = type(self.infoname,(RRDDataSourceInfo,),data)
     else:  self.infoclass = type(self.infoname,(ComponentInfo,),data)
     classImplements(self.infoclass,self.interfaceclass)
     self.info_path = "%s.info.%s" % (self.zenpackname, self.infoname)
     self.addClassData(self.infoname, self.info_path, self.infoclass)
Ejemplo n.º 19
0
def viewletManager(
    _context, name, permission,
    for_=Interface, layer=interfaces.IFlourishLayer, view=interfaces.IPageBase,
    provides=interfaces.IViewletManager,
    class_=ViewletManager, template=None,
    update='update', render='render',
    allowed_interface=(), allowed_attributes=(),
    **kwargs):

    bases = (class_, )
    if not interfaces.IViewletManager.implementedBy(class_):
        bases = bases + (ViewletManager, )
    class_ = type(class_.__name__, bases, {})

    allowed_interface = (tuple(allowed_interface) +
                         (interfaces.IViewletManager, ))

    if not provides.implementedBy(class_):
        classImplements(class_, provides)

    contentDirective(
        _context, name, permission,
        for_=for_, layer=layer, view=view,
        class_=class_, template=template,
        update=update, render=render,
        allowed_interface=allowed_interface,
        allowed_attributes=allowed_attributes,
        **kwargs)
Ejemplo n.º 20
0
def ViewModelType(name, class_=None, provides=(),
                  title='', description='', schema=None, **kw):

    cdict = {}
    cdict.update(kw)
    cdict['__id__'] = name
    cdict['__name__'] = name
    cdict['__schema__'] = schema
    cdict['__title__'] = title
    cdict['__description__'] = description

    class_name = 'ViewModel<%s>'%name

    if class_ is None:
        bases = (ViewModel,)
    else:
        bases = (class_, ViewModel)

    ViewModelClass = type(str(class_name), bases, cdict)

    if provides:
        interface.classImplements(ViewModelClass, *provides)

    if schema is not None:
        for f_id in getFields(schema):
            if not hasattr(ViewModelClass, f_id) and \
                   f_id not in ('context', 'request'):
                setattr(ViewModelClass, f_id, StorageProperty(schema[f_id]))

        interface.classImplements(ViewModelClass, schema)

    return ViewModelClass
 def testExceptionSideEffects(self):
     from zope.publisher.interfaces import IExceptionSideEffects
     @implementer(IExceptionSideEffects)
     class SideEffects(object):
         def __init__(self, exception):
             self.exception = exception
         def __call__(self, obj, request, exc_info):
             self.obj = obj
             self.request = request
             self.exception_type = exc_info[0]
             self.exception_from_info = exc_info[1]
     class SideEffectsFactory:
         def __call__(self, exception):
             self.adapter = SideEffects(exception)
             return self.adapter
     factory = SideEffectsFactory()
     from ZODB.POSException import ConflictError
     from zope.interface import Interface
     class IConflictError(Interface):
         pass
     classImplements(ConflictError, IConflictError)
     component.provideAdapter(factory, (IConflictError,),
                              IExceptionSideEffects)
     exception = ConflictError()
     try:
         raise exception
     except:
         self.publication.handleException(
             self.object, self.request, sys.exc_info(), retry_allowed=False)
     adapter = factory.adapter
     self.assertEqual(exception, adapter.exception)
     self.assertEqual(exception, adapter.exception_from_info)
     self.assertEqual(ConflictError, adapter.exception_type)
     self.assertEqual(self.object, adapter.obj)
     self.assertEqual(self.request, adapter.request)
Ejemplo n.º 22
0
def new_custom_domain_model(type_key, domain_interface, archetype_key):
    domain_model_name = naming.model_name(type_key)
    assert archetype_key, \
        "Custom descriptor %r does not specify an archetype" % (type_key)
    archetype = getattr(MODEL_MODULE, naming.model_name(archetype_key)) # AttributeError
    # !+ assert archetype constraints
    domain_model = type(domain_model_name,
        (archetype,),
        {
            "__module__": MODEL_MODULE.__name__,
            "extended_properties": [],
        }
    )
    # apply domain_interface
    classImplements(domain_model, domain_interface)
    # set on MODEL_MODULE (register on type_info downstream)
    setattr(MODEL_MODULE, domain_model_name, domain_model)
    # db map custom domain class
    from sqlalchemy.orm import mapper
    mapper(domain_model, 
        inherits=archetype,
        polymorphic_on=utils.get_local_table(archetype).c.type,
        polymorphic_identity=type_key, #naming.polymorphic_identity(domain_model),
    )
    log.info("new_custom_domain_model [%s] %s.%s" % (
            type_key, MODEL_MODULE.__name__, domain_model_name))
    return domain_model
Ejemplo n.º 23
0
def feature_audit(kls):
    """Decorator for domain types to support "audit" feature.
    """
    interface.classImplements(kls, interfaces.IFeatureAudit)
    # If a domain class is explicitly defined, then it is assumed that all 
    # necessary setup is also taken care of. Typically, only the sub-classes
    # of an archetype (mapped to a same table) need dynamic creation/setup.
    def audit_cls_exists_for(auditable_cls):
        audit_cls_name = "%sAudit" % (auditable_cls.__name__)
        return bool(globals().get(audit_cls_name))
    if not audit_cls_exists_for(kls):
        # define {kls}Audit class
        feature_audit.CREATED_AUDIT_CLASS_FOR.add(kls)
        def base_audit_class(kls):
            """Identify what should be the BASE audit class for a 
            {kls}Audit class to inherit from, and return it.
            """
            # !+ may have a deeper inheritance
            # !+ other archetypes
            if kls is not Doc and issubclass(kls, Doc):
                return DocAudit
            return Audit
        audit_kls = base_audit_class(kls).auditFactory(kls)
        globals()[audit_kls.__name__] = audit_kls
    # !+ITER_TYPE_INFO remember decorated classes, for audit.set_auditor(kls), 
    # that is called quite early, and capi.iter_type_info() is not yet ready...
    feature_audit.DECORATED.add(kls)
    return kls
Ejemplo n.º 24
0
def generate_table_schema_interface(ti):
    '''!+DO_NOT_REORDER_USER_APPLIED_INTERFACES
    def get_domain_interfaces(domain_model):
        """Return the domain bases for an interface as well as a filtered 
        implements only list (base interfaces removed).
        
        Note that for 2nd level (mapped) domain classes i.e. those that inherit
        from another domain class e.g. Event(Doc), Office(Group), 
        OfficeMember(GroupMembership), an IIModelInterface-providing 
        I*TableSchema interface had already been created (for base class) and 
        assigned to the super class--and that interface will match as one of 
        the domain_base interfaces here.
        """
        domain_bases = []
        domain_implements = []
        for iface in interface.implementedBy(domain_model):
            if IIModelInterface.providedBy(iface):
                domain_bases.append(iface)
            else:
                domain_implements.append(iface)
        domain_bases = tuple(domain_bases) or (IAlchemistContent,)
        return domain_bases, domain_implements
    bases, implements = get_domain_interfaces(ti.domain_model)
    '''
    
    # derived_table_schema:
    # - ALWAYS dynamically generated
    # - directlyProvides IIModelInterface (by virtue of IAlchemistContent)
    type_key = naming.polymorphic_identity(ti.domain_model)
    # use the class's mapper select table as input for the transformation
    table_schema_interface_name = naming.table_schema_interface_name(type_key)
    domain_table = utils.get_local_table(ti.domain_model)
    
    derived_table_schema = transmute(
        domain_table,
        annotation=ti.descriptor_model,
        interface_name=table_schema_interface_name,
        __module__=INTERFACE_MODULE.__name__,
        #_generated_by="bungeni.alchemist.catalyst.generate_table_schema_interface"
        #bases=bases)
        bases=(IAlchemistContent,))
    
    # apply, register on type_info, set on module
    interface.classImplements(ti.domain_model, derived_table_schema)
    utils.inisetattr(ti, "derived_table_schema", derived_table_schema)
    setattr(INTERFACE_MODULE, table_schema_interface_name, derived_table_schema)
    log.info("generate_table_schema_interface: %s", derived_table_schema)
    
    # defensive sanity check - that derived_table_schema is precisely the FIRST
    # resolving IIModelInterface-providing interface implemented by domain_model
    # !+ this failing does not necessarily mean an incorrectness
    for iface in interface.implementedBy(ti.domain_model):
        if IIModelInterface.providedBy(iface):
            assert iface is derived_table_schema, (ti.domain_model, 
                iface, id(iface), 
                derived_table_schema, id(derived_table_schema))
            break
    
    '''!+DO_NOT_REORDER_USER_APPLIED_INTERFACES
Ejemplo n.º 25
0
 def _decorator(cls):
     missing = object()
     for interface in interfaces:
         classImplements(cls, interface)
         for name in interface:
             if getattr(cls, name, missing) is missing:
                 setattr(cls, name, Passthrough(name, context))
     return cls
Ejemplo n.º 26
0
    def setUp(self):
        classImplements(TranslationDomain, IAttributeAnnotatable)
        self.sm = PlacefulSetup.setUp(self, site=True)
        TestITranslationDomain.setUp(self)

        setup.addUtility(self.sm, "default", ITranslationDomain, self._domain)

        ztapi.provideUtility(IFactory, Factory(MessageCatalog), "zope.app.MessageCatalog")
Ejemplo n.º 27
0
def load_vocabulary(_context, vocabulary):
    conf = vocabulary['config']
    klass = vocabulary['klass']
    from guillotina.schema.vocabulary import getVocabularyRegistry
    vocabulary_registry = getVocabularyRegistry()
    from guillotina.schema.interfaces import ISource
    classImplements(klass, ISource)
    vocabulary_registry.register(conf['name'], klass)
Ejemplo n.º 28
0
 def setMappers(self):
     if not hasattr(self, 'metadata'):
         self.connect()
     classImplements(MetaData, IMetadata)
     notify(self.notifyInterface(self.metadata))
     if self.createAll:
         self.metadata.create_all(checkfirst=True)
     self.configuredMappers = True
Ejemplo n.º 29
0
def setUp(test=None):
    browserSetUp(test)
    setup.setUpCalendaring()

    from schooltool.app.overlay import CalendarOverlayInfo
    from schooltool.app.app import ShowTimetables
    provideAdapter(ShowTimetables)
    classImplements(CalendarOverlayInfo, IAttributeAnnotatable)
Ejemplo n.º 30
0
def feature_event(kls):
    """Decorator for domain types to support "event" feature.
    For Doc types (other than Event itself).
    """
    # domain.Event itself may NOT support events
    assert not interfaces.IEvent.implementedBy(kls)
    interface.classImplements(kls, interfaces.IFeatureEvent)
    return kls
Ejemplo n.º 31
0
 def afterSetUp(self):
     base.EasyFormTestCase.afterSetUp(self)
     self.folder.invokeFactory('EasyForm', 'ff1')
     self.ff1 = getattr(self.folder, 'ff1')
     self.ff1.title = u'ff1'
     self.ff1.checkAuthenticator = False  # no csrf protection
     actions = get_actions(self.ff1)
     actions['mailer'].recipient_email = u'*****@*****.**'
     set_actions(self.ff1, actions)
     self.mailhost = self.folder.MailHost
     self.mailhost._send = self.dummy_send
     classImplements(BaseRequest, IFormLayer)
Ejemplo n.º 32
0
    def testNotImplemented(self):
        class C(object):
            pass

        class I(Interface):
            pass

        self.assertRaises(DoesNotImplement, verifyClass, I, C)

        classImplements(C, I)

        verifyClass(I, C)
Ejemplo n.º 33
0
    def afterSetUp(self):
        base.EasyFormTestCase.afterSetUp(self)
        self.folder.invokeFactory('EasyForm', 'ff1')
        self.ff1 = getattr(self.folder, 'ff1')
        self.ff1.checkAuthenticator = False  # no csrf protection
        classImplements(BaseRequest, IFormLayer)
        from collective.easyform.validators import update_validators
        update_validators()

        request = self.app.REQUEST
        for i in FORM_DATA:
            request.form['form.widgets.{0}'.format(i)] = FORM_DATA[i]
    def test_ObjectSpecification(self):
        c = C()
        directlyProvides(c, I4)
        self.assertEqual([i.getName() for i in providedBy(c)],
                         ['I4', 'I31', 'I1', 'I2'])
        self.assertEqual([i.getName() for i in providedBy(c).flattened()],
                         ['I4', 'I31', 'I3', 'I1', 'I2', 'Interface'])
        self.assert_(I1 in providedBy(c))
        self.failIf(I3 in providedBy(c))
        self.assert_(providedBy(c).extends(I3))
        self.assert_(providedBy(c).extends(I31))
        self.failIf(providedBy(c).extends(I5))

        class COnly(A, B):
            implementsOnly(I31)

        class D(COnly):
            implements(I5)

        classImplements(D, I5)

        c = D()
        directlyProvides(c, I4)
        self.assertEqual([i.getName() for i in providedBy(c)],
                         ['I4', 'I5', 'I31'])
        self.assertEqual([i.getName() for i in providedBy(c).flattened()],
                         ['I4', 'I5', 'I31', 'I3', 'Interface'])
        self.failIf(I1 in providedBy(c))
        self.failIf(I3 in providedBy(c))
        self.assert_(providedBy(c).extends(I3))
        self.failIf(providedBy(c).extends(I1))
        self.assert_(providedBy(c).extends(I31))
        self.assert_(providedBy(c).extends(I5))

        class COnly(A, B):
            __implemented__ = I31

        class D(COnly):
            implements(I5)

        classImplements(D, I5)
        c = D()
        directlyProvides(c, I4)
        self.assertEqual([i.getName() for i in providedBy(c)],
                         ['I4', 'I5', 'I31'])
        self.assertEqual([i.getName() for i in providedBy(c).flattened()],
                         ['I4', 'I5', 'I31', 'I3', 'Interface'])
        self.failIf(I1 in providedBy(c))
        self.failIf(I3 in providedBy(c))
        self.assert_(providedBy(c).extends(I3))
        self.failIf(providedBy(c).extends(I1))
        self.assert_(providedBy(c).extends(I31))
        self.assert_(providedBy(c).extends(I5))
Ejemplo n.º 35
0
def apply_customization_workflow(name):
    """Apply customizations, features as per configuration from a workflow. 
    Must (currently) be run after db setup.
    """
    # support to infer/get the domain class from the workflow name
    def camel(name):
        """Convert an underscore-separated word to CamelCase.
        """
        return "".join([ s.capitalize() for s in name.split("_") ])
    from bungeni.models import domain, schema, orm
    def get_domain_kls(workflow_name):
        """Infer a workflow's target domain kls from the workflow file name, 
        following underscore naming to camel case convention; names that do 
        not follow the convention are custom handled, as per mapping below.
        """
        # !+ should state it explicitly as a param?
        # !+ problem with multiple types sharing same workflow e.g. 
        #    UserAddress, GroupAddress
        kls_name = camel(
            get_domain_kls.non_conventional.get(workflow_name, workflow_name))
        return getattr(domain, kls_name)
    # !+RENAME_TO_CONVENTION
    get_domain_kls.non_conventional = {
        "address": "address", # !+ use common base cls for User & Group addresses
        "agendaitem": "agenda_item",
        "attachedfile": "attached_file",
        "tableddocument": "tabled_document",
        "groupsitting": "group_sitting",
        "membership": "group_membership",
    }
    # get the domain class
    kls = get_domain_kls(name)
    
    # We "mark" the domain class with IWorkflowed, to be able to 
    # register/lookup adapters generically on this single interface.
    classImplements(kls, IWorkflowed)
    
    # dynamic features from workflow
    wf = get_workflow(name)
    def _apply_customization_workflow(kls):
        # decorate/modify domain/schema/mapping as needed
        kls = domain.configurable_domain(kls, wf)
        schema.configurable_schema(kls)
        orm.configurable_mappings(kls)
        # !+ ok to call set_auditor(kls) more than once?
        # !+ following should be part of the domain.auditable(kls) logic
        if wf.has_feature("audit"):
            # create/set module-level dedicated auditor singleton for auditable kls
            bungeni.core.audit.set_auditor(kls)
    
    if kls.__dynamic_features__:
        _apply_customization_workflow(kls)
Ejemplo n.º 36
0
def mark_error_retryable(error):
    """
    Mark an exception instance or type as retryable. If this exception
    is caught by ``pyramid_retry`` then it may retry the request.

    """
    if isinstance(error, Exception):
        alsoProvides(error, IRetryableError)
    elif inspect.isclass(error) and issubclass(error, Exception):
        classImplements(error, IRetryableError)
    else:
        raise ValueError(
            'only exception objects or types may be marked retryable')
Ejemplo n.º 37
0
def feature_address(kls, **params):
    """Decorator for domain types to support "address" feature.
    For User and Group types, means support for possibility to have addresses.
    """
    interface.classImplements(kls, interfaces.IFeatureAddress)
    if issubclass(kls, domain.Group):
        add_container_property_to_model(
            kls, "addresses", "bungeni.models.domain.GroupAddressContainer",
            "group_id")
    elif issubclass(kls, domain.User):
        add_container_property_to_model(
            kls, "addresses", "bungeni.models.domain.UserAddressContainer",
            "user_id")
Ejemplo n.º 38
0
    def test_class_doesnt_implement_but_classImplements_later(self):
        from zope.interface import Interface
        from zope.interface import classImplements

        class ICurrent(Interface):
            pass

        class Current(object):
            pass

        classImplements(Current, ICurrent)

        self._callFUT(ICurrent, Current)
Ejemplo n.º 39
0
    def test_implementedBy(self):
        class I2(I1): pass

        class C1(Odd):
            pass
        classImplements(C1, I2)

        class C2(C1):
            pass
        classImplements(C2, I3)

        self.assertEqual([i.getName() for i in implementedBy(C2)],
                         ['I3', 'I2'])
Ejemplo n.º 40
0
def auditable(kls):
    """Decorator for auditable domain types, to collect in one place all
    that is needed for a domain type to be auditale.
    """
    # assign interface (changes property added downstream)
    name = kls.__name__
    interface.classImplements(kls, interfaces.IAuditable)
    CUSTOM_DECORATED["auditable"].add(kls)
    # define TYPEChange class
    change_name = "%sChange" % (name)
    change_kls = ItemChanges.makeChangeFactory(change_name)
    globals()[change_name] = change_kls
    return kls
Ejemplo n.º 41
0
def generate_container_class(ti):
    """Generate a zope3 container class for a domain model.
    """
    type_key = naming.polymorphic_identity(ti.domain_model)
    container_name = naming.container_class_name(type_key)
    container_iname = naming.container_interface_name(type_key)
    base_interfaces = (IAlchemistContainer,)
    
    # logging variables
    msg = (ti.domain_model.__name__, CONTAINER_MODULE.__name__, container_name)
    
    # container class - if we already have one, exit                
    if getattr(CONTAINER_MODULE, container_name, None):
        log.info("generate_container_class [model=%s] found container %s.%s, skipping" % msg)
        ti.container_class = getattr(CONTAINER_MODULE, container_name)
        return
    
    container_class = type(container_name,
        (AlchemistContainer,),
        dict(_class=ti.domain_model, 
            __module__=CONTAINER_MODULE.__name__)
    )
    # set on CONTAINER_MODULE, register on type_info
    setattr(CONTAINER_MODULE, container_name, container_class)
    ti.container_class = container_class
    log.info("generate_container_class [model=%s] generated container %s.%s" % msg)
    
    # container interface - if we already have one, skip creation 
    # !+ should always be newly created?
    container_iface = getattr(INTERFACE_MODULE, container_iname, None)
    msg = (ti.domain_model.__name__, CONTAINER_MODULE.__name__, container_iname)
    if container_iface is not None:
        assert issubclass(container_iface, IAlchemistContainer)
        log.info("generate_container_class [model=%s] skipping container interface %s.%s for" % msg)
    else:
        container_iface = interface.interface.InterfaceClass(
            container_iname,
            bases=base_interfaces,
            __module__=INTERFACE_MODULE.__name__
        )
        # set on INTERFACE_MODULE, register on type_info
        setattr(INTERFACE_MODULE, container_iname, container_iface)
        ti.container_interface = container_iface
        log.info("generate_container_class [model=%s] generated container interface %s.%s" % msg)
    
    # setup security
    for n, d in container_iface.namesAndDescriptions(all=True):
        protectName(container_class, n, "zope.Public")
    # apply implementedBy
    if not container_iface.implementedBy(container_class):
        interface.classImplements(container_class, container_iface)
Ejemplo n.º 42
0
def apply_customization_workflow(type_key, ti):
    """Apply customizations, features as per configuration from a workflow. 
    Must (currently) be run after db setup.
    """
    domain_model, workflow = ti.domain_model, ti.workflow
    assert domain_model and workflow, ti
    # We "mark" the domain class with IWorkflowed, to be able to
    # register/lookup adapters generically on this single interface.
    #!+directlyImplementedBy? assert not IWorkflowed.implementedBy(domain_model), domain_model
    if not IWorkflowed.implementedBy(domain_model):
        classImplements(domain_model, IWorkflowed)
    # dynamic features from workflow - setup domain/mapping as needed
    for feature in workflow.features:
        feature.setup_model(domain_model)
Ejemplo n.º 43
0
 def afterSetUp(self):
     self.folder.invokeFactory("EasyForm", "ff1")
     self.ff1 = getattr(self.folder, "ff1")
     self.ff1.CSRFProtection = False  # no csrf protection
     self.ff1.showAll = True
     field_template = api.content.create(self.layer["portal"],
                                         "File",
                                         id="easyform_default_fields.xml")
     with open(join(dirname(__file__), "fixtures",
                    self.schema_fixture)) as f:
         filecontent = NamedFile(f.read(), contentType="application/xml")
     field_template.file = filecontent
     classImplements(BaseRequest, IFormLayer)
     validators.update_validators()
Ejemplo n.º 44
0
def apply_concrete_behaviors():
    '''
    Configured behaviors for an object should always be applied and can't
    be removed.

    Should be called once at startup instead of doing alsoProvides every
    time an object is created
    '''
    for type_name, factory in get_utilities_for(IResourceFactory):
        for behavior in factory.behaviors:
            behavior_registration = get_utility(
                IBehavior, name=behavior.__identifier__)
            if behavior_registration.marker is not None:
                classImplements(factory._callable, behavior_registration.marker)
Ejemplo n.º 45
0
def subscription_factory(cls, *args, **kwargs):
    """Utility which allows to to quickly register a subscription adapters which returns new
    instantiated objects of a given class

    >>> provideSubscriptionAdapter(subscription_factory(MetricsDaemonProcess), adapts=(IProc,))

    """
    class SubscriptionFactoryWrapper(object):
        def __new__(self, *_ignore):
            return cls(*args)

    interfaces = get_direct_interfaces(cls)
    classImplements(SubscriptionFactoryWrapper, *interfaces)
    return SubscriptionFactoryWrapper
    def wire(cls, name, key, *interfaces, **options):
        fields = {}
        bases = (cls, ) + options.get('bases', ())

        for iface in interfaces:
            for field in schema.getFields(iface).values():
                fields[field.__name__] = property(
                    lambda self, field=field: self.getFieldProperty(field),
                    lambda self, value, field_name=field.__name__: self.
                    setProperty(field_name, value))
        new_class = type(name, bases, fields)
        cls.annotation_key = key
        classImplements(new_class, interfaces)
        return new_class
Ejemplo n.º 47
0
def enable_attachment(kls):
    """Decorator for attachment-feature of domain types.
    Executed on adapters.load_workflow()
    
    !+ currently assumes that the object is versionable.
    !+ domain.AttachedFile is the only versionable type that is not a PI.
    """
    # !+ domain.AttachedFile is versionable, but does not support attachments
    assert kls is not AttachedFile
    # assign interface (versions property added downstream)
    name = kls.__name__
    interface.classImplements(kls, interfaces.IAttachmentable)
    CUSTOM_DECORATED["enable_attachment"].add(kls)
    return kls
Ejemplo n.º 48
0
def versionable(kls):
    """Decorator for versionable domain types, to collect in one place all
    that is needed for a domain type to be versionable.
    
    Note: @versionable implies @auditable, here made explicit
    """
    # if @versionable must also be @auditable:
    kls = auditable(kls)
    # assign interface (versions property added downstream)
    name = kls.__name__
    interface.classImplements(kls, interfaces.IVersionable)
    # define TYPEVersion class
    version_name = "%sVersion" % (name)
    globals()[version_name] = ItemVersions.makeVersionFactory(version_name)
    return kls
Ejemplo n.º 49
0
    def test_classImplements(self):
        class A(Odd):
            implements(I3)

        class B(Odd):
            implements(I4)

        class C(A, B):
            pass
        classImplements(C, I1, I2)
        self.assertEqual([i.getName() for i in implementedBy(C)],
                         ['I1', 'I2', 'I3', 'I4'])
        classImplements(C, I5)
        self.assertEqual([i.getName() for i in implementedBy(C)],
                         ['I1', 'I2', 'I5', 'I3', 'I4'])
Ejemplo n.º 50
0
def load_adapter(_context, adapter):
    conf = adapter['config']
    klass = resolve_dotted_name(adapter['klass'])
    factory = conf.pop('factory', None) or klass
    _component_conf(conf)
    if 'provides' in conf and isinstance(klass, type):
        # not sure if this is what we want or not for sure but
        # we are automatically applying the provides interface to
        # registered class objects
        classImplements(klass, conf['provides'])
    component.adapter(
        _context,
        factory=(factory,),
        **conf
    )
Ejemplo n.º 51
0
    def registerImplementation(self,
                               klass,
                               adapter=NO_ADAPTER_NEEDED,
                               depth=1):

        if adapter is NO_ADAPTER_NEEDED:
            zi.classImplements(klass, self.subject)

        elif adapter is DOES_NOT_SUPPORT:
            ifaces = zi.Declaration(
                [i.__iro__ for i in zi.implementedBy(klass)]) - self.subject
            zi.classImplementsOnly(klass, ifaces)

        return supermeta(ZopeInterfaceAsProtocol,
                         self).registerImplementation(klass, adapter, depth)
Ejemplo n.º 52
0
 def afterSetUp(self):
     super(TestFunctions, self).afterSetUp()
     self.folder.invokeFactory('EasyForm', 'ff1')
     self.ff1 = getattr(self.folder, 'ff1')
     self.ff1.title = u'ff1'
     self.mailhost = self.folder.MailHost
     self.mailhost._send = self.dummy_send
     self.request = makerequest(self.app).REQUEST
     self.ff1.CSRFProtection = False
     self.ff1.actions_model = (self.ff1.actions_model.replace(
         u'<description>E-Mails Form Input</description>',
         u'<recipient_email>[email protected]</recipient_email><description>E-Mails Form Input</description>'
     ))
     self.mailhost = self.folder.MailHost
     self.mailhost._send = self.dummy_send
     classImplements(BaseRequest, IFormLayer)
Ejemplo n.º 53
0
def classImplements(class_, *interfaces):
    normalized_interfaces = []
    for i in interfaces:
        normalized_interfaces.append(i)
    return interface.classImplements(
        class_,  # NOQA: D001
        *normalized_interfaces)
Ejemplo n.º 54
0
def patchPersistent():
    global _patched
    if _patched:
        return

    _patched = True

    from zope.interface import classImplements
    from Persistence import Persistent
    from App.interfaces import IPersistentExtra

    for k, v in PersistentUtil.__dict__.items():
        if k[0] != '_':
            setattr(Persistent, k, v)

    classImplements(Persistent, IPersistentExtra)
Ejemplo n.º 55
0
def patch():
    prefix = '__old_'
    for patch in patches:
        klass = patch.kls
        if not IElasticSearchCatalog.implementedBy(klass):
            patched[klass] = {}
            for name, method in patch.method_map.items():
                classImplements(klass, IElasticSearchCatalog)
                old = getattr(klass, name, method)
                patched[klass][name] = old
                setattr(klass, prefix + name, old)
                setattr(klass, name, method)
                info('patched %s', str(getattr(klass, name)))

    
    CatalogMultiplex.unindexObject = unindexObject
    setattr(CatalogMultiplex, '__old_unindexObject', original_unindexObject)
Ejemplo n.º 56
0
def annotation_proxy(context, schema):
    annotations = IAnnotations(context)
    properties = dict(
        (name, AnnotationProperty(annotations, schema[name]))
        for name in schema
        )

    properties['portal_url'] = staticmethod(context.portal_url)

    proxy = type(
        "%sAdapter" % schema.__name__[1:],
        (object, ), properties,
        )

    classImplements(proxy, schema)

    return proxy()
Ejemplo n.º 57
0
    def _add_delegate(cls):
        """Returns the given class, updated with a new __init__ function that wraps the
        old one and adds instantiation of the delegate, and adds new member functions
        that match the public members in the delegate class.  Any public members in the
        delegate that have a name matching anything in the scoping object are ignored.
        """
        member_set = set()

        for klass in getmro(cls):
            member_set.update(klass.__dict__.keys())

        listofdels = []
        for tup in delegates:
            if isinstance(tup, tuple):
                delegatename, delegate = tup
            else:  # assume no name given
                delegate = tup
                delegatename = None
            if not isinstance(delegate, type):
                raise TypeError(
                    "Can't add delegate to class %s because delegate is not a class"
                    % cls.__name__)
            if not delegatename:
                delegatename = '_%s' % delegate.__name__.lower()

            listofdels.append((delegatename, delegate))

            alldict = {}

            for interface in implementedBy(delegate):
                classImplements(cls, interface)

            for klass in getmro(delegate):
                if hasattr(klass, '_do_not_promote'):
                    skip = klass._do_not_promote
                else:
                    skip = []
                for k, v in getmembers(klass, ismethod):
                    if not k.startswith(
                            '_'
                    ) and k not in alldict and k not in member_set and k not in skip:
                        member_set.add(k)
                        setattr(cls, k, forwarder(cls, v, delegatename))
            cls.__init__ = init_wrapper(cls, listofdels)
        return cls
    def testExceptionSideEffects(self):
        from zope.publisher.interfaces import IExceptionSideEffects

        class SideEffects(object):
            implements(IExceptionSideEffects)

            def __init__(self, exception):
                self.exception = exception

            def __call__(self, obj, request, exc_info):
                self.obj = obj
                self.request = request
                self.exception_type = exc_info[0]
                self.exception_from_info = exc_info[1]

        class SideEffectsFactory:
            def __call__(self, exception):
                self.adapter = SideEffects(exception)
                return self.adapter

        factory = SideEffectsFactory()
        from ZODB.POSException import ConflictError
        from zope.interface import Interface

        class IConflictError(Interface):
            pass

        classImplements(ConflictError, IConflictError)
        component.provideAdapter(factory, (IConflictError, ),
                                 IExceptionSideEffects)
        exception = ConflictError()
        try:
            raise exception
        except:
            pass
        self.publication.handleException(self.object,
                                         self.request,
                                         sys.exc_info(),
                                         retry_allowed=False)
        adapter = factory.adapter
        self.assertEqual(exception, adapter.exception)
        self.assertEqual(exception, adapter.exception_from_info)
        self.assertEqual(ConflictError, adapter.exception_type)
        self.assertEqual(self.object, adapter.obj)
        self.assertEqual(self.request, adapter.request)
Ejemplo n.º 59
0
 def setup_model(self, model):
     """Executed on adapters.load_workflow().
     """
     self.validate_model(model)
     if self.enabled:
         interface.classImplements(model, self.feature_interface)
         # add a convenient "{name}_feature" (cached) property to model
         feature_name = self.name
         feature_property_name = "%s_feature" % (feature_name)
         assert feature_property_name not in model.__dict__, \
             "Model %s already has an attribute %r" % (
                 model, feature_property_name)
         def _get_feature(self):
             return get_feature(self, feature_name)
         _get_feature.__name__ = feature_property_name
         setattr(model, feature_property_name, misc.cached_property(_get_feature))
         # additional model preparations
         self.decorate_model(model)
Ejemplo n.º 60
0
def ViewletManagerFactory(name, interface, bases=(), cdict=None):  # pylint: disable=invalid-name
    """Viewlet manager factory"""

    attr_dict = {'__name__': name}
    attr_dict.update(cdict or {})

    if ViewletManager not in bases:
        # Make sure that we do not get a default viewlet manager mixin, if the
        # provided base is already a full viewlet manager implementation.
        # pylint: disable=no-value-for-parameter
        if not (len(bases) == 1 and IViewletManager.implementedBy(bases[0])):
            bases = bases + (ViewletManager, )

    viewlet_manager_class = type(
        '<ViewletManager providing %s>' % interface.getName(), bases,
        attr_dict)
    classImplements(viewlet_manager_class, interface)
    return viewlet_manager_class