cubicweb: comparison server/hook.py

equal deleted inserted replaced

-:2ee0ef069fa7
+:2a3c1b787688
-# copyright 2003-2011 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# copyright 2003-2012 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
 # contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
 #
 # This file is part of CubicWeb.
 #
 # CubicWeb is free software: you can redistribute it and/or modify it under the
 :class:`~cubicweb.server.session.hooks_control` context manager to
 filter them in or out. Note that ending the transaction with commit()
 or rollback() will restore the hooks.
-Hooks specific selector
+Hooks specific predicate
 ~~~~~~~~~~~~~~~~~~~~~~~
 .. autoclass:: cubicweb.server.hook.match_rtype
 .. autoclass:: cubicweb.server.hook.match_rtype_sets
 from itertools import chain
 from logilab.common.decorators import classproperty, cached
 from logilab.common.deprecation import deprecated, class_renamed
 from logilab.common.logging_ext import set_log_methods
+from logilab.common.registry import (Predicate, NotPredicate, OrPredicate,
+classid, objectify_predicate, yes)
 from cubicweb import RegistryNotFound
-from cubicweb.vregistry import classid
+from cubicweb.cwvreg import CWRegistry, CWRegistryStore
-from cubicweb.cwvreg import CWRegistry, VRegistry
+from cubicweb.predicates import ExpectedValuePredicate, is_instance
-from cubicweb.selectors import (objectify_selector, lltrace, ExpectedValueSelector,
+from cubicweb.appobject import AppObject
-is_instance)
-from cubicweb.appobject import AppObject, NotSelector, OrSelector
 from cubicweb.server.session import security_enabled
 ENTITIES_HOOKS = set(('before_add_entity',    'after_add_entity',
 'before_update_entity', 'after_update_entity',
 'before_delete_entity', 'after_delete_entity'))
 the idea is to make a first pass over all the hooks in the
 registry and to mark put some of them in a pruned list. The
 pruned hooks are the one which:
 * are disabled at the session level
-* have a match_rtype or an is_instance selector which does not
-match the rtype / etype of the relations / entities for
+* have a selector containing a :class:`match_rtype` or an
-which we are calling the hooks. This works because the
+:class:`is_instance` predicate which does not match the rtype / etype
-repository calls the hooks grouped by rtype or by etype when
+of the relations / entities for which we are calling the hooks. This
-using the entities or eids_to_from keyword arguments
+works because the repository calls the hooks grouped by rtype or by
+etype when using the entities or eids_to_from keyword arguments
-Only hooks with a simple selector or an AndSelector of simple
-selectors are considered for disabling.
+Only hooks with a simple predicate or an AndPredicate of simple
+predicates are considered for disabling.
 """
 if 'entity' in kwargs:
 entities = [kwargs['entity']]
 if len(entities):
 return # no hooks for this event
 registry.call_hooks(event, session, **kwargs)
 for event in ALL_HOOKS:
-VRegistry.REGISTRY_FACTORY['%s_hooks' % event] = HooksRegistry
+CWRegistryStore.REGISTRY_FACTORY['%s_hooks' % event] = HooksRegistry
 @deprecated('[3.10] use entity.cw_edited.oldnewvalue(attr)')
 def entity_oldnewvalue(entity, attr):
 return entity.cw_edited.oldnewvalue(attr)
-# some hook specific selectors #################################################
+# some hook specific predicates #################################################
-@objectify_selector
+@objectify_predicate
-@lltrace
 def enabled_category(cls, req, **kwargs):
 if req is None:
 return True # XXX how to deactivate server startup / shutdown event
 return req.is_hook_activated(cls)
-@objectify_selector
+@objectify_predicate
-@lltrace
 def from_dbapi_query(cls, req, **kwargs):
 if req.running_dbapi_query:
 return 1
 return 0
 self.iterators = iterators
 def __iter__(self):
 return iter(chain(*self.iterators))
-class match_rtype(ExpectedValueSelector):
+class match_rtype(ExpectedValuePredicate):
 """accept if parameters specified as initializer arguments are specified
-in named arguments given to the selector
+in named arguments given to the predicate
 :param \*expected: parameters (eg `basestring`) which are expected to be
 found in named arguments (kwargs)
 """
 def __init__(self, *expected, **more):
 self.expected = expected
 self.frometypes = more.pop('frometypes', None)
 self.toetypes = more.pop('toetypes', None)
 assert not more, "unexpected kwargs in match_rtype: %s" % more
-@lltrace
 def __call__(self, cls, req, *args, **kwargs):
 if kwargs.get('rtype') not in self.expected:
 return 0
 if self.frometypes is not None and \
 req.describe(kwargs['eidfrom'])[0] not in self.frometypes:
 req.describe(kwargs['eidto'])[0] not in self.toetypes:
 return 0
 return 1
-class match_rtype_sets(ExpectedValueSelector):
+class match_rtype_sets(ExpectedValuePredicate):
 """accept if the relation type is in one of the sets given as initializer
-argument. The goal of this selector is that it keeps reference to original sets,
+argument. The goal of this predicate is that it keeps reference to original sets,
-so modification to thoses sets are considered by the selector. For instance
+so modification to thoses sets are considered by the predicate. For instance
 MYSET = set()
 class Hook1(Hook):
 __regid__ = 'hook1'
 """
 def __init__(self, *expected):
 self.expected = expected
-@lltrace
 def __call__(self, cls, req, *args, **kwargs):
 for rel_set in self.expected:
 if kwargs.get('rtype') in rel_set:
 return 1
 return 0
 @classmethod
 @cached
 def filterable_selectors(cls):
 search = cls.__select__.search_selector
-if search((NotSelector, OrSelector)):
+if search((NotPredicate, OrPredicate)):
 return None, None
 enabled_cat = search(enabled_category)
 main_filter = search((is_instance, match_rtype))
 return enabled_cat, main_filter
 This hook ensure that when one of the watched relation is added, the
 `main_rtype` relation is added to the target entity of the relation.
 Notice there are no default behaviour defined when a watched relation is
 deleted, you'll have to handle this by yourself.
-You usually want to use the :class:`match_rtype_sets` selector on concrete
+You usually want to use the :class:`match_rtype_sets` predicate on concrete
 classes.
 """
 events = ('after_add_relation',)
 # to set in concrete class

changeset 8190	2a3c1b787688
parent 8032	bcb87336c7d2
child 8211	543e1579ba0d