def test_show_on_home_factory_does_not_remove_other_interfaces(self):
        applyProfile(self.portal, 'ftw.news:show-on-homepage')

        page = create(Builder('sl content page'))
        newsfolder = create(Builder('news folder').within(page))
        news = create(Builder('news')
                      .within(newsfolder)
                      .having(news_date=datetime(2011, 1, 2, 15, 0, 0)))

        class IDummyMarkerInterface(Interface):
            pass

        directlyProvides(news, IDummyMarkerInterface)
        self.assertEqual(
            [IDummyMarkerInterface],
            list(directlyProvidedBy(news))
        )

        IShowOnHomepageSchema(news).show_on_homepage = True
        self.assertEqual(
            [IDummyMarkerInterface, IShowOnHomepage],
            list(directlyProvidedBy(news))
        )

        IShowOnHomepageSchema(news).show_on_homepage = False
        self.assertEqual(
            [IDummyMarkerInterface],
            list(directlyProvidedBy(news))
        )

    def test_directlyProvides(self):
        class IA1(Interface): pass
        class IA2(Interface): pass
        class IB(Interface): pass
        class IC(Interface): pass
        class A(Odd):
            pass
        classImplements(A, IA1, IA2)

        class B(Odd):
            pass
        classImplements(B, IB)

        class C(A, B):
            pass
        classImplements(C, IC)


        ob = C()
        directlyProvides(ob, I1, I2)
        self.assertTrue(I1 in providedBy(ob))
        self.assertTrue(I2 in providedBy(ob))
        self.assertTrue(IA1 in providedBy(ob))
        self.assertTrue(IA2 in providedBy(ob))
        self.assertTrue(IB in providedBy(ob))
        self.assertTrue(IC in providedBy(ob))

        directlyProvides(ob, directlyProvidedBy(ob)-I2)
        self.assertTrue(I1 in providedBy(ob))
        self.assertFalse(I2 in providedBy(ob))
        self.assertFalse(I2 in providedBy(ob))
        directlyProvides(ob, directlyProvidedBy(ob), I2)
        self.assertTrue(I2 in providedBy(ob))

    def test_directlyProvides(self):
        class IA1(Interface): pass
        class IA2(Interface): pass
        class IB(Interface): pass
        class IC(Interface): pass
        class A(Odd):
            implements(IA1, IA2)

        class B(Odd):
            implements(IB)

        class C(A, B):
            implements(IC)


        ob = C()
        directlyProvides(ob, I1, I2)
        self.assert_(I1 in providedBy(ob))
        self.assert_(I2 in providedBy(ob))
        self.assert_(IA1 in providedBy(ob))
        self.assert_(IA2 in providedBy(ob))
        self.assert_(IB in providedBy(ob))
        self.assert_(IC in providedBy(ob))

        directlyProvides(ob, directlyProvidedBy(ob)-I2)
        self.assert_(I1 in providedBy(ob))
        self.failIf(I2 in providedBy(ob))
        self.failIf(I2 in providedBy(ob))
        directlyProvides(ob, directlyProvidedBy(ob), I2)
        self.assert_(I2 in providedBy(ob))

