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