def filter(self, components, manager=None):
     """ Returns a filtered list of components
     """
     order = []
     # temporary provide all interfaces of the registered components
     notprovided = []
     for name, comp in components:
         if not comp.interface.providedBy(self.context):
             notprovided.append(comp.interface)
             interface.alsoProvides(self.context, comp.interface)
     view = component.getMultiAdapter((self.context, self.request), name=u'view')
     if manager is not None:
         manager = component.getMultiAdapter((self.context, self.request, view), VIEWLET_MANAGER_MAP.get(manager, object()), name=manager)
         viewlets = component.getAdapters((self.context, self.request, view, manager), IViewlet)
         viewlets = manager.filter(viewlets)
         viewlets = manager.sort(viewlets)
         for name, viewlet in viewlets:
             order.append(name)
     else:
         for name, iface in ORDERED_VIEWLET_MANAGERS:
             manager = component.getMultiAdapter((self.context, self.request, view), iface, name=name)
             viewlets = component.getAdapters((self.context, self.request, view, manager), IViewlet)
             viewlets = manager.filter(viewlets)
             viewlets = manager.sort(viewlets)
             for name, viewlet in viewlets:
                 order.append(name)
     # no longer provide the interfaces previously set
     for iface in notprovided:
         interface.noLongerProvides(self.context, iface)
     components = [(name, comp) for name, comp in components if comp.viewlet in order]
     components.sort(lambda x, y: cmp(order.index(x[1].viewlet), order.index(y[1].viewlet)))
     return components

    def test_membership_adapter_registration(self):

        class Source(TestAdapter):

            def memberships(self, person=None):
                pass

        with self.custom_source(Source):

            folder = self.new_temporary_folder()

            adapters = [
                name for name, source in
                getAdapters((folder, ), IMembershipSource)
            ]

            self.assertEqual(
                adapters, ['zodb-membership-source', 'custom-source']
            )

        adapters = [
            name for name, source in
            getAdapters((folder, ), IMembershipSource)
        ]
        self.assertEqual(adapters, ['zodb-membership-source'])

    def __init__(self, context):
        perms = []
        # first get object permissionsmap
        supp = IObjectPermissionsMaps(context, None)
        if supp is not None:
            perms.extend(supp.get())

        for name, permissions in getAdapters((context,), IPermissionsMap):
        # then get adapted permissionsmap
            perms.append(permissions)

        self.perms = perms

        # collect parents permissionsmaps
        parent_perms = []
        if hasattr(context, '__parent__'):
            parent_context = context.__parent__
        else:
            parent_context = None
        while ILocation.providedBy(parent_context) and parent_context is not None:
            for name, permissions in getAdapters((parent_context,), IPermissionsMap):
                if permissions not in parent_perms:
                    parent_perms.append(permissions)
            parent_context = parent_context.__parent__

        self.parent_perms = parent_perms #tuple(reversed(parent_perms)) # Permissions are propagated in 'child -> parent' direction

def instanceSchemaFactory(context):
    """Default schema adapter factory.

    In BaseObject, the Schema() method will do 'schema = ISchema(self)'. This
    adapter factory is a replacement of the default one in
    Archetypes.Schema.factory. It allows you to register named adapter
    to extend the schema. The advantage is that now several packages can do
    additions to the schema without conflicts.
    """
    extenders = list(getAdapters((context, ), ISchemaExtender))
    modifiers = list(getAdapters((context, ), ISchemaModifier))
    if len(extenders) == 0 and len(modifiers) == 0:
        return context.schema

    # as long as the schema is only extended, we can reuse all fields
    # if it's modified later, then we need a full copy, see modifiers below
    # however, using the __add__ function will needlessly validate all fields
    # again (in `addField`).  instead we first create an empty schema of the
    # same class, which is then populated using (shallow) copies of the
    # internal data structures.  this shouldn't be too risky considering
    # that they've last changed about 6 years ago...
    schema = context.schema.__class__()
    schema._names = list(context.schema._names)
    schema._fields = context.schema._fields.copy()
    schema._props = context.schema._props.copy()
    schema._layers = context.schema._layers.copy()

    # loop through all schema extenders
    order = None
    for name, extender in extenders:
        if IBrowserLayerAwareExtender.providedBy(extender) and \
           (not has_plone_browserlayer or \
           extender.layer not in registered_layers()):
            continue
        for field in extender.getFields():
            schema.addField(field)
            if order is not None:
                if not field.schemata in order.keys():
                    order[field.schemata] = list()
                order[field.schemata].append(field.getName())
        if IOrderableSchemaExtender.providedBy(extender):
            if order is None:
                # we need to get the current order first
                order = get_schema_order(schema)
            order = extender.getOrder(order)
            if DevelopmentMode:
                validate_schema_order(schema, order)
    if order is not None:
        set_schema_order(schema, order)

    if len(modifiers) > 0:
        for name, modifier in modifiers:
            if IBrowserLayerAwareExtender.providedBy(modifier) and \
               (not has_plone_browserlayer or \
               modifier.layer not in registered_layers()):
                continue
            modifier.fiddle(schema)

    return schema

    def extenders(self):

        extenders = [x for x in getAdapters((self.base_context, ), ISchemaExtender)]
        modifiers = [x for x in getAdapters((self.base_context, ), ISchemaModifier)]

        extenders.extend(modifiers)

        return extenders

