def grok(self, name, factory, context, module_info, templates): adapter_context = util.determine_class_context(factory, context) provides = util.class_annotation(factory, 'grok.provides', None) if provides is None: base_interfaces = interface.implementedBy(grok.Annotation) factory_interfaces = interface.implementedBy(factory) real_interfaces = list(factory_interfaces - base_interfaces) util.check_implements_one_from_list(real_interfaces, factory) provides = real_interfaces[0] key = util.class_annotation(factory, 'grok.name', None) if key is None: key = factory.__module__ + '.' + factory.__name__ @component.adapter(adapter_context) @interface.implementer(provides) def getAnnotation(context): annotations = IAnnotations(context) try: result = annotations[key] except KeyError: result = factory() annotations[key] = result # Containment has to be set up late to allow containment # proxies to be applied, if needed. This does not trigger # an event and is idempotent if containment is set up # already. contained_result = contained(result, context, key) return contained_result component.provideAdapter(getAnnotation) return True
def _provides(component, module=None, **data): martian.util.check_implements_one(component) return list(interface.implementedBy(component))[0]
def _provides(component, module=None, **data): martian.util.check_implements_one(component) return list(interface.implementedBy(component))[0]
def grok(self, name, factory, context, module_info, templates): infos = util.class_annotation_list(factory, 'grok.local_utility', None) if infos is None: return False for info in infos: if info.public and not IContainer.implementedBy(factory): raise GrokError( "Cannot set public to True with grok.local_utility as " "the site (%r) is not a container." % factory, factory) if info.provides is None: if util.check_subclass(info.factory, grok.LocalUtility): baseInterfaces = interface.implementedBy(grok.LocalUtility) utilityInterfaces = interface.implementedBy(info.factory) provides = list(utilityInterfaces - baseInterfaces) if len(provides) == 0 and len(list(utilityInterfaces)) > 0: raise GrokError( "Cannot determine which interface to use " "for utility registration of %r in site %r. " "It implements an interface that is a specialization " "of an interface implemented by grok.LocalUtility. " "Specify the interface by either using grok.provides " "on the utility or passing 'provides' to " "grok.local_utility." % (info.factory, factory), info.factory) else: provides = list(interface.implementedBy(info.factory)) util.check_implements_one_from_list(provides, info.factory) info.provides = provides[0] # raise an error in case of any duplicate registrations # on the class level (subclassing overrides, see below) used = set() class_infos = util.class_annotation(factory, 'grok.local_utility', []) for info in class_infos: key = (info.provides, info.name) if key in used: raise GrokError( "Conflicting local utility registration %r in " "site %r. Local utilities are registered multiple " "times for interface %r and name %r." % (info.factory, factory, info.provides, info.name), factory) used.add(key) # Make sure that local utilities from subclasses override # utilities from base classes if the registration (provided # interface, name) is identical. overridden_infos = [] used = set() for info in reversed(infos): key = (info.provides, info.name) if key in used: continue used.add(key) overridden_infos.append(info) overridden_infos.reverse() # store infos on site class factory.__grok_utilities_to_install__ = overridden_infos component.provideHandler(localUtilityRegistrationSubscriber, adapts=(factory, grok.IObjectAddedEvent)) return True
def default_provides(factory, module=None, **data): martian.util.check_implements_one(factory) return list(interface.implementedBy(factory))[0]