cubicweb: comparison cwvreg.py

equal deleted inserted replaced

-:c25da7573ebd
+:02b52bf9f5f8
 :license: GNU Lesser General Public License, v2.1 - http://www.gnu.org/licenses
 """
 __docformat__ = "restructuredtext en"
 _ = unicode
-from logilab.common.decorators import cached, clear_cache, monkeypatch
+from logilab.common.decorators import cached, clear_cache
 from logilab.common.deprecation import  deprecated
 from logilab.common.modutils import cleanup_sys_modules
 from rql import RQLHelper
 from cubicweb import (ETYPE_NAME_MAP, Binary, UnknownProperty, UnknownEid,
 ObjectNotFound, NoSelectableObject, RegistryNotFound,
 RegistryOutOfDate, CW_EVENT_MANAGER, onevent)
 from cubicweb.utils import dump_class
-from cubicweb.vregistry import VRegistry, Registry
+from cubicweb.vregistry import VRegistry, Registry, class_regid
 from cubicweb.rtags import RTAGS
 @onevent('before-registry-reload')
 def clear_rtag_objects():
 @property
 def schema(self):
 return self.vreg.schema
-def initialization_completed(self):
+@deprecated('[3.6] select object, then use obj.render()')
-# call vreg_initialization_completed on appobjects and print
-# registry content
-for appobjects in self.itervalues():
-for appobject in appobjects:
-# XXX kill vreg_initialization_completed
-appobject.vreg_initialization_completed()
 def render(self, __oid, req, __fallback_oid=None, rset=None, initargs=None,
 **kwargs):
 """Select object with the given id (`__oid`) then render it.  If the
 object isn't selectable, try to select fallback object if
 `__fallback_oid` is specified.
 if __fallback_oid is None:
 raise
 obj = self.select(__fallback_oid, req, rset=rset, **initargs)
 return obj.render(**kwargs)
+@deprecated('[3.6] use select_or_none and test for obj.cw_propval("visible")')
 def select_vobject(self, oid, *args, **kwargs):
-selected = self.select_object(oid, *args, **kwargs)
+selected = self.select_or_none(oid, *args, **kwargs)
-if selected and selected.propval('visible'):
+if selected and selected.cw_propval('visible'):
 return selected
 return None
-def possible_vobjects(self, *args, **kwargs):
+def poss_visible_objects(self, *args, **kwargs):
 """return an ordered list of possible app objects in a given registry,
 supposing they support the 'visible' and 'order' properties (as most
 visualizable objects)
 """
 return sorted([x for x in self.possible_objects(*args, **kwargs)
-if x.propval('visible')],
+if x.cw_propval('visible')],
-key=lambda x: x.propval('order'))
+key=lambda x: x.cw_propval('order'))
+possible_vobjects = deprecated('[3.6] use poss_visible_objects()')(poss_visible_objects)
 VRegistry.REGISTRY_FACTORY[None] = CWRegistry
 """on registration completed, clear etype_class internal cache
 """
 super(ETypeRegistry, self).initialization_completed()
 # clear etype cache if you don't want to run into deep weirdness
 clear_cache(self, 'etype_class')
+clear_cache(self, 'parent_classes')
 def register(self, obj, **kwargs):
-oid = kwargs.get('oid') or obj.id
+oid = kwargs.get('oid') or class_regid(obj)
 if oid != 'Any' and not oid in self.schema:
 self.error('don\'t register %s, %s type not defined in the '
-'schema', obj, obj.id)
+'schema', obj, oid)
 return
 kwargs['clear'] = True
 super(ETypeRegistry, self).register(obj, **kwargs)
 @cached
+def parent_classes(self, etype):
+if etype == 'Any':
+return [self.etype_class('Any')]
+eschema = self.schema.eschema(etype)
+parents = [self.etype_class(e.type) for e in eschema.ancestors()]
+parents.append(self.etype_class('Any'))
+return parents
+@cached
 def etype_class(self, etype):
 """return an entity class for the given entity type.
 Try to find out a specific class for this kind of entity or default to a
 dump of the nearest parent class (in yams inheritance) registered.
 Fall back to 'Any' if not yams parent class found.
 """
 etype = str(etype)
 if etype == 'Any':
-return self.select('Any', 'Any')
+objects = self['Any']
+assert len(objects) == 1, objects
+return objects[0]
 eschema = self.schema.eschema(etype)
 baseschemas = [eschema] + eschema.ancestors()
 # browse ancestors from most specific to most generic and try to find an
 # associated custom entity class
-cls = None
 for baseschema in baseschemas:
 try:
 btype = ETYPE_NAME_MAP[baseschema]
 except KeyError:
 btype = str(baseschema)
-if cls is None:
+try:
-try:
+objects = self[btype]
-objects = self[btype]
+assert len(objects) == 1, objects
-assert len(objects) == 1, objects
+if btype == etype:
-if btype == etype:
+cls = objects[0]
-cls = objects[0]
+else:
-else:
+# recurse to ensure issubclass(etype_class('Child'),
-cls = self.etype_class(btype)
+#                              etype_class('Parent'))
-except ObjectNotFound:
+cls = self.etype_class(btype)
-continue
+break
-else:
+except ObjectNotFound:
-# ensure parent classes are built first
+pass
-self.etype_class(btype)
+else:
-if cls is None:
 # no entity class for any of the ancestors, fallback to the default
 # one
 objects = self['Any']
 assert len(objects) == 1, objects
 cls = objects[0]
