def grok(self, name, factory, context, module_info, templates): provides = util.class_annotation(factory, 'grok.provides', None) if provides is None: util.check_implements_one(factory) name = util.class_annotation(factory, 'grok.name', '') component.provideUtility(factory(), provides=provides, name=name) return True
def grok(self, name, factory, module_info, config, *kws): factory.module_info = module_info factory_name = factory.__name__.lower() # we need a path to the file containing the resource directory_name = util.class_annotation(factory, 'mars.resource.directory', '') directory = os.path.join(os.path.dirname(module_info.path), directory_name) if not os.path.isdir(directory): raise GrokError("No directory found for %s using path %s." " Please use mars.resource.directory" " to define path to the directory." % (factory.__name__, directory_name), factory) view_layer = determine_class_directive('grok.layer', factory, module_info, default=IDefaultBrowserLayer) view_name = util.class_annotation(factory, 'grok.name', factory_name) checker = NamesChecker(allowed_names) factory = DirectoryResourceFactory(directory, checker, view_name) adapts = (view_layer, ) config.action( discriminator=('adapter', adapts, IBrowserRequest, view_name), callable=zope.component.provideAdapter, args=(factory, adapts, IBrowserRequest, view_name), ) return True
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 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: util.check_implements_one(factory) name = util.class_annotation(factory, 'grok.name', '') component.provideAdapter(factory, adapts=(adapter_context,), provides=provides, name=name) return True
def grok(self, name, factory, module_info, config, *kws): factory.module_info = module_info factory_name = factory.__name__.lower() # we need a path to the file containing the resource file_name = util.class_annotation(factory, 'mars.resource.file', '') image_name = util.class_annotation(factory, 'mars.resource.image', '') if file_name == '' and image_name == '': raise GrokError("Either mars.resource.file or mars.resource.image" " must be defined for %s." % (factory.__name__), factory) file = image = None if image_name != '': file_name = image_name image = filepath = os.path.join(os.path.dirname(module_info.path), file_name) else: file = filepath = os.path.join(os.path.dirname(module_info.path), file_name) if not os.path.exists(filepath): filepath = None # allow for absolute path to resource if os.path.exists(file_name): filepath = file_name if filepath is None: raise GrokError("No resource found for %s using path %s." " Please use mars.resource.file or" " mars.resource.image to define path to the" " file containing the resource" % (factory.__name__, file_name), factory) view_layer = determine_class_directive('grok.layer', factory, module_info, default=IDefaultBrowserLayer) view_name = util.class_annotation(factory, 'grok.name', '') checker = NamesChecker(allowed_names) if file: factory = FileResourceFactory(file, checker, view_name) elif image: factory = ImageResourceFactory(image, checker, view_name) adapts = (view_layer, ) config.action( discriminator=('adapter', adapts, IBrowserRequest, view_name), callable=zope.component.provideAdapter, args=(factory, adapts, IBrowserRequest, view_name), ) return True
def __init__(self, factory, provides=None, name=u'', direct=False): self.factory = factory self.direct = direct if provides is None: provides = util.class_annotation(factory, 'grok.provides', None) self.provides = provides if name is u'': name = util.class_annotation(factory, 'grok.name', u'') self.name = name
def grok(self, name, factory, module_info, config, *kws): factory.module_info = module_info self.factory_name = factory.__name__.lower() self.view_layer = determine_class_directive( 'grok.layer', factory, module_info, default=IDefaultBrowserLayer) self.view_name = util.class_annotation(factory, 'grok.name', self.factory_name) self.view_context = determine_class_directive( 'grok.context', factory, module_info, default=zope.interface.Interface) # is name defined for template? # if defined a named template is looked up factory._template_name = util.class_annotation(factory, 'grok.template', '') # __view_name__ is needed to support IAbsoluteURL on views # TODO check how this is working for these views factory.__view_name__ = self.view_name # don't know if this would ever need to be set self.provides = util.class_annotation(factory, 'grok.provides', self.provides) # safety belt: make sure that the programmer didn't use # @grok.require on any of the view's methods. methods = util.methods_from_class(factory) for method in methods: if getattr(method, '__grok_require__', None) is not None: raise GrokError( 'The @grok.require decorator is used for ' 'method %r in view %r. It may only be used ' 'for XML-RPC methods.' % (method.__name__, factory), factory) # sub classes must provide the registration self.register(factory, config) #print '\n'.join([str(factory), str(self.view_context), # str(self.view_layer), str(self.view_name), str(self.provides)]) permission = get_default_permission(factory) config.action( discriminator=('protectName', factory, '__call__'), callable=make_checker, args=(factory, factory, permission), ) return True
def grok(self, name, factory, context, module_info, templates): permission_name = util.class_annotation(factory, 'grok.name', None) if permission_name is None: raise GrokError( "A permission needs to have a dotted name for its id. Use " "grok.name to specify one.", factory) permission_name = unicode(permission_name) title = unicode( util.class_annotation(factory, 'grok.title', permission_name)) # TODO permission description component.provideUtility(Permission(permission_name, title=title), name=permission_name) return True
def grok(self, name, factory, context, module_info, templates): role_name = util.class_annotation(factory, 'grok.name', None) if role_name is None: raise GrokError( "A role needs to have a dotted name for its id. Use " "grok.name to specify one.", factory) title = unicode(util.class_annotation(factory, 'grok.title', role_name)) component.provideUtility(Role(role_name, title=title), name=role_name) permissions = util.class_annotation(factory, 'grok.permissions', ()) for permission in permissions: rolePermissionManager.grantPermissionToRole(permission, role_name) return True
def grok(self, name, factory, module_info, config, *kws): factory.module_info = module_info factory_name = factory.__name__.lower() # we need a path to the file containing the template template_name = util.class_annotation(factory, 'grok.template', factory_name) filepath = os.path.join(os.path.dirname(module_info.path), template_name) if not os.path.exists(filepath): filepath = None if os.path.exists(template_name): filepath = template_name if filepath is None: raise GrokError("No template found for %s." " Please use grok.template to define path to the" " file containing the template" % (factory.__name__), factory) macro = util.class_annotation(factory, 'mars.template.macro', None) contentType = util.class_annotation(factory, 'mars.template.content_type', 'text/html') view_layer = determine_class_directive('grok.layer', factory, module_info, default=IDefaultBrowserLayer) view_name = util.class_annotation(factory, 'grok.name', u'') view_context = determine_class_directive('grok.context', factory, module_info, default=zope.interface.Interface) provides = util.class_annotation(factory, 'grok.provides', self.provides) # now make the template factory proper factory = TemplateFactory(filepath, contentType, macro) zope.interface.directlyProvides(factory, provides) adapts = (view_context, view_layer) # print '\n',view_name,'\n',factory,'\n',provides,'\n',adapts config.action( discriminator=('adapter', adapts, provides, view_name), callable=zope.component.provideAdapter, args=(factory, adapts, provides, view_name), ) return True
def register(self, factory, config): manager = util.class_annotation(factory, 'mars.viewlet.manager', None) or module_info.getAnnotation( 'mars.viewlet.manager', None) or IViewletManager view = util.class_annotation(factory, 'mars.viewlet.view', None) or IBrowserView adapts = (self.view_context, self.view_layer, view, manager) config.action( discriminator=('adapter', adapts, self.provides, self.view_name), callable=zope.component.provideAdapter, args=(factory, adapts, self.provides, self.view_name), )
def grok(self, name, factory, context, module_info, templates): site = util.class_annotation(factory, 'grok.site', None) if site is None: raise GrokError( "No site specified for grok.Indexes " "subclass in module %r. " "Use grok.site() to specify." % module_info.getModule(), factory) indexes = util.class_annotation(factory, 'grok.indexes', None) if indexes is None: return False context = util.determine_class_context(factory, context) catalog_name = util.class_annotation(factory, 'grok.name', u'') zope.component.provideHandler(IndexesSetupSubscriber( catalog_name, indexes, context, module_info), adapts=(site, grok.IObjectAddedEvent)) return True
def grok(self, name, factory, module_info, config, **kws): factory.module_info = module_info factory_name = factory.__name__.lower() # we need a path to the file containing the template template_name = util.class_annotation(factory, 'grok.template', factory_name) filepath = os.path.join(os.path.dirname(module_info.path), template_name) if not os.path.exists(filepath): filepath = None if os.path.exists(template_name): filepath = template_name if filepath is None: raise GrokError( "No template found for %s." " Please use grok.template to define path to file." " containing the template" % (factory.__name__), factory) contentType = util.class_annotation(factory, 'mars.macro.content_type', 'text/html') view_layer = determine_class_directive('grok.layer', factory, module_info, default=IDefaultBrowserLayer) view_name = util.class_annotation(factory, 'grok.name', factory_name) macro = util.class_annotation(factory, 'mars.macro.macro', view_name) view = util.class_annotation(factory, 'mars.macro.view', IBrowserView) view_context = determine_class_directive( 'grok.context', factory, module_info, default=zope.interface.Interface) factory = MacroFactory(filepath, macro, contentType) adapts = (view_context, view, view_layer) config.action( discriminator=('adapter', adapts, IMacroTemplate, view_name), callable=zope.component.provideAdapter, args=(factory, adapts, IMacroTemplate, view_name), ) return True
def __init__(self, factory, provides=None, name=u'', setup=None, public=False, name_in_container=None): self.factory = factory if provides is None: provides = util.class_annotation(factory, 'grok.provides', None) self.provides = provides self.name = name self.setup = setup self.public = public self.name_in_container = name_in_container
def grok(self, name, factory, module_info, config, *kws): name = util.class_annotation(factory, 'grok.name', '') adapter_factory = util.class_annotation(factory, 'mars.adapter.factory', None) provides = zope.component.registry._getAdapterProvided(adapter_factory) adapter_context = zope.component.registry._getAdapterRequired( adapter_factory, None) #print '\n',name,'\n',adapter_factory,'\n',provides,'\n',adapter_context if adapter_factory is None: raise GrokError( "mars.adapter.factory must be provided for AdapterFactory") else: config.action( discriminator=('adapter', adapter_context[0], provides, name), callable=zope.component.provideAdapter, args=(adapter_factory, adapter_context, provides, name), ) return True
def register(self, factory, config): # is name defined for layout? # if defined a named template is looked up factory._layout_name = util.class_annotation(factory, 'mars.view.layout', '') adapts = (self.view_context, self.view_layer) config.action( discriminator=('adapter', adapts, self.provides, self.view_name), callable=zope.component.provideAdapter, args=(factory, adapts, self.provides, self.view_name), )
def register(self, factory, config): view = util.class_annotation(factory, 'mars.viewlet.view', None) or IBrowserView zope.component.provideAdapter(factory, adapts=(self.view_context, self.view_layer, view), provides=self.provides, name=self.view_name) adapts = (self.view_context, self.view_layer, view) config.action( discriminator=('adapter', adapts, self.provides, self.view_name), callable=zope.component.provideAdapter, args=(factory, adapts, self.provides, self.view_name), )
def get_default_permission(factory): """Determine the default permission for a view. There can be only 0 or 1 default permission. """ permissions = class_annotation(factory, 'grok.require', []) if not permissions: return None if len(permissions) > 1: raise GrokError('grok.require was called multiple times in ' '%r. It may only be set once for a class.' % factory, factory) result = permissions[0] check_permission(factory, result) return result
def localUtilityRegistrationSubscriber(site, event): """A subscriber that fires to set up local utilities. """ installed = getattr(site, '__grok_utilities_installed__', False) if installed: return for info in util.class_annotation(site.__class__, 'grok.utilities_to_install', []): setupUtility(site, info.factory(), info.provides, name=info.name, name_in_container=info.name_in_container, public=info.public, setup=info.setup) # we are done. If this subscriber gets fired again, we therefore # do not register utilities anymore site.__grok_utilities_installed__ = True
def grok(self, name, factory, context, module_info, templates): view_context = util.determine_class_context(factory, context) factory.module_info = module_info factory_name = factory.__name__.lower() if util.check_subclass(factory, components.GrokForm): # setup form_fields from context class if we've encountered a form if getattr(factory, 'form_fields', None) is None: factory.form_fields = formlib.get_auto_fields(view_context) if not getattr(factory.render, 'base_method', False): raise GrokError( "It is not allowed to specify a custom 'render' " "method for form %r. Forms either use the default " "template or a custom-supplied one." % factory, factory) # find templates template_name = util.class_annotation(factory, 'grok.template', factory_name) template = templates.get(template_name) if factory_name != template_name: # grok.template is being used if templates.get(factory_name): raise GrokError("Multiple possible templates for view %r. It " "uses grok.template('%s'), but there is also " "a template called '%s'." % (factory, template_name, factory_name), factory) if template: if (getattr(factory, 'render', None) and not util.check_subclass(factory, components.GrokForm)): # we do not accept render and template both for a view # (unless it's a form, they happen to have render. raise GrokError( "Multiple possible ways to render view %r. " "It has both a 'render' method as well as " "an associated template." % factory, factory) templates.markAssociated(template_name) factory.template = template else: if not getattr(factory, 'render', None): # we do not accept a view without any way to render it raise GrokError("View %r has no associated template or " "'render' method." % factory, factory) view_name = util.class_annotation(factory, 'grok.name', factory_name) # __view_name__ is needed to support IAbsoluteURL on views factory.__view_name__ = view_name component.provideAdapter(factory, adapts=(view_context, IDefaultBrowserLayer), provides=interface.Interface, name=view_name) # protect view, public by default default_permission = get_default_permission(factory) make_checker(factory, factory, default_permission) # safety belt: make sure that the programmer didn't use # @grok.require on any of the view's methods. methods = util.methods_from_class(factory) for method in methods: if getattr(method, '__grok_require__', None) is not None: raise GrokError('The @grok.require decorator is used for ' 'method %r in view %r. It may only be used ' 'for XML-RPC methods.' % (method.__name__, factory), factory) return True
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