def __init__(self, *interfaces):
# Override the z.c.adapter decorator to force sanity checking
# and have better error reporting.
if not interfaces:
raise GrokImportError(
"@grok.adapter requires at least one argument.")
if type(interfaces[0]) is types.FunctionType:
raise GrokImportError(
"@grok.adapter requires at least one argument.")
self.interfaces = interfaces
def factory(self, storename, uri):
if martian.util.not_unicode_or_ascii(storename):
raise GrokImportError(
"You can only pass unicode or ASCII"
"to megrok.storm.Store to the '%s' directive." % self.name)
if martian.util.not_unicode_or_ascii(uri):
raise GrokImportError(
"You can only pass unicode or ASCII"
"to megrok.storm.Store to the '%s' directive." % self.name)
return (storename, uri)
def __init__(self, *args, **kw):
frame = sys._getframe(1)
if not frame_is_class(frame):
raise GrokImportError(
"%r can only be instantiated on class level." % self.__class__)
if not IAttributeIndex.implementedBy(self.index_class):
raise GrokImportError(
"%r does not implement IAttributeIndex." % self.__class__)
# Store any extra parameters to pass to index later.
self._args = args
self._attribute = kw.pop('attribute', None)
self._kw = kw
def validateLocalPath(directive, value):
martian.validateText(directive, value)
if os.path.sep in value:
raise GrokImportError(
"The '%s' directive can not contain path separator."
% directive.name)
# XXX kinda hackish...
dirname = os.path.dirname(directive.frame.f_locals['__file__'])
if not os.path.isdir(os.path.join(dirname, value)):
raise GrokImportError(
"The directory '%s' specified by the '%s' directive "
"cannot be found." % (value, directive.name))
def __call__(self, function):
frame = sys._getframe(1)
if not frame_is_module(frame):
raise GrokImportError("@grok.subscribe can only be used on module "
"level.")
if not self.subscribed:
raise GrokImportError("@grok.subscribe requires at least one "
"argument.")
subscribers = frame.f_locals.get('__grok_subscribers__', None)
if subscribers is None:
frame.f_locals['__grok_subscribers__'] = subscribers = []
subscribers.append((function, self.subscribed))
def factory(self,
factory,
provides=None,
name=u'',
setup=None,
public=False,
name_in_container=None):
if provides is not None and not IInterface.providedBy(provides):
raise GrokImportError("You can only pass an interface to the "
"provides argument of %s." % self.name)
if provides is None:
# We cannot bind the provides directive and get information
# from the factory, so we do it "manually" as we know how
# to get to the information.
dotted = grokcore.component.provides.dotted_name()
provides = getattr(factory, dotted, None)
if provides is None:
if util.check_subclass(factory, LocalUtility):
baseInterfaces = interface.implementedBy(LocalUtility)
utilityInterfaces = interface.implementedBy(factory)
provides = list(utilityInterfaces - baseInterfaces)
if len(provides) == 0 and len(list(utilityInterfaces)) > 0:
raise GrokImportError(
"Cannot determine which interface to use "
"for utility registration of %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." % factory, factory)
else:
provides = list(interface.implementedBy(factory))
util.check_implements_one_from_list(provides, factory)
provides = provides[0]
if (provides, name) in self.frame.f_locals.get(self.dotted_name(), {}):
raise GrokImportError(
"Conflicting local utility registration %r. "
"Local utilities are registered multiple "
"times for interface %r and name %r." %
(factory, provides, name), factory)
info = LocalUtilityInfo(factory, provides, name, setup, public,
name_in_container)
return (provides, name), info
def validate(self, value):
if util.check_subclass(value, components.Permission):
return
if util.not_unicode_or_ascii(value):
raise GrokImportError(
"You can only pass unicode, ASCII, or a subclass "
"of grok.Permission to the '%s' directive." % self.name)
def __init__(self, *args, **kw):
frame = sys._getframe(1)
if not frame_is_class(frame):
raise GrokImportError(
"%r can only be instantiated on class level." % self.__class__)
# Store any extra parameters to pass to index later.
self._args = args
self._kw = kw
def set(self, locals_, directive, value):
values_dict = locals_.setdefault(directive.dotted_name(), {})
try:
key, value = value
except (TypeError, ValueError):
raise GrokImportError(
"The factory method for the '%s' directive should return a "
"key-value pair." % directive.name)
values_dict[key] = value
def validate(self, directive, *args, **kw):
try:
if issubclass(directive, Directive):
return
except TypeError:
# directive is not a class, so error too
pass
raise GrokImportError("The '%s' directive can only be called with "
"a directive." % self.name)
def validate(self, *values):
for value in values:
if martian.util.check_subclass(value, components.Permission):
continue
if martian.util.not_unicode_or_ascii(value):
raise GrokImportError(
"You can only pass unicode values, ASCII values, or "
"subclasses of grok.Permission to the '%s' directive." %
self.name)
def __init__(self, *interfaces, **kw):
if not interfaces:
raise GrokImportError(
"@grok.adapter requires at least one argument.")
if type(interfaces[0]) is types.FunctionType:
raise GrokImportError(
"@grok.adapter requires at least one argument.")
self.name = u""
if kw:
if 'name' in kw:
self.name = kw.pop('name')
if kw:
raise GrokImportError(
"@grok.adapter got unexpected keyword arguments: %s" %
','.join(kw.keys()))
zope.component.adapter.__init__(self, *interfaces)
def set(self, locals_, directive, value):
if directive.dotted_name() in locals_:
raise GrokImportError(
"The '%s' directive can only be called once per %s." %
(directive.name, directive.scope.description))
# Make use of the implementation details of interface tagged
# values. Instead of being able to call "setTaggedValue()"
# on an interface object, we only have access to the "locals"
# of the interface object. We inject whatever setTaggedValue()
# would've injected.
taggeddata = locals_.setdefault(TAGGED_DATA, {})
taggeddata[directive.dotted_name()] = value
def factory(self, factory, adapts=None, provides=None, name=None):
if provides is not None and not IInterface.providedBy(provides):
raise GrokImportError(
"You can only pass an interface to the "
"provides argument of %s." % self.name)
if adapts is None:
adapts = getattr(factory, '__component_adapts__', None)
elif not isinstance(adapts, (list, tuple,)):
adapts = (adapts,)
elif isinstance(adapts, list):
adapts = tuple(adapts)
return (factory, adapts, provides, name)
def __call__(self, function):
frame = sys._getframe(1)
if not frame_is_module(frame):
raise GrokImportError("@grok.subscribe can only be used on module "
"level.")
if not self.subscribed:
raise GrokImportError("@grok.subscribe requires at least one "
"argument.")
# Add the function and subscribed interfaces to the
# grok.subscribers module annotation.
subscribers = frame.f_locals.get('__grok_subscribers__', None)
if subscribers is None:
frame.f_locals['__grok_subscribers__'] = subscribers = []
subscribers.append((function, self.subscribed))
# Also store the subscribed interfaces on the
# attribute__component_adapts__ for provideHandler to register
# the subscriber (in case you don't grok your package and
# register it manually)
return zope.component.adapter(*self.subscribed)(function)
def __init__(self, *args, **kw):
self.name = self.__class__.__name__
self.frame = frame = sys._getframe(1)
if not self.scope.check(frame):
raise GrokImportError(
"The '%s' directive can only be used on %s level." %
(self.name, self.scope.description))
self.check_factory_signature(*args, **kw)
validate = getattr(self, 'validate', None)
if validate is not None:
validate(*args, **kw)
value = self.factory(*args, **kw)
self.store.set(frame.f_locals, self, value)
def execute(self, form, config, context, layer, name, permission, wrap,
**kw):
if permission is None:
permission = self.default_permissions.get(form.__class__,
self.permission_fallback)
if issubclass(form, AutoExtensibleForm):
if getattr(form, 'schema', None) is None:
if issubclass(
form,
(EditForm, Form)) and IInterface.providedBy(context):
form.schema = context
else:
raise GrokImportError(
u"The schema form %s must have a 'schema' attribute "
"defining a schema interface for the form. If you want "
"to set up your fields manually, use a non-schema form "
"base class instead." % (form.__name__))
form.__view_name__ = name
if wrap is None:
wrap = DEFAULT_WRAP
# Only use the wrapper view if we are on Zope < 2.12
if wrap:
factory = wrap_form(form)
factory.__view_name__ = name
else:
factory = form
page_directive(config,
name=name,
permission=permission,
for_=context,
layer=layer,
class_=factory)
return True
def check_arguments(self, factory, provides=None, name=u'',
direct=False):
if provides is not None and not IInterface.providedBy(provides):
raise GrokImportError("You can only pass an interface to the "
"provides argument of %s." % self.name)
def check_arguments(self, factory, provides=None, name=u'',
setup=None, public=False, name_in_container=None):
if provides is not None and not IInterface.providedBy(provides):
raise GrokImportError("You can only pass an interface to the "
"provides argument of %s." % self.name)
def validateInterface(directive, value):
if not (IInterface.providedBy(value)):
raise GrokImportError("The '%s' directive can only be called with "
"an interface." % directive.name)
def validateClass(directive, value):
if not util.isclass(value):
raise GrokImportError("The '%s' directive can only be called with "
"a class." % directive.name)
def validateInterfaceOrClass(directive, value):
if not (IInterface.providedBy(value) or util.isclass(value)):
raise GrokImportError("The '%s' directive can only be called with "
"a class or an interface." % directive.name)
def validateText(directive, value):
if util.not_unicode_or_ascii(value):
raise GrokImportError("The '%s' directive can only be called with "
"unicode or ASCII." % directive.name)
def set(self, locals_, directive, value):
if directive.dotted_name() in locals_:
raise GrokImportError(
"The '%s' directive can only be called once per %s." %
(directive.name, directive.scope.description))
locals_[directive.dotted_name()] = value
