cubicweb: comparison rtags.py

equal deleted inserted replaced

-:c25da7573ebd
+:02b52bf9f5f8
-"""relation tags store
+#:organization: Logilab
+#:copyright: 2001-2010 LOGILAB S.A. (Paris, FRANCE), license is LGPL v2.
-:organization: Logilab
+#:contact: http://www.logilab.fr/ -- mailto:contact@logilab.fr
-:copyright: 2001-2010 LOGILAB S.A. (Paris, FRANCE), license is LGPL v2.
+#:license: GNU Lesser General Public License, v2.1 - http://www.gnu.org/licenses
-:contact: http://www.logilab.fr/ -- mailto:contact@logilab.fr
-:license: GNU Lesser General Public License, v2.1 - http://www.gnu.org/licenses
+"""
+A RelationTag object is an object which allows to link a configuration information to a relation definition. For instance, the standard primary view uses a RelationTag object (uicfg.primaryview_section) to get the section to display relations.
+.. sourcecode:: python
+# display ``entry_of`` relations in the ``relations`` section in the ``BlogEntry`` primary view
+uicfg.primaryview_section.tag_subject_of(('BlogEntry', 'entry_of', '*'),
+'relations')
+# hide every relation ``entry_of`` in the ``Blog`` primary view
+uicfg.primaryview_section.tag_object_of(('*', 'entry_of', 'Blog'), 'hidden')
+Three primitives are defined:
+* ``tag_subject_of`` tag a relation in the subject's context
+* ``tag_object_of`` tag a relation in the object's context
+* ``tag_attribute`` shortcut for tag_subject_of
 """
 __docformat__ = "restructuredtext en"
 import logging
 RTAGS = []
 def register_rtag(rtag):
 RTAGS.append(rtag)
+def _ensure_str_key(key):
+return tuple(str(k) for k in key)
 class RelationTags(object):
 """a tag store for full relation definitions :
 (subject type, relation type, object type, tagged)
 allowing to set tags using wildcard (eg '*') as subject type / object type
 This class associates a single tag to each key.
 """
 _allowed_values = None
+_initfunc = None
 def __init__(self, name=None, initfunc=None, allowed_values=None):
 self._name = name or '<unknown>'
 self._tagdefs = {}
 if allowed_values is not None:
 self._allowed_values = allowed_values
-self._initfunc = initfunc
+if initfunc is not None:
+self._initfunc = initfunc
 register_rtag(self)
 def __repr__(self):
 return '%s: %s' % (self._name, repr(self._tagdefs))
 def clear(self):
 self._tagdefs.clear()
 def _get_keys(self, stype, rtype, otype, tagged):
-keys = [(rtype, tagged, '*', '*'),
+keys = [('*', rtype, '*', tagged),
-(rtype, tagged, '*', otype),
+('*', rtype, otype, tagged),
-(rtype, tagged, stype, '*'),
+(stype, rtype, '*', tagged),
-(rtype, tagged, stype, otype)]
+(stype, rtype, otype, tagged)]
 if stype == '*' or otype == '*':
-keys.remove((rtype, tagged, '*', '*'))
+keys.remove( ('*', rtype, '*', tagged) )
 if stype == '*':
-keys.remove((rtype, tagged, '*', otype))
+keys.remove( ('*', rtype, otype, tagged) )
 if otype == '*':
-keys.remove((rtype, tagged, stype, '*'))
+keys.remove( (stype, rtype, '*', tagged) )
 return keys
 def init(self, schema, check=True):
 # XXX check existing keys against schema
 if check:
-for (rtype, tagged, stype, otype), value in self._tagdefs.items():
+for (stype, rtype, otype, tagged), value in self._tagdefs.items():
 for ertype in (stype, rtype, otype):
 if ertype != '*' and not ertype in schema:
 self.warning('removing rtag %s: %s, %s undefined in schema',
 (stype, rtype, otype, tagged), value, ertype)
 self.del_rtag(stype, rtype, otype, tagged)
 break
 if self._initfunc is not None:
-for eschema in schema.entities():
+self.apply(schema, self._initfunc)
-for rschema, tschemas, role in eschema.relation_definitions(True):
-for tschema in tschemas:
+def apply(self, schema, func):
-if role == 'subject':
+for eschema in schema.entities():
-sschema, oschema = eschema, tschema
+for rschema, tschemas, role in eschema.relation_definitions(True):
-else:
+for tschema in tschemas:
-sschema, oschema = tschema, eschema
+if role == 'subject':
-self._initfunc(self, sschema, rschema, oschema, role)
+sschema, oschema = eschema, tschema
+else:
+sschema, oschema = tschema, eschema
+func(self, sschema, rschema, oschema, role)
 # rtag declaration api ####################################################
-def tag_attribute(self, key, tag):
+def tag_attribute(self, key, *args, **kwargs):
 key = list(key)
 key.append('*')
-self.tag_subject_of(key, tag)
+key.append('subject')
+self.tag_relation(key, *args, **kwargs)
-def tag_subject_of(self, key, tag):
+def tag_subject_of(self, key, *args, **kwargs):
 key = list(key)
 key.append('subject')
-self.tag_relation(key, tag)
+self.tag_relation(key, *args, **kwargs)
-def tag_object_of(self, key, tag):
+def tag_object_of(self, key, *args, **kwargs):
 key = list(key)
 key.append('object')
-self.tag_relation(key, tag)
+self.tag_relation(key, *args, **kwargs)
 def tag_relation(self, key, tag):
-#if isinstance(key, basestring):
+assert len(key) == 4, 'bad key: %s' % list(key)
-#    stype, rtype, otype = key.split()
-#else:
-stype, rtype, otype, tagged = [str(k) for k in key]
 if self._allowed_values is not None:
 assert tag in self._allowed_values, \
 '%r is not an allowed tag (should be in %s)' % (
 tag, self._allowed_values)
-self._tagdefs[(rtype, tagged, stype, otype)] = tag
+self._tagdefs[_ensure_str_key(key)] = tag
 return tag
 # rtag runtime api ########################################################
-def del_rtag(self, stype, rtype, otype, tagged):
+def del_rtag(self, *key):
-del self._tagdefs[(rtype, tagged, stype, otype)]
+del self._tagdefs[key]
-def get(self, stype, rtype, otype, tagged):
+def get(self, *key):
-for key in reversed(self._get_keys(stype, rtype, otype, tagged)):
+for key in reversed(self._get_keys(*key)):
 try:
 return self._tagdefs[key]
 except KeyError:
 continue
 return None
 """This class associates a set of tags to each key.
 """
 tag_container_cls = set
 def tag_relation(self, key, tag):
-stype, rtype, otype, tagged = [str(k) for k in key]
+rtags = self._tagdefs.setdefault(_ensure_str_key(key),
-rtags = self._tagdefs.setdefault((rtype, tagged, stype, otype),
 self.tag_container_cls())
 rtags.add(tag)
 return rtags
 def get(self, stype, rtype, otype, tagged):
 class RelationTagsDict(RelationTagsSet):
 """This class associates a set of tags to each key."""
 tag_container_cls = dict
 def tag_relation(self, key, tag):
-stype, rtype, otype, tagged = [str(k) for k in key]
+key = _ensure_str_key(key)
 try:
-rtags = self._tagdefs[(rtype, tagged, stype, otype)]
+rtags = self._tagdefs[key]
 rtags.update(tag)
 return rtags
 except KeyError:
-self._tagdefs[(rtype, tagged, stype, otype)] = tag
+self._tagdefs[key] = tag
 return tag
 def setdefault(self, key, tagkey, tagvalue):
-stype, rtype, otype, tagged = [str(k) for k in key]
+key = _ensure_str_key(key)
 try:
-rtags = self._tagdefs[(rtype, tagged, stype, otype)]
+rtags = self._tagdefs[key]
 rtags.setdefault(tagkey, tagvalue)
 return rtags
 except KeyError:
-self._tagdefs[(rtype, tagged, stype, otype)] = {tagkey: tagvalue}
+self._tagdefs[key] = {tagkey: tagvalue}
-return self._tagdefs[(rtype, tagged, stype, otype)]
+return self._tagdefs[key]
 class RelationTagsBool(RelationTags):
 _allowed_values = frozenset((True, False))

branch	oldstable
changeset 4985	02b52bf9f5f8
parent 4931	92c9d0a5dc11
child 5314	86e5abbebfaf