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