def _gpgAuthenticateEmail(mail, principal, person,
                          signature_timestamp_checker):
    """Check GPG signature.

    :param principal: Claimed sender of the mail; to be checked against
        the actual signature.
    :returns: principal, either strongly or weakly authenticated.
    """
    log = logging.getLogger('process-mail')
    signature = mail.signature
    email_addr = parseaddr(mail['From'])[1]
    if signature is None:
        # Mark the principal so that application code can check that the
        # user was weakly authenticated.
        log.debug('message has no signature; therefore weakly authenticated')
        directlyProvides(
            principal, directlyProvidedBy(principal),
            IWeaklyAuthenticatedPrincipal)
        setupInteraction(principal, email_addr)
        return principal

    gpghandler = getUtility(IGPGHandler)
    try:
        sig = gpghandler.getVerifiedSignature(
            canonicalise_line_endings(mail.signedContent), signature)
        log.debug("got signature %r" % sig)
    except GPGVerificationError as e:
        # verifySignature failed to verify the signature.
        message = "Signature couldn't be verified: %s" % e
        log.debug(message)
        raise InvalidSignature(message)

    if signature_timestamp_checker is None:
        signature_timestamp_checker = ensure_sane_signature_timestamp
    # If this fails, we return an error to the user rather than just treating
    # it as untrusted, so they can debug or understand the problem.
    signature_timestamp_checker(
        sig.timestamp,
        'incoming mail verification')

    for gpgkey in person.gpg_keys:
        if gpgkey.fingerprint == sig.fingerprint:
            log.debug('gpg-signed message by key %r' % gpgkey.fingerprint)
            break
    else:
        # The key doesn't belong to the user. Mark the principal so that the
        # application code knows that the key used to sign the email isn't
        # associated with the authenticated user.
        log.debug('gpg-signed message but by no known key of principal')
        directlyProvides(
            principal, directlyProvidedBy(principal),
            IWeaklyAuthenticatedPrincipal)

    setupInteraction(principal, email_addr)
    return principal

    def test_context_manager_adds_book_layers(self):
        thelist = list(directlyProvidedBy(self.portal.REQUEST))

        with providing_book_layers(self.portal, self.portal.REQUEST):
            diff = [it for it in list(
                    directlyProvidedBy(self.portal.REQUEST)) if it not in thelist]

            self.assertEquals(
                ['<InterfaceClass ftw.book.interfaces.IWithinBookLayer>'],
                [str(item) for item in diff])

        self.assertEquals(thelist,
                          list(directlyProvidedBy(self.portal.REQUEST)))

    def afterSetUp(self):

        # A hack to force gomobile.convergence install when running multiple tests on P3
        name = "gomobile.convergence"
        qi = self.portal.portal_quickinstaller
        
        try:
            qi.uninstallProducts([name])
        except:
            pass
        qi.installProduct(name)        
        
        self.filter = getUtility(IConvergenceMediaFilter)

        # Set up convergence layer on HTTP request,
        # so that configure overrides kick in


        from plone.browserlayer import utils

        # TODO: Put following into a test case
        self.assertTrue(IConvergenceBrowserLayer in utils.registered_layers())

        # Make sure that convergence layer is applied on the test request,
        # so that our custom views kick in
        #import pdb ; pdb.set_trace()
        directlyProvides(self.portal.REQUEST, [IConvergenceBrowserLayer] + list(directlyProvidedBy(self.portal.REQUEST)))

def mark_layer(site, event):
    """Mark the request with a layer corresponding to the current skin,
    as set in the portal_skins tool.
    """
    if getattr(event.request, "_plonetheme_", False):
        return
    event.request._plonetheme_=True

    portal_skins = getToolByName(site, 'portal_skins', None)
    if portal_skins is not None:
        skin_name = site.getCurrentSkinName()
        skin = queryUtility(IBrowserSkinType, name=skin_name)
        if skin is not None:
            layer_ifaces = []
            default_ifaces = []
            # We need to make sure IDefaultPloneLayer comes after
            # any other layers, even if they don't explicitly extend it.
            if IDefaultPloneLayer in skin.__iro__:
                default_ifaces += [IDefaultPloneLayer]
            for layer in directlyProvidedBy(event.request):
                if layer in default_layers:
                    default_ifaces.append(layer)
                elif IBrowserSkinType.providedBy(layer):
                    continue
                else:
                    layer_ifaces.append(layer)
            ifaces = [skin, ] + layer_ifaces + default_ifaces
            directlyProvides(event.request, *ifaces)

def objs_with_iface(context, iface):
    """Return all objects in the system as found by the nearest portal
    catalog that provides the given interface.  The result will be a generator
    for scalability reasons.

      >>> from zope import interface
      >>> class ITest(interface.Interface): pass
      >>> class Mock(object):
      ...     def __init__(self, id): self.id = id
      ...     def getObject(self): return self
      ...     def __repr__(self): return '<Mock id=%s>' % self.id
      >>> m = Mock('Portal Root')
      >>> objs = [Mock('m1'), Mock('m2'), Mock('m3')]
      >>> interface.directlyProvides(objs[1], ITest)
      >>> m.portal_catalog = lambda **kwargs: objs

      >>> [x for x in objs_with_iface(m, ITest)]
      [<Mock id=m2>]

    """

    catalog = cmfutils.getToolByName(context, 'portal_catalog')

    for brain in catalog(object_provides=interfaceToName(context, iface)):
        obj = brain.getObject()
        if iface in interface.directlyProvidedBy(obj):
            yield brain.getObject()