-# make a copy event if cls.id == etype, else we may have pb for client
+# make a copy event if cls.__regid__ == etype, else we may have pb for
-# application using multiple connections to different repositories (eg
+# client application using multiple connections to different
-# shingouz)
+# repositories (eg shingouz)
 cls = dump_class(cls, etype)
-cls.id = etype
+cls.__regid__ = etype
-cls.__initialize__()
+cls.__initialize__(self.schema)
 return cls
 VRegistry.REGISTRY_FACTORY['etypes'] = ETypeRegistry
 class ViewsRegistry(CWRegistry):
-def main_template(self, req, oid='main-template', **kwargs):
+def main_template(self, req, oid='main-template', rset=None, **kwargs):
 """display query by calling the given template (default to main),
 and returning the output as a string instead of requiring the [w]rite
 method as argument
 """
-res = self.render(oid, req, **kwargs)
+obj = self.select(oid, req, rset=rset, **kwargs)
+res = obj.render(**kwargs)
 if isinstance(res, unicode):
 return res.encode(req.encoding)
 assert isinstance(res, str)
 return res
 """
 for vid, views in self.items():
 if vid[0] == '_':
 continue
 try:
-view = self.select_best(views, req, rset=rset, **kwargs)
+view = self._select_best(views, req, rset=rset, **kwargs)
 if view.linkable():
 yield view
 except NoSelectableObject:
 continue
 except Exception:
 class ActionsRegistry(CWRegistry):
 def possible_actions(self, req, rset=None, **kwargs):
 if rset is None:
-actions = self.possible_vobjects(req, rset=rset, **kwargs)
+actions = self.poss_visible_objects(req, rset=rset, **kwargs)
 else:
 actions = rset.possible_actions(**kwargs) # cached implementation
 result = {}
 for action in actions:
 result.setdefault(action.category, []).append(action)
 for obj in objects:
 obj.schema = schema
 def register_if_interface_found(self, obj, ifaces, **kwargs):
 """register an object but remove it if no entity class implements one of
-the given interfaces
+the given interfaces at the end of the registration process
 """
 self.register(obj, **kwargs)
 if not isinstance(ifaces,  (tuple, list)):
 self._needs_iface[obj] = (ifaces,)
 else:
 def register_objects(self, path, force_reload=None):
 """overriden to remove objects requiring a missing interface"""
 if force_reload is None:
 force_reload = self.config.debugmode
 try:
-self._register_objects(path, force_reload)
+super(CubicWebVRegistry, self).register_objects(
+path, force_reload, self.config.extrapath)
 except RegistryOutOfDate:
 CW_EVENT_MANAGER.emit('before-registry-reload')
 # modification detected, reset and reload
 self.reset(path, force_reload)
-self._register_objects(path, force_reload)
+super(CubicWebVRegistry, self).register_objects(
+path, force_reload, self.config.extrapath)
 CW_EVENT_MANAGER.emit('after-registry-reload')
-def _register_objects(self, path, force_reload=None):
-"""overriden to remove objects requiring a missing interface"""
-extrapath = {}
-for cubesdir in self.config.cubes_search_path():
-if cubesdir != self.config.CUBES_DIR:
-extrapath[cubesdir] = 'cubes'
-if super(CubicWebVRegistry, self).register_objects(path, force_reload,
-extrapath):
-self.initialization_completed()
-# don't check rtags if we don't want to cleanup_interface_sobjects
-for rtag in RTAGS:
-rtag.init(self.schema,
-check=self.config.cleanup_interface_sobjects)
 def initialization_completed(self):
-for regname, reg in self.iteritems():
+"""cw specific code once vreg initialization is completed:
-self.debug('available in registry %s: %s', regname, sorted(reg))
-reg.initialization_completed()
+* remove objects requiring a missing interface, unless
-for appobjects in reg.itervalues():
+config.cleanup_interface_sobjects is false
-for appobjectcls in appobjects:
+* init rtags
-appobjectcls.register_properties()
+"""
 # we may want to keep interface dependent objects (e.g.for i18n
 # catalog generation)
 if self.config.cleanup_interface_sobjects:
 # remove appobjects that don't support any available interface
 implemented_interfaces = set()
 'interface among %s)', obj, ifaces)
 self.unregister(obj)
 # clear needs_iface so we don't try to remove some not-anymore-in
 # objects on automatic reloading
 self._needs_iface.clear()
+super(CubicWebVRegistry, self).initialization_completed()
+for rtag in RTAGS:
+# don't check rtags if we don't want to cleanup_interface_sobjects
+rtag.init(self.schema, check=self.config.cleanup_interface_sobjects)
 # rql parsing utilities ####################################################
 @property
 @cached
 def property_value(self, key):
 try:
 return self['propertyvalues'][key]
 except KeyError:
-return self['propertydefs'][key]['default']
+return self.property_info(key)['default']
 def typed_value(self, key, value):
 """value is an unicode string, return it correctly typed. Let potential
 type error propagates.
 """

branch	oldstable
changeset 4985	02b52bf9f5f8
parent 4719	aaed3f813ef8
child 4966	e968e0a7776b