def vocab(context):
    request = context.REQUEST
    view = getMultiAdapter((context, context.REQUEST), Interface, 'plone')
    values = []
    for manager_name, manager in getAdapters((context, request, view), IViewletManager):
        if manager_name not in MANAGER_BLACKLIST:
            for viewlet_name, viewlet in getAdapters((context, request, view, manager), IViewlet):
                if viewlet_name not in VIEWLET_BLACKLIST:
                    values.append(' '.join((manager_name, viewlet_name)))
    return SimpleVocabulary.fromValues(values)

def vocab(context):
    request = context.REQUEST
    view = BrowserView(context, request)
    alsoProvides(view, IViewView)
    values = []
    for manager_name, manager in getAdapters((context, request, view), IViewletManager):
        if manager_name not in MANAGER_BLACKLIST:
            for viewlet_name, viewlet in getAdapters((context, request, view, manager), IViewlet):
                if viewlet_name not in VIEWLET_BLACKLIST:
                    values.append(' '.join((manager_name, viewlet_name)))
    return SimpleVocabulary.fromValues(values)

def addRefreshViewletCommands(event):
    view = event.view
    context = view.context
    request = view.request
    annotations = IAnnotations(request)
    viewletByClass = annotations.get('viewletByClass', [])
    if viewletByClass:
        for name, manager in getAdapters(
                (context, request, view, ), IViewletManager):
            for name, viewlet in  getAdapters(
                (context, request, view, manager), IViewlet):
                maybeRenderViewlet(viewlet, viewletByClass)