def remove_marker_ifaces(context, ifaces): 
    """Remove the given interfaces from all objects using a catalog
    query.  context needs to either be the portal or be properly aq wrapped
    to allow for cmf catalog tool lookup.  ifaces can be either a single
    interface or a sequence of interfaces.

      >>> from zope import interface
      >>> class ITest(interface.Interface): pass
      >>> class Mock(object):
      ...     def __init__(self, id): self.id = id
      ...     def getObject(self): return self
      ...     def __repr__(self): return '<Mock id=%s>' % self.id
      >>> m = Mock('Portal Root')
      >>> objs = [Mock('m1'), Mock('m2'), Mock('m3')]
      >>> interface.directlyProvides(objs[1], ITest)
      >>> m.portal_catalog = lambda **kwargs: objs

      >>> remove_marker_ifaces(m, ITest)
      1

      >>> remove_marker_ifaces(m, [ITest])
      0

    """

    if not isinstance(ifaces, (tuple, list)):
        ifaces = [ifaces]

    count = 0
    for iface in ifaces:
        for obj in objs_with_iface(context, iface):
            count += 1
            provided = interface.directlyProvidedBy(obj)
            interface.directlyProvides(obj, provided - iface)
    return count

 def set_newsletter_state(self, state):
     if IPossibleNewsletter.providedBy(self.context):
         ifaces = interface.directlyProvidedBy(self.context)
         if state and not INewsletterEnhanced.providedBy(self.context):
             interface.alsoProvides(self.context, INewsletterEnhanced)
         elif not state and INewsletterEnhanced in ifaces:
             interface.directlyProvides(self.context, ifaces - INewsletterEnhanced)

def _set_activation(obj, possibleiface, enhancediface, activation):
    """Try to set the feature activation on the given object.
    """

    if isinstance(possibleiface, basestring):
        raise NotImplementedError('Still need to locaate class via dotted '
                                  'path string')
    if isinstance(enhancediface, basestring):
        raise NotImplementedError('Still need to locaate class via '
                                  'dotted path string')

    if not possibleiface.providedBy(obj):
        raise ActivationException('The object denoted by %r does not '
                                  'provide the %r interface'
                                  % (repr(obj), repr(possibleiface)))

    if not activation and enhancediface.implementedBy(obj.__class__):
        raise ActivationException('It is not possible to remove %r from '
                                  'the %r since the class is the '
                                  'implementer'
                                  % (repr(possibleiface), repr(obj)))

    ifaces = interface.directlyProvidedBy(obj)
    if activation and not enhancediface.providedBy(obj):
        interface.alsoProvides(obj, enhancediface)
        event.notify(interfaces.FeatureActivatedEvent(enhancediface, obj))
    elif not activation and enhancediface in ifaces:
        interface.directlyProvides(obj, ifaces - enhancediface)
        event.notify(interfaces.FeatureDeactivatedEvent(enhancediface, obj))

def configureXMLWidgets(root):
    """Configure XMLWidgets registries, editor, etc'
    """
    # create the core widgets from the filesystem
    add_fss_directory_view(root, 'service_widgets', __file__, 'widgets')

    # create the editor service
    root.manage_addProduct['XMLWidgets'].manage_addEditorService(
        'service_editor')
    # create the services for XMLWidgets
    for name in ['service_doc_editor', 'service_doc_previewer',
                 'service_doc_viewer',
                 'service_field_editor', 'service_field_viewer',
                 'service_nlist_editor', 'service_nlist_previewer',
                 'service_nlist_viewer',
                 'service_sub_editor', 'service_sub_previewer',
                 'service_sub_viewer',
                 'service_table_editor', 'service_table_viewer']:
        root.manage_addProduct['XMLWidgets'].manage_addWidgetRegistry(name)
        if IInvisibleService is not None:
            interface.directlyProvides(
                root[name],
                IInvisibleService,
                *interface.directlyProvidedBy(root[name]))

    # now register all widgets
    # XXX not really necessary; the "install" should take case of this
    registerCoreWidgets(root)

 def enabled(self, value):
     context = removeAllProxies(self.context)
     if value:
         interface.alsoProvides(context, self.marker)
     else:
         if self.marker in interface.directlyProvidedBy(context):
             interface.noLongerProvides(context, self.marker)

def copyRelationsOnSourceCopy(obj, event):
    """Copies all source relaitonships marked with IRetainOnCopy
    when the source object is copied"""
    orig_obj = obj.__orig_object__.aq_inner
    source = IRelationshipSource(orig_obj)
    cur_ifaces = directlyProvidedBy(obj)
    directlyProvides(obj, *[i for i in cur_ifaces if i is not ICopyPendingAdd])
    delattr(obj, '__orig_object__')
    copy_filter = IRetainOnCopy.providedBy
    # this is not efficient to source objects with a huge number of
    # relations
    rels = source.getRelationships(rel_filter=copy_filter)
    container = getUtility(IComplexRelationshipContainer, name='relations')
    unwrapped_obj = aq_base(obj)
    for rel in rels:
        # copy the relationship
        rel_copy = locationCopy(aq_base(rel))
        # The references on the copy becames copies themselves we need
        # to make sure all such references point to the originals:
        rel_copy.__dict__ = rel.__dict__
        # We should also remove existing ILocation pointers
        rel_copy.__parent__ = rel_copy.__name__ = None
        # Now we add the relationship (with wrong sources for now) to
        # give it a context.
        container.add(rel_copy)
        # replace the old sources with just the copy
        rel_copy.sources = (obj,)

