cubicweb: comparison vregistry.py

equal deleted inserted replaced

-:2c3711d4570b
+:091ac3ba5d51
 objects and provide a convenient api access to those objects
 according to a context
 * to interact with the vregistry, object should inherit from the
 VObject abstract class
 * the selection procedure has been generalized by delegating to a
 selector, which is responsible to score the vobject according to the
 current state (req, rset, row, col). At the end of the selection, if
 a vobject class has been found, an instance of this class is
 returned. The selector is instantiated at vobject registration
 class VObject(object):
 """visual object, use to be handled somehow by the visual components
 registry.
 The following attributes should be set on concret vobject subclasses:
 :__registry__:
 name of the registry for this object (string like 'views',
 'templates'...)
 :id:
 object's identifier in the registry (string like 'main',
 'primary', 'folder_box')
 :__select__:
 class'selector
 Moreover, the `__abstract__` attribute may be set to True to indicate
 that a vobject is abstract and should not be registered
 """
 # necessary attributes to interact with the registry
 id = None
 return cls
 @classmethod
 def selected(cls, *args, **kwargs):
 """called by the registry when the vobject has been selected.
 It must return the  object that will be actually returned by the
 .select method (this may be the right hook to create an
 instance for example). By default the selected object is
 returned without any transformation.
 """
 class VRegistry(object):
 """class responsible to register, propose and select the various
 elements used to build the web interface. Currently, we have templates,
 views, actions and components.
 """
 def __init__(self, config):#, cache_size=1000):
 self.config = config
 # dictionnary of registry (themself dictionnary) by name
 self._registries = {}
 self._lastmodifs = {}
 oid = obj.id
 except AttributeError:
 continue
 if oid:
 self.register(obj)
 def register(self, obj, registryname=None, oid=None, clear=False):
 """base method to add an object in the registry"""
 assert not '__abstract__' in obj.__dict__
 registryname = registryname or obj.__registry__
 oid = oid or obj.id
 self.warning('can\'t remove %s, not in the %s registry with id %s',
 removed_id, registryname, obj.id)
 #                 else:
 #                     # if objects is empty, remove oid from registry
 #                     if not registry[obj.id]:
 #                         del regcontent[oid]
 break
 def register_and_replace(self, obj, replaced, registryname=None):
 if hasattr(replaced, 'classid'):
 replaced = replaced.classid()
 registryname = registryname or obj.__registry__
 registry = self.registry(registryname)
 del registry[obj.id][index]
 break
 self.register(obj, registryname=registryname)
 # dynamic selection methods ###############################################
 def select(self, vobjects, *args, **kwargs):
 """return an instance of the most specific object according
 to parameters
 raise NoSelectableObject if not object apply
 % (args, kwargs.keys(),
 [repr(v) for v in winners]))
 winner = winners[0]
 # return the result of the .selected method of the vobject
 return winner.selected(*args, **kwargs)
 def possible_objects(self, registry, *args, **kwargs):
 """return an iterator on possible objects in a registry for this result set
 actions returned are classes, not instances
 """
 continue
 def select_object(self, registry, cid, *args, **kwargs):
 """return the most specific component according to the resultset"""
 return self.select(self.registry_objects(registry, cid), *args, **kwargs)
 # intialization methods ###################################################
 def init_registration(self, path):
 # compute list of all modules that have to be loaded
 self._toloadmods, filemods = _toload_info(path)
 self._loadedmods = {}
 return filemods
 def register_objects(self, path, force_reload=None):
 if force_reload is None:
 force_reload = self.config.mode == 'dev'
 elif not force_reload:
 # force_reload == False usually mean modules have been reloaded
 change = False
 for filepath, modname in filemods:
 if self.load_file(filepath, modname, force_reload):
 change = True
 return change
 def load_file(self, filepath, modname, force_reload=False):
 """load visual objects from a python file"""
 from logilab.common.modutils import load_module_from_name
 if modname in self._loadedmods:
 return
 unregistered = None
 # load the module
 module = load_module_from_name(modname, use_sys=not force_reload)
 self.load_module(module)
 # if something was unregistered, we need to update places where it was
 # referenced
 if unregistered:
 # oldnew_mapping = {}
 registered = self._loadedmods[modname]
 oldnew_mapping = dict((unregistered[name], registered[name])
 for name in unregistered if name in registered)
 for objname, obj in vars(module).items():
 if objname.startswith('_'):
 continue
 self._load_ancestors_then_object(module.__name__, obj)
 self.debug('loaded %s', module)
 def _load_ancestors_then_object(self, modname, obj):
 # imported classes
 objmodname = getattr(obj, '__module__', None)
 if objmodname != modname:
 if objmodname in self._toloadmods:
 return
 self._loadedmods[modname][objname] = obj
 for parent in obj.__bases__:
 self._load_ancestors_then_object(modname, parent)
 self.load_object(obj)
 def load_object(self, obj):
 try:
 self.register_vobject_class(obj)
 except Exception, ex:
 if self.config.mode in ('test', 'dev'):
 raise
 self.exception('vobject %s registration failed: %s', obj, ex)
 # old automatic registration XXX deprecated ###############################
 def register_vobject_class(self, cls):
 """handle vobject class registration
 vobject class with __abstract__ == True in their local dictionnary or
 with a name starting starting by an underscore are not registered.
 Also a vobject class needs to have __registry__ and id attributes set
 to a non empty string to be registered.
 """
 return
 regname = cls.__registry__
 if '%s.%s' % (regname, cls.id) in self.config['disable-appobjects']:
 return
 self.register(cls)
 def unregister_module_vobjects(self, modname):
 """removes registered objects coming from a given module
 returns a dictionnary classid/class of all classes that will need
 to be updated after reload (i.e. vobjects referencing classes defined
 # update obj's baseclasses tuple (__bases__) if needed
 if newbases != obj.__bases__:
 self.debug('updating %s.%s base classes',
 obj.__module__, obj.__name__)
 obj.__bases__ = newbases
 # init logging
 set_log_methods(VObject, getLogger('cubicweb'))
 set_log_methods(VRegistry, getLogger('cubicweb.registry'))
 # selector base classes and operations ########################################
 return self
 return None
 def __str__(self):
 return self.__class__.__name__
 def __and__(self, other):
 return AndSelector(self, other)
 def __rand__(self, other):
 return AndSelector(other, self)
 def __ror__(self, other):
 return OrSelector(other, self)
 def __invert__(self):
 return NotSelector(self)
 # XXX (function | function) or (function & function) not managed yet
 def __call__(self, cls, *args, **kwargs):
 return NotImplementedError("selector %s must implement its logic "
 "in its __call__ method" % self.__class__)
 class MultiSelector(Selector):
 """base class for compound selector classes"""
 def __init__(self, *selectors):
 self.selectors = self.merge_selectors(selectors)
 def __str__(self):
 return '%s(%s)' % (self.__class__.__name__,
 found = childselector.search_selector(selector)
 if found is not None:
 return found
 return None
 def objectify_selector(selector_func):
 """convenience decorator for simple selectors where a class definition
 would be overkill::
 @objectify_selector
 def yes(cls, *args, **kwargs):
 return 1
 """
 return type(selector_func.__name__, (Selector,),
 {'__call__': lambda self, *args, **kwargs: selector_func(*args, **kwargs)})
 def _instantiate_selector(selector):
 """ensures `selector` is a `Selector` instance
 NOTE: This should only be used locally in build___select__()
 XXX: then, why not do it ??
 """
 if isinstance(selector, types.FunctionType):
 return objectify_selector(selector)()

branch	tls-sprint
changeset 1433	091ac3ba5d51
parent 1432	2c3711d4570b
child 1641	2c80b09d8d86