cubicweb: comparison cwvreg.py

equal deleted inserted replaced

-:716f0742ee7f
+:5c1ec97f317e
 :contact: http://www.logilab.fr/ -- mailto:contact@logilab.fr
 """
 __docformat__ = "restructuredtext en"
 from logilab.common.decorators import cached, clear_cache
-from logilab.common.interface import extend
 from rql import RQLHelper
 from cubicweb import Binary, UnknownProperty, UnknownEid
 from cubicweb.vregistry import VRegistry, ObjectNotFound, NoSelectableObject
 selectors, with a bw compat fallback to accepts_interfaces attribute
 """
 from cubicweb.selectors import implements
 try:
 # XXX deprecated
 return sorted(obj.accepts_interfaces)
 except AttributeError:
 try:
 impl = obj.__select__.search_selector(implements)
 if impl:
 return sorted(impl.expected_ifaces)
 return ()
 class CubicWebRegistry(VRegistry):
 """extend the generic VRegistry with some cubicweb specific stuff"""
 def __init__(self, config, debug=None, initlog=True):
 if initlog:
 # first init log service
 config.init_log(debug=debug)
 super(CubicWebRegistry, self).__init__(config)
 self.schema = None
 self.reset()
 self.initialized = False
 def items(self):
 return [item for item in self._registries.items()
 if not item[0] in ('propertydefs', 'propertyvalues')]
 def values(self):
 return [value for key, value in self._registries.items()
 if not key in ('propertydefs', 'propertyvalues')]
 def reset(self):
 self._registries = {}
 self._lastmodifs = {}
 self._needs_iface = {}
 # two special registries, propertydefs which care all the property
 # properties
 self._registries['propertydefs'] = {}
 self._registries['propertyvalues'] = self.eprop_values = {}
 for key, propdef in self.config.eproperty_definitions():
 self.register_property(key, **propdef)
 def set_schema(self, schema):
 """set application'schema and load application objects"""
 self.schema = schema
 clear_cache(self, 'rqlhelper')
 # now we can load application's web objects
 self.register_objects(self.config.vregistry_path())
 def update_schema(self, schema):
 """update .schema attribute on registered objects, necessary for some
 tests
 """
 self.schema = schema
 super(CubicWebRegistry, self).register(obj, **kwargs)
 # XXX bw compat
 ifaces = use_interfaces(obj)
 if ifaces:
 self._needs_iface[obj] = ifaces
 def register_objects(self, path, force_reload=None):
 """overriden to remove objects requiring a missing interface"""
 if super(CubicWebRegistry, self).register_objects(path, force_reload):
 # clear etype cache if you don't want to run into deep weirdness
 clear_cache(self, 'etype_class')
 self.debug('available in registry %s: %s', registry,
 sorted(objects))
 for appobjects in objects.itervalues():
 for appobject in appobjects:
 appobject.vreg_initialization_completed()
 @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 class registered for 'Any'
 pass
 else:
 # no entity class for any of the ancestors, fallback to the default
 # one
 cls = self.select(self.registry_objects('etypes', 'Any'), etype)
-# add class itself to the list of implemented interfaces, as well as the
-# Any entity class so we can select according to class using the
-# `implements` selector
-extend(cls, cls)
-extend(cls, self.etype_class('Any'))
 return cls
 def render(self, registry, oid, req, **context):
 """select an object in a given registry and render it
 - registry: the registry's name
 - oid : the view to call
 - req : the HTTP request
 """
 objclss = self.registry_objects(registry, oid)
 try:
 rset = context.pop('rset')
 except KeyError:
 rset = None
 selected = self.select(objclss, req, rset, **context)
 return selected.dispatch(**context)
 def main_template(self, req, oid='main-template', **context):
 """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
 """
 visualizable objects)
 """
 return [x for x in sorted(self.possible_objects(registry, *args, **kwargs),
 key=lambda x: x.propval('order'))
 if x.propval('visible')]
 def possible_actions(self, req, rset, **kwargs):
 if rset is None:
 actions = self.possible_vobjects('actions', req, rset)
 else:
 actions = rset.possible_actions() # cached implementation
 result = {}
 for action in actions:
 result.setdefault(action.category, []).append(action)
 return result
 def possible_views(self, req, rset, **kwargs):
 """return an iterator on possible views for this result set
 views returned are classes, not instances
 """
 except NoSelectableObject:
 continue
 except Exception:
 self.exception('error while trying to list possible %s views for %s',
 vid, rset)
 def select_box(self, oid, *args, **kwargs):
 """return the most specific view according to the result set"""
 try:
 return self.select_object('boxes', oid, *args, **kwargs)
 except NoSelectableObject:
 """return the most specific view according to the result set"""
 try:
 return self.select_object('actions', oid, *args, **kwargs)
 except NoSelectableObject:
 return
 def select_component(self, cid, *args, **kwargs):
 """return the most specific component according to the result set"""
 try:
 return self.select_object('components', cid, *args, **kwargs)
 except (NoSelectableObject, ObjectNotFound):
 def select_view(self, __vid, req, rset, **kwargs):
 """return the most specific view according to the result set"""
 views = self.registry_objects('views', __vid)
 return self.select(views, req, rset, **kwargs)
 # properties handling #####################################################
 def user_property_keys(self, withsitewide=False):
 if withsitewide:
 return sorted(self['propertydefs'])
 def register_property(self, key, type, help, default=None, vocabulary=None,
 sitewide=False):
 """register a given property"""
 properties = self._registries['propertydefs']
 assert type in YAMS_TO_PY
 properties[key] = {'type': type, 'vocabulary': vocabulary,
 'default': default, 'help': help,
 'sitewide': sitewide}
 def property_info(self, key):
 """return dictionary containing description associated to the given
 soft = key.split('.')[-1]
 return {'type': 'String', 'sitewide': True,
 'default': None, 'vocabulary': None,
 'help': _('%s software version of the database') % soft}
 raise UnknownProperty('unregistered property %r' % key)
 def property_value(self, key):
 try:
 return self._registries['propertyvalues'][key]
 except KeyError:
 return self._registries['propertydefs'][key]['default']
 if callable(vocab):
 vocab = vocab(key, None) # XXX need a req object
 if not value in vocab:
 raise ValueError(_('unauthorized value'))
 return value
 def init_properties(self, propvalues):
 """init the property values registry using the given set of couple (key, value)
 """
 self.initialized = True
 values = self._registries['propertyvalues']
 for vobject in vobjects:
 vobject.vreg = self
 vobject.schema = self.schema
 vobject.config = self.config
 return super(MulCnxCubicWebRegistry, self).select(vobjects, *args, **kwargs)
 from datetime import datetime, date, time, timedelta
 YAMS_TO_PY = {
 'Boolean':  bool,
 'String' :  unicode,

branch	tls-sprint
changeset 1475	5c1ec97f317e
parent 1357	e5a97779c7fc
child 1477	b056a49c16dc