def SetDefaults(object, event):
    """ Sets the default components defined by the registered adapters providing IDefaultComponents
    """
    for name, provider in component.getAdapters((object,),
                                                interfaces.IDefaultComponents):
        for comp in provider.getComponents():
            interface.alsoProvides(object, comp.interface)
    for name, provider in component.getAdapters((object,),
                                                interfaces.INamedDefaultComponent):
        comp = component.queryAdapter(object,
                                      interface=interfaces.IComponent,
                                      name=name)
        if comp is not None:
            interface.alsoProvides(object, comp.interface)
    object.reindexObject(idxs=['object_provides'])

 def containers(self):
     """Get a list of potential containers
     """
     context = aq_inner(self.context)
     for name, locator in getAdapters((context,), IWCContainerLocator):
         if locator.available:
             yield dict(name=name, locator=locator)

 def _process_devices(self):
     stats = {'Device Count': 0,
              'Decommissioned Devices': 0,
              'CPU Cores':0}
     LINKED_DEVICES = "Linked Devices"
     if LINKED_DEVICES not in stats:
         stats[LINKED_DEVICES] = 0
     for device in self._dmd.Devices.getSubDevicesGen_recursive():
         stats['Device Count'] += 1
         if device.productionState < 0:
             stats["Decommissioned Devices"] += 1
         cpuCount = IDeviceCpuCount(device).cpuCount()
         log.debug("Devices %s has %s cpu cores", device, cpuCount)
         stats['CPU Cores'] += cpuCount
         for adapter in subscribers([device], IDeviceResource):
             adapter.processDevice(stats)
         found_linked = False
         for name, adapter in getAdapters((device,), IDeviceLink):
             if adapter.linkedDevice():
                 key = "%s - %s" % (LINKED_DEVICES, name)
                 if key not in stats:
                     stats[key] = 0
                 stats[key] += 1
                 if not found_linked:
                     stats[LINKED_DEVICES] += 1
                     found_linked = True
                 
             
     return stats

    def update(self):
        """See zope.contentprovider.interfaces.IContentProvider"""
        
        OTHER_MANAGER_KEYS = ["form.buttons.scale_button", "form.buttons.slots_button",
                              "form.buttons.lead_button","form.buttons.text_button_questions",
                              "form.buttons.text_button_answers","form.buttons.quiz_pages"]
        for key in OTHER_MANAGER_KEYS:
            no_need_update = self.request.get(key, default=False)
            if no_need_update:
                self.viewlets = []
                return
            
        
        self.__updated = True
        # Find all content providers for the region
        viewlets = getAdapters(
            (self.context, self.request, self.__parent__, self),IViewlet)

        viewlets = self.filter(viewlets)
        viewlets = self.sort(viewlets)

        # Just use the viewlets from now on
        self.viewlets = [viewlet for name, viewlet in viewlets]
        self.names = [name for name,viewlet in viewlets]
        # Update all viewlets and Handle Delete action
        for viewlet in self.viewlets:
            viewlet.update()
            if self.context.__name__ is None:
                #handle case when the first lead viewlet must be updated
                if IQuestionsForConstructor.providedBy(self.__parent__):
                    if ILeadedLayer.providedBy(self.request):
                        self.__parent__.question_was_removed = True
                self.viewlets = []
                break

    def testUpgradeTinyMCE(self):
        alphas.upgradeTinyMCE(self.portal.portal_setup)
        jstool = getToolByName(self.portal, 'portal_javascripts')
        jsresourceids = jstool.getResourceIds()

        self.assertIn('jquery.tinymce.js', jsresourceids)
        for ne in ['tiny_mce.js', 'tiny_mce_init.js']:
            self.assertNotIn(ne, jsresourceids, ne)

        ksstool = getToolByName(self.portal, 'portal_kss', None)
        if ksstool is not None:
            kssresourceids = ksstool.getResourceIds()
            self.assertNotIn('++resource++tinymce.kss/tinymce.kss',
                             kssresourceids)

        request = self.app.REQUEST
        plone_view = queryMultiAdapter((self.portal, request), name="plone")
        manager = queryMultiAdapter(
                    (self.portal, request, plone_view), IContentProvider, 'plone.htmlhead')
        viewlets = getAdapters(
                (manager.context, manager.request, manager.__parent__, manager), IViewlet)
        self.assertIn(u'tinymce.configuration', dict(viewlets))
        storage = getUtility(IViewletSettingsStorage)
        skinname = self.portal.getCurrentSkinName()
        order_by_name = storage.getOrder('plone.htmlhead', skinname)
        self.assertEqual(order_by_name[-1], u'tinymce.configuration')