def providing_book_layers(book, request):
    original_interfaces = list(directlyProvidedBy(request))
    provide_book_layers(book, request)
    try:
        yield
    finally:
        directlyProvides(request, *original_interfaces)

    def __call__(self):
        context = aq_inner(self.context)
        
        manager = IDynamicViewManager(context)
        layout = manager.getLayout()

        if not layout:
            layout, title = manager.getDefaultLayout()

        if ICollageAlias.providedBy(context):
            context = context.get_target()
            
            # if not set, revert to self.context
            if not context: context = self.context

        # transmute request interfaces
        ifaces = directlyProvidedBy(self.request)
        directlyProvides(self.request, ICollageBrowserLayer)

        view = getMultiAdapter((context, self.request), name=layout)

        # restore interfaces
        directlyProvides(self.request, ifaces)

        return view.index

    def getInterfaces(self, obj):
        if not obj:
            return None

        doc = self.doc
        root = doc.createElement('interfaces')

        ifaces = [i.__identifier__ for i in directlyProvidedBy(obj)]
        if self.include:
            ifaces = filter(lambda i: i in self.include, ifaces)
        elif self.exclude:
            ifaces = filter(lambda i: not i in self.include, ifaces)

        if ifaces == []:
            return None

        for iface in ifaces:
            # create record
            record = doc.createElement('record')

            # add object interface
            text = doc.createTextNode(iface)
            record.appendChild(text)

            root.appendChild(record)

        doc.appendChild(root)

        try:
            data = doc.toprettyxml(indent='  ', encoding='utf-8')
        except UnicodeDecodeError, e:
            # all comments are strings encoded in 'utf-8' and they will properly
            # saved in xml file, but if we explicitly give 'utf-8' encoding
            # UnicodeDecodeError will be raised when they have non-ascii chars
            data = doc.toprettyxml(indent='  ')

    def _createBook(self):
        id = self.portal.invokeFactory(
            'Folder',
            'Maths',
            title=u"Maths Grade 10")
        book = self.portal._getOb(id)
        directlyProvides(book, directlyProvidedBy(book), INavigationRoot)

        structure = (('folder001', 'Folder', u'Folder 001'),
                     ('folder002', 'Folder', u'Folder 002'),
                     ('folder003', 'Folder', u'Folder 003'),
                    )
        for number, details in enumerate(structure):
            itemId, itemType, itemTitle = details
            id = book.invokeFactory(itemType, itemId, title=itemTitle)
            chapter = book[id]
            chapter.setNextPreviousEnabled(True)
            chapter.setExcludeFromNav(False)
            id = chapter.invokeFactory(
                'File',
                'file%s' %number,
                title=u'File %s' %number)
            item = chapter._getOb(id)
            item.setNextPreviousEnabled(True)
            item.setExcludeFromNav(False)
            chapter.setDefaultPage(id) 
        return book

    def upgradeObj(self, obj, path=None):
        obj._p_activate()

        if self.delRemovedObj(obj, path):
            # Deleted don't do anything else
            return

        if '__implements__' in obj.__dict__:
            self.log('Deleting __implements__ instance attributre from %r'
                     % obj)
            del obj.__dict__['__implements__']
            obj._p_changed = True

        if zodb_ifaces.IBroken.providedBy(obj):
            self.log('Removing broken interfaces from %r: %r' %
                     (obj, list(interface.directlyProvidedBy(obj))))
            interface.noLongerProvides(obj, zodb_ifaces.IBroken)

        if not self.update_catalogs:
            return
        base = aq_base(obj)

        if (
                not isinstance(obj, ZCatalog.ZCatalog) and
                callable(getattr(base, 'indexObject', None))):
            obj.indexObject()

        if callable(getattr(base, '_updateCatalog', None)):
            obj._updateCatalog(obj)

def contained(obj, parent=None, name=None):
    """An implementation of zope.app.container.contained.contained
    that doesn't generate events, for internal use.

    copied from SQLOS / z3c.zalchemy
    """
    if (parent is None):
        raise TypeError('Must provide a parent')

    if not IContained.providedBy(obj):
        if ILocation.providedBy(obj):
            interface.directlyProvides(obj, IContained,
                                       interface.directlyProvidedBy(obj))
        else:
            obj = ContainedProxy(obj)

    oldparent = obj.__parent__
    oldname = obj.__name__

    if (oldparent is None) or not (oldparent is parent
                                   or sameProxiedObjects(oldparent, parent)):
        obj.__parent__ = parent

    if oldname != name and name is not None:
        obj.__name__ = name

    return obj