Added basic composite name support

MoinMoin/items/__init__.py

 # Copyright: 2012 MoinMoin:CheerXiao
 # Copyright: 2009 MoinMoin:ThomasWaldmann
 # Copyright: 2009-2011 MoinMoin:ReimarBauer
 # Copyright: 2009 MoinMoin:ChristopherDenter
 # Copyright: 2008,2009 MoinMoin:BastianBlank
 # Copyright: 2010 MoinMoin:ValentinJaniaut
 # Copyright: 2010 MoinMoin:DiogenesAugusto
 # License: GNU GPL v2 (or any later version), see LICENSE.txt for details.
 
 """
@@ skipping 23 matching lines @@
 
 from MoinMoin import log
 logging = log.getLogger(__name__)
 
 from MoinMoin.security.textcha import TextCha, TextChaizedForm
 from MoinMoin.signalling import item_modified
 from MoinMoin.storage.middleware.protecting import AccessDenied
 from MoinMoin.i18n import L_
 from MoinMoin.themes import render_template
 from MoinMoin.util.mime import Type
-from MoinMoin.util.interwiki import url_for_item
+from MoinMoin.util.interwiki import url_for_item, split_fqname, get_fqname
 from MoinMoin.util.registry import RegistryBase
 from MoinMoin.util.clock import timed
 from MoinMoin.forms import RequiredText, OptionalText, JSON, Tags
 from MoinMoin.constants.keys import (
     NAME, NAME_OLD, NAME_EXACT, WIKINAME, MTIME, ITEMTYPE,
     CONTENTTYPE, SIZE, ACTION, ADDRESS, HOSTNAME, USERID, COMMENT,
-    HASH_ALGORITHM, ITEMID, REVID, DATAID, CURRENT, PARENTID
+    HASH_ALGORITHM, ITEMID, REVID, DATAID, CURRENT, PARENTID, NAMESPACE,
+    UFIELDS_TYPELIST
 )
 from MoinMoin.constants.contenttypes import CHARSET, CONTENTTYPE_NONEXISTENT
 from MoinMoin.constants.itemtypes import (
     ITEMTYPE_NONEXISTENT, ITEMTYPE_USERPROFILE, ITEMTYPE_DEFAULT,
 )
 
 from .content import content_registry, Content, NonExistentContent, Draw
 
 
 COLS = 80
@@ skipping 40 matching lines @@
     """ if we have no stored Revision, we use this dummy """
     def __init__(self, item, itemtype=None, contenttype=None):
         self.item = item
         self.meta = {
             ITEMTYPE: itemtype or ITEMTYPE_NONEXISTENT,
             CONTENTTYPE: contenttype or CONTENTTYPE_NONEXISTENT
         }
         self.data = StringIO('')
         self.revid = None
         if self.item:
-            self.meta[NAME] = [self.item.name]
+            self.meta[NAMESPACE] = item.fqname.namespace
+            if item.fqname.field in UFIELDS_TYPELIST:
+                self.meta[item.fqname.field] = [item.fqname.value]
+            else:
+                self.meta[item.fqname.field] = item.fqname.value
 
 
 class DummyItem(object):
     """ if we have no stored Item, we use this dummy """
-    def __init__(self, name):
-        self.name = name
+    def __init__(self, fqname):
+        self.fqname = fqname
 
     def list_revisions(self):
         return []  # same as an empty Item
 
     def destroy_all_revisions(self):
         return True
 
 
-def get_storage_revision(name, itemtype=None, contenttype=None, rev_id=CURRENT, item=None):
+def get_storage_revision(fqname, itemtype=None, contenttype=None, rev_id=CURRENT, item=None):
     """
     Get a storage Revision.
 
     If :item is supplied it is used as the storage Item; otherwise the storage
     Item is looked up with :name. If it is not found (either because the item
     doesn't exist or the user does not have the required permissions) a
     DummyItem is created, and a DummyRev is created with appropriate metadata
     properties and the "item" property pointing to the DummyItem. The DummyRev
     is then returned.
 
     If the previous step didn't end up with a DummyRev, the revision
     designated by :rev_id is then looked up. If it is not found, current
     revision is looked up and returned instead. If current revision is not
     found (i.e. the item has no revision), a DummyRev is created. (TODO: in
     the last two cases, emit warnings or throw exceptions.)
 
     :itemtype and :contenttype are used when creating a DummyRev, where
     metadata is not available from the storage.
     """
+    query = {fqname.field: fqname.value, NAMESPACE: fqname.namespace}
+    rev_id = fqname.value if fqname.field == REVID else rev_id
     if 1:  # try:
         if item is None:
-            item = flaskg.storage[name]
+            item = flaskg.storage.get_item(**query)
         else:
-            name = item.name
+            if item.fqname:
+                fqname = item.fqname
     if not item:  # except NoSuchItemError:
-        logging.debug("No such item: {0!r}".format(name))
-        item = DummyItem(name)
+        logging.debug("No such item: {0!r}".format(fqname))
+        item = DummyItem(fqname)
         rev = DummyRev(item, itemtype, contenttype)
-        logging.debug("Item {0!r}, created dummy revision with contenttype {1!r}".format(name, contenttype))
+        logging.debug("Item {0!r}, created dummy revision with contenttype {1!r}".format(fqname, contenttype))
     else:
-        logging.debug("Got item: {0!r}".format(name))
+        logging.debug("Got item: {0!r}".format(fqname))
         try:
             rev = item.get_revision(rev_id)
         except KeyError:  # NoSuchRevisionError:
             try:
                 rev = item.get_revision(CURRENT)  # fall back to current revision
                 # XXX add some message about invalid revision
             except KeyError:  # NoSuchRevisionError:
-                logging.debug("Item {0!r} has no revisions.".format(name))
+                logging.debug("Item {0!r} has no revisions.".format(fqname))
                 rev = DummyRev(item, itemtype, contenttype)
-                logging.debug("Item {0!r}, created dummy revision with contenttype {1!r}".format(name, contenttype))
-        logging.debug("Got item {0!r}, revision: {1!r}".format(name, rev_id))
+                logging.debug("Item {0!r}, created dummy revision with contenttype {1!r}".format(fqname, contenttype))
+        logging.debug("Got item {0!r}, revision: {1!r}".format(fqname, rev_id))
     return rev
 
 
 class BaseChangeForm(TextChaizedForm):
     comment = OptionalText.using(label=L_('Comment')).with_properties(placeholder=L_("Comment about your change"))
     submit_label = L_('OK')
 
 
 class BaseMetaForm(Form):
     itemtype = RequiredText.using(label=L_("Item type")).with_properties(placeholder=L_("Item type"))
@@ skipping 88 matching lines @@
         only when handling +convert (when deciding the contenttype of target
         item), +modify (when creating a new item whose contenttype is not yet
         decided), +diff and +diffraw (to coerce the Content to a common
         super-contenttype of both revisions).
 
         After that the Content instance, an instance of Item subclass is
         created according to the item's itemtype metadata entry, and the
         previously created Content instance is assigned to its content
         property.
         """
-        rev = get_storage_revision(name, itemtype, contenttype, rev_id, item)
+        fqname = split_fqname(name)
+        rev = get_storage_revision(fqname, itemtype, contenttype, rev_id, item)
         contenttype = rev.meta.get(CONTENTTYPE) or contenttype
         logging.debug("Item {0!r}, got contenttype {1!r} from revision meta".format(name, contenttype))
         #logging.debug("Item %r, rev meta dict: %r" % (name, dict(rev.meta)))
 
         # XXX Cannot pass item=item to Content.__init__ via
         # content_registry.get yet, have to patch it later.
         content = Content.create(contenttype)
 
         itemtype = rev.meta.get(ITEMTYPE) or itemtype or ITEMTYPE_DEFAULT
         logging.debug("Item {0!r}, got itemtype {1!r} from revision meta".format(name, itemtype))
 
-        item = item_registry.get(itemtype, name, rev=rev, content=content)
+        item = item_registry.get(itemtype, fqname, rev=rev, content=content)
         logging.debug("Item class {0!r} handles {1!r}".format(item.__class__, itemtype))
 
         content.item = item
-
         return item
 
-    def __init__(self, name, rev=None, content=None):
-        self.name = name
+    def __init__(self, fqname, rev=None, content=None):
+        self.fqname = fqname
         self.rev = rev
         self.content = content
 
     def get_meta(self):
         return self.rev.meta
     meta = property(fget=get_meta)
 
+    @property
+    def name(self):
+        """
+        returns the item name

[Thomas.J.Waldmann, 2013/06/29 14:10:04]

well, as items may have 0, 1 or more names, what is "the item name"?

also, considering the 0 case, code below looks like it would crash.

+        """
+        if self.fqname.field == NAME_EXACT:
+            return self.fqname.value
+        else:
+            return self.meta.get(NAME)[0]
+
     # XXX Backward compatibility, remove soon
     @property
     def contenttype(self):
         return self.content.contenttype if self.content else None
 
     def _render_meta(self):
         return "<pre>{0}</pre>".format(escape(self.meta_dict_to_text(self.meta, use_filter=False)))
 
     def meta_filter(self, meta):
         """ kill metadata entries that we set automatically when saving """
         kill_keys = [  # shall not get copied from old rev to new rev
             NAME_OLD,
             # are automatically implanted when saving
-            ITEMID, REVID, DATAID,
+            REVID, DATAID,
             HASH_ALGORITHM,
             SIZE,
             COMMENT,
             MTIME,
             ACTION,
             ADDRESS, HOSTNAME, USERID,
         ]
         for key in kill_keys:
             meta.pop(key, None)
         return meta
@@ skipping 121 matching lines @@
         Handle +modify requests, both GET and POST.
 
         This method should be overridden in subclasses, providing polymorphic
         behavior for the +modify view.
         """
         raise NotImplementedError
 
     def _save(self, meta, data=None, name=None, action=u'SAVE', contenttype_guessed=None, comment=None,
               overwrite=False, delete=False):
         backend = flaskg.storage
-        storage_item = backend[self.name]
+        query = {self.fqname.field: self.fqname.value, NAMESPACE: self.fqname.namespace}
+        storage_item = backend.get_item(**query)
         try:
             currentrev = storage_item.get_revision(CURRENT)
             rev_id = currentrev.revid
             contenttype_current = currentrev.meta.get(CONTENTTYPE)
         except KeyError:  # XXX was: NoSuchRevisionError:
             currentrev = None
             rev_id = None
             contenttype_current = None
 
         meta = dict(meta)  # we may get a read-only dict-like, copy it
-
         # we store the previous (if different) and current item name into revision metadata
         # this is useful for rename history and backends that use item uids internally
-        if name is None:
-            name = self.name
-        oldname = meta.get(NAME)
-        if oldname:
-            if not isinstance(oldname, list):
-                oldname = [oldname]
-            if delete or name not in oldname:  # this is a delete or rename
-                meta[NAME_OLD] = oldname[:]
-                try:
-                    oldname.remove(self.name)
-                except ValueError:
-                    pass
-                if not delete:
-                    oldname.append(name)
-                meta[NAME] = oldname
-        else:
-            meta[NAME] = [name]
+        if self.fqname.field == NAME_EXACT:
+            if name is None:
+                name = self.fqname.value
+            oldname = meta.get(NAME)
+            if oldname:
+                if not isinstance(oldname, list):
+                    oldname = [oldname]
+                if delete or name not in oldname:  # this is a delete or rename
+                    meta[NAME_OLD] = oldname[:]
+                    try:
+                        oldname.remove(self.name)
+                    except ValueError:
+                        pass
+                    if not delete:
+                        oldname.append(name)
+                    meta[NAME] = oldname
+            else:
+                meta[NAME] = [name]
 
         if comment is not None:
             meta[COMMENT] = unicode(comment)
 
         if not overwrite and REVID in meta:
             # we usually want to create a new revision, thus we must remove the existing REVID
             del meta[REVID]
 
         if data is None:
             if currentrev is not None:
                 # we don't have (new) data, just copy the old one.
                 # a valid usecase of this is to just edit metadata.
                 data = currentrev.data
             else:
                 data = ''
 
         if isinstance(data, unicode):
             data = data.encode(CHARSET)  # XXX wrong! if contenttype gives a coding, we MUST use THAT.
 
         if isinstance(data, str):
             data = StringIO(data)
-
         newrev = storage_item.store_revision(meta, data, overwrite=overwrite,
                                              action=unicode(action),
                                              contenttype_current=contenttype_current,
                                              contenttype_guessed=contenttype_guessed,
                                              return_rev=True,
                                              )
         item_modified.send(app._get_current_object(), item_name=name)
         return newrev.revid, newrev.meta[SIZE]
 
     @property
@@ skipping 45 matching lines @@
                     relname = fullname[prefixlen:]
                     if '/' in relname:
                         # Find the *direct* subitem that is the ancestor of current
                         # (indirect) subitem. e.g. suppose when the index root is
                         # 'foo', and current item (`rev`) is 'foo/bar/lorem/ipsum',
                         # 'foo/bar' will be found.
                         direct_relname = relname.partition('/')[0]
                         if direct_relname not in added_dir_relnames:
                             added_dir_relnames.add(direct_relname)
                             direct_fullname = prefix + direct_relname
-                            direct_rev = get_storage_revision(direct_fullname)
+                            fqname = split_fqname(direct_fullname)
+                            direct_rev = get_storage_revision(fqname)
                             dirs.append(IndexEntry(direct_relname, direct_fullname, direct_rev.meta))
                     else:
                         files.append(IndexEntry(relname, fullname, rev.meta))
 
         return dirs, files
 
     def build_index_query(self, startswith=None, selected_groups=None):
         prefix = self.subitems_prefix
         if startswith:
             query = Prefix(NAME_EXACT, prefix + startswith) | Prefix(NAME_EXACT, prefix + startswith.swapcase())
@@ skipping 72 matching lines @@
     itemtype = ITEMTYPE_DEFAULT
     display_name = L_('Default')
     description = L_('Wiki item')
     order = -10
 
     def _do_modify_show_templates(self):
         # call this if the item is still empty
         rev_ids = []
         item_templates = self.content.get_templates(self.contenttype)
         return render_template('modify_select_template.html',
-                               item_name=self.name,
+                               item_name=self.fqname.fullname,
                                itemtype=self.itemtype,
                                rev=self.rev,
                                contenttype=self.contenttype,
                                templates=item_templates,
                                first_rev_id=rev_ids and rev_ids[0],
                                last_rev_id=rev_ids and rev_ids[-1],
                                meta_rendered='',
                                data_rendered='',
                                )
 
     def do_show(self, revid):
         show_revision = revid != CURRENT
         show_navigation = False  # TODO
         first_rev = last_rev = None  # TODO
         return render_template(self.show_template,
-                               item=self, item_name=self.name,
+                               item=self, item_name=self.fqname.fullname,
                                rev=self.rev,
                                contenttype=self.contenttype,
                                first_rev_id=first_rev,
                                last_rev_id=last_rev,
                                data_rendered=Markup(self.content._render_data()),
                                show_revision=show_revision,
                                show_navigation=show_navigation,
                               )
 
     def do_modify(self):
         method = request.method
         if method in ['GET', 'HEAD']:
             if isinstance(self.content, NonExistentContent):
                 return render_template('modify_select_contenttype.html',
-                                       item_name=self.name,
+                                       item_name=self.fqname.fullname,
                                        itemtype=self.itemtype,
                                        group_names=content_registry.group_names,
                                        groups=content_registry.groups,
                                       )
             item = self
             if isinstance(self.rev, DummyRev):
                 template_name = request.values.get('template')
                 if template_name is None:
                     return self._do_modify_show_templates()
                 elif template_name:
@@ skipping 13 matching lines @@
             form = self.ModifyForm.from_request(request)
             state = dict(name=self.name, itemid=self.meta.get(ITEMID))
             if form.validate(state):
                 meta, data, contenttype_guessed, comment = form._dump(self)
                 contenttype_qs = request.values.get('contenttype')
                 try:
                     self.modify(meta, data, comment, contenttype_guessed, contenttype_qs)
                 except AccessDenied:
                     abort(403)
                 else:
-                    return redirect(url_for_item(self.name))
+                    return redirect(url_for_item(**self.fqname.split))
         return render_template(self.modify_template,
-                               item_name=self.name,
+                               item_name=self.fqname.fullname,
                                rows_meta=str(ROWS_META), cols=str(COLS),
                                form=form,
                                search_form=None,
                               )
 
     show_template = 'show.html'
     modify_template = 'modify.html'
 
 
 @register
@@ skipping 18 matching lines @@
 
     def _convert(self, doc):
         abort(404)
 
     def do_show(self, revid):
         # First, check if the current user has the required privileges
         if flaskg.user.may.create(self.name):
             content = self._select_itemtype()
         else:
             content = render_template('show_nonexistent.html',
-                                      item_name=self.name,
+                                      item_name=self.fqname.fullname,
                                      )
         return Response(content, 404)
 
     def do_modify(self):
         # First, check if the current user has the required privileges
         if not flaskg.user.may.create(self.name):
             abort(403)
         return self._select_itemtype()
 
     def _select_itemtype(self):
         return render_template('modify_select_itemtype.html',
-                               item_name=self.name,
+                               item_name=self.fqname.fullname,
                                itemtypes=item_registry.shown_entries,
                               )
 
     def rename(self, name, comment=u''):
         # pointless for non-existing items
         pass
 
     def delete(self, comment=u''):
         # pointless for non-existing items
         pass
 
     def revert(self, comment=u''):
         # pointless for non-existing items
         pass
 
     def destroy(self, comment=u'', destroy_item=False):
         # pointless for non-existing items
         pass
 
 
 from ..util.pysupport import load_package_modules
 load_package_modules(__name__, __path__)