def renameAfterCreation(obj):
    """Rename the content after it was created/added
    """
    # Check if the _bika_id was already set
    bika_id = getattr(obj, "_bika_id", None)
    if bika_id is not None:
        return bika_id
    # Can't rename without a subtransaction commit when using portal_factory
    transaction.savepoint(optimistic=True)
    # The id returned should be normalized already
    new_id = None
    # Checking if an adapter exists for this content type. If yes, we will
    # get new_id from adapter.
    for name, adapter in getAdapters((obj, ), IIdServer):
        if new_id:
            logger.warn(('More than one ID Generator Adapter found for'
                         'content type -> %s') % obj.portal_type)
        new_id = adapter.generate_id(obj.portal_type)
    if not new_id:
        new_id = generateUniqueId(obj)

    # TODO: This is a naive check just in current folder
    # -> this should check globally for duplicate objects with same prefix
    # N.B. a check like `search_by_prefix` each time would probably slow things
    # down too much!
    # -> A solution could be to store all IDs with a certain prefix in a storage
    parent = api.get_parent(obj)
    if new_id in parent.objectIds():
        # XXX We could do the check in a `while` loop and generate a new one.
        raise KeyError("The ID {} is already taken in the path {}".format(
            new_id, api.get_path(parent)))
    # rename the object to the new id
    parent.manage_renameObject(obj.id, new_id)

    return new_id

 def addition_init_code(self):
     code = u""
     providers = component.getAdapters(self, IFacebookInitCodeProvider)
     for provider in providers:
         if provider.available():
             code += provider.get_code()
     return code

 def __init__(self, context):
     terms = []
     site = component.getSiteManager()
     books = list(component.getAdapters((site,), IAddressBook))
     for name, book in books:
         terms.append(SimpleTerm(name, name, unicode(name)))
     super(AddressBooks, self).__init__(terms)

    def update(self):
        """Return the first component find that is valid for this context.
        If none are found use a dummy ressource"""

        if self.resource is None:
            url = self.url
            #to optimize performance those are hardcoded
            if check_facebook(url):
                self.resource = FacebookLink(self.context)
            elif check_picasaweb(url):
                self.resource = PicasawebLink(self.context)
            elif check_flickr(url):
                self.resource = FlickrLink(self.context)

        if self.resource is None:
            resources = component.getAdapters((self.context,),
                                              interfaces.IGallery)
            for name, r in resources:
                #every adapters should have a validate method
                if r.validate():
                    self.resource = r
                    break

        if self.resource:
            self.resource.width = self.width
            self.resource.height = self.height
        else:
            msg = i18n.message_no_backend_for_link
            self.addmessage(msg, type=u"error")

def getPathsToPurge(context, request):
    """Given the current request and an object, look up paths to purge for
    the object and yield them one by one. An IPurgePathRewriter adapter may
    be used to rewrite the paths.
    """

    rewriter = IPurgePathRewriter(request, None)

    for name, pathProvider in getAdapters((context,), IPurgePaths):
        # add relative paths, which are rewritten
        relativePaths = pathProvider.getRelativePaths()
        if relativePaths:
            for relativePath in relativePaths:
                if rewriter is None:
                    yield relativePath
                else:
                    rewrittenPaths = rewriter(relativePath) or [] # None -> []
                    for rewrittenPath in rewrittenPaths:
                        yield rewrittenPath

        # add absoute paths, which are not
        absolutePaths = pathProvider.getAbsolutePaths()
        if absolutePaths:
            for absolutePath in absolutePaths:
                yield absolutePath

    def __call__(self, *args, **kw):
        workspaces = []
        space = self.context
        default = space.defaultWorkspace

        factory = queryAdapter(space, IWorkspaceFactory, default)
        if factory is not None:
            if space.isEnabled(factory):
                if IOverviewWorkspaceFactory.providedBy(factory):
                    return getMultiAdapter(
                        (space, self.request), name='overview')()

                self.request.response.redirect('./%s/'%default)
                return

        for name, factory in getAdapters((space,), IWorkspaceFactory):
            if space.isEnabled(factory) and \
                    checkPermission('zope.View', factory.get()):
                workspaces.append((factory.weight, factory.title, name))

        if workspaces:
            workspaces.sort()
            self.request.response.redirect('./%s/'%workspaces[0][2])
        else:
            self.request.response.redirect('./listing.html')

    def __call__(self):
        portal_state = getMultiAdapter(
            (self.context, self.request),
            name=u'plone_portal_state'
        )
        context_state = getMultiAdapter(
            (self.context, self.request),
            name='plone_context_state'
        )
        # do not use getSite because it's possible it could be different
        # than the actual portal url
        portal_url = portal_state.portal_url()
        result = {
            'data-base-url': self.context.absolute_url(),
            'data-view-url': context_state.view_url(),
            'data-portal-url': portal_url,
            'data-i18ncatalogurl': portal_url + '/plonejsi18n'
        }

        # first, check for any adapters that need pattern data defined
        adapters = getAdapters(
            (self.context, self.request, None),
            IPatternsSettings
        )
        [result.update(x[1]()) for x in adapters]

        # Resources Registered UI patterns can override adapters
        registry = getUtility(IRegistry)
        pattern_options = registry.get('plone.patternoptions', {})
        for key, value in pattern_options.items():
            result['data-pat-' + key] = value

        return result