userheads

MoinMoin/storage/middleware/indexing.py

 # Copyright: 2011 MoinMoin:RonnyPfannschmidt
 # Copyright: 2011 MoinMoin:ThomasWaldmann
 # Copyright: 2011 MoinMoin:MichaelMayorov
 # License: GNU GPL v2 (or any later version), see LICENSE.txt for details.
 
 """
 MoinMoin - indexing middleware
 
 The backends and stores moin uses are rather simple, it is mostly just a
 unsorted / unordered bunch of revisions (meta and data) with iteration.
@@ skipping 61 matching lines @@
 from whoosh.query import Every, Term
 from whoosh.sorting import FieldFacet
 
 from MoinMoin import log
 logging = log.getLogger(__name__)
 
 from MoinMoin.config import WIKINAME, NAME, NAME_EXACT, MTIME, CONTENTTYPE, TAGS, \
                             LANGUAGE, USERID, ADDRESS, HOSTNAME, SIZE, ACTION, COMMENT, SUMMARY, \
                             CONTENT, EXTERNALLINKS, ITEMLINKS, ITEMTRANSCLUSIONS, ACL, EMAIL, OPENID, \
                             ITEMID, REVID, CURRENT, PARENTID, \
-                            LATEST_REVS, ALL_REVS, BRANCHES, USERHEADS, \
+                            ALL_REVS, BRANCHES, \
                             CONTENTTYPE_USER, \
-                            BRANCH_ID, BRANCH_ITEMID, BRANCH_NAME, BRANCH_REVID, \
-                            BRANCH_TYPE, \
-                            UH_ID, UH_ITEMID, UH_USER, UH_POINTER
+                            BRANCH_ID, BRANCH_ITEMID, BRANCH_SRC, BRANCH_DST, \
+                            BRANCH_TYPE, MASTER_BRANCH, \
+                            UH_ID, UH_ITEMID, UH_USER, UH_POINTER, \
+                            BRANCH, TAG, USERHEAD
+
 from MoinMoin.constants import keys
 
 from MoinMoin import user
 from MoinMoin.search.analyzers import item_name_analyzer, MimeTokenizer, AclTokenizer
 from MoinMoin.themes import utctimestamp
-from MoinMoin.util.crypto import make_uuid
+from MoinMoin.util.crypto import make_uuid, UUID_LEN
 from MoinMoin.storage.middleware.validation import ContentMetaSchema, UserMetaSchema
 from MoinMoin.storage.error import NoSuchItemError, ItemAlreadyExistsError
 
 
-INDEXES = [LATEST_REVS, ALL_REVS, BRANCHES, USERHEADS]
+INDEXES = [ALL_REVS, BRANCHES]
 
 
 def backend_to_index(meta, content, schema, wikiname):
     """
     Convert backend metadata/data to a whoosh document.
 
     :param meta: revision meta from moin backend
     :param content: revision data converted to indexable content
     :param schema: whoosh schema
     :param wikiname: interwikiname of this wiki
@@ skipping 163 matching lines @@
 
         # TODO: because there is no "latest_revs" anymore, everything is dumped
         # into "all_revs". Some parts should be moved to branches and userheads
         all_revs_fields = dict()
         all_revs_fields.update(**latest_revs_fields)
         all_revs_fields[ITEMID] = ID(stored=True)
 
         branches_fields = {
             BRANCH_ID: ID(unique=True, stored=True),
             BRANCH_ITEMID: ID(stored=True),
-            BRANCH_NAME: ID(stored=True),
-            BRANCH_REVID: ID(stored=True),
             BRANCH_TYPE: ID(stored=True),
+            BRANCH_SRC: ID(stored=True),
+            BRANCH_DST: ID(stored=True),
         }
 
-        userheads_fields = {
-            UH_ID: ID(unique=True, stored=True),
-            UH_ITEMID: ID(stored=True),
-            UH_USER: ID(stored=True),
-            UH_POINTER: ID(stored=True),
-        }
-
-        latest_revisions_schema = Schema(**latest_revs_fields)
         all_revisions_schema = Schema(**all_revs_fields)
         branches_schema = Schema(**branches_fields)
-        userheads_schema = Schema(**userheads_fields)
 
         # Define dynamic fields
         dynamic_fields = [("*_id", ID(stored=True)),
                           ("*_text", TEXT(stored=True)),
                           ("*_keyword", KEYWORD(stored=True)),
                           ("*_numeric", NUMERIC(stored=True)),
                           ("*_datetime", DATETIME(stored=True)),
                           ("*_boolean", BOOLEAN(stored=True)),
                          ]
 
         # Adding dynamic fields to schemas
         for glob, field_type in dynamic_fields:
-            latest_revisions_schema.add(glob, field_type, glob=True)
             all_revisions_schema.add(glob, field_type, glob=True)
 
         # schemas are needed by query parser and for index creation
         self.schemas[ALL_REVS] = all_revisions_schema
-        self.schemas[LATEST_REVS] = latest_revisions_schema
         self.schemas[BRANCHES] = branches_schema
-        self.schemas[USERHEADS] = userheads_schema
 
         # what fields could whoosh result documents have (no matter whether all revs index
         # or latest revs index):
         self.common_fields = set(latest_revs_fields.keys()) & set(all_revs_fields.keys())
 
     def open(self):
         """
         Open all indexes.
         """
         index_dir = self.index_dir
@@ skipping 70 matching lines @@
         else:
             writer = self.ix[type].writer()
         with writer as writer:
             writer.update_document(**doc)
 
     def remove_revision(self, revid, async=True):
         """
         Remove a single revision from indexes.
         """
         # get branches with the revision which will be removed
-        with self.ix[LATEST_REVS].searcher() as searcher:
+        with self.ix[ALL_REVS].searcher() as searcher:
             revision_to_remove = searcher.document(revid=revid)
             if revision_to_remove:
                 parent_revid = revision_to_remove.get(PARENTID, None)
                 with self.ix[BRANCHES].searcher() as searcher:
-                    branches_docs = searcher.documents(revid=revid)
-                with self.ix[BRANCHES].writer() as writer:
-                    for branch_doc in branches_docs:
-                        branch_doc[BRANCH_REVID] = parent_revid
-                        writer.update_document(**branch_doc)
+                    branches_docs = searcher.documents(**{BRANCH_DST: revid})
+                    with self.ix[BRANCHES].writer() as writer:
+                        for branch_doc in branches_docs:
+                            branch_doc[BRANCH_DST] = parent_revid
+                            writer.update_document(**branch_doc)
         if async:
             writer = AsyncWriter(self.ix[ALL_REVS])
         else:
             writer = self.ix[ALL_REVS].writer()
         with writer as writer:
             writer.delete_by_term(REVID, revid)
 
-    def _modify_branches_index(self, index, schema, wikiname, branches,
-                               mode='add', procs=1, limitmb=256):

[Reimar Bauer, 2012/07/20 14:16:34]

unicode type

-        return self._modify_special_index(index, schema, wikiname, branches,
-                                          BRANCH_ID, self.backend.retrieve_branch,
-                                          mode, procs, limitmb)
-    def _modify_userheads_index(self, index, schema, wikiname, userheads,
-                                mode='add', procs=1, limitmb=256):
-        return self._modify_special_index(index, schema, wikiname, userheads,
-                                          UH_ID, self.backend.retrieve_userhead,
-                                          mode, procs, limitmb)
-
-    def _modify_special_index(self, index, schema, wikiname, data, id_field,
-                              retrieve_function, mode='add',
+    def _modify_branches_index(self, index, schema, wikiname, data, mode='add',
                               procs=1, limitmb=256):
         """
         modify special index, containing simple (non-typed) elements like
         branches and userheads.
         """
         with index.writer(procs=procs, limitmb=limitmb) as writer:
             for dataid in data:
                 if mode in ['add', 'update', ]:
-                    entry = retrieve_function(dataid)
+                    entry = self.backend.retrieve_branch(dataid)
                     doc = dict([(str(key), value)
                                 for key, value in entry.items()
                                 if key in schema])
                 if mode == 'update':
                     writer.update_document(**doc)
                 elif mode == 'add':
                     writer.add_document(**doc)
                 elif mode == 'delete':
-                    writer.delete_by_term(id_field, dataid)
+                    writer.delete_by_term(BRANCH_ID, dataid)
                 else:
                     raise ValueError("mode must be 'update', 'add' or 'delete', not '{0}'".format(mode))
 
     def _modify_index(self, index, schema, wikiname, revids, mode='add', procs=1, limitmb=256):
         """
         modify index contents - add, update, delete the indexed documents for all given revids
 
         Note: mode == 'add' is faster but you need to make sure to not create duplicate
               documents in the index.
         """
@@ skipping 42 matching lines @@
         """
         index_dir = self.index_dir_tmp if tmp else self.index_dir
         index = open_dir(index_dir, indexname=ALL_REVS)
         try:
             # build an index of all we have (so we know what we have)
             all_revids = self.backend # the backend is an iterator over all revids
             self._modify_index(index, self.schemas[ALL_REVS], self.wikiname, all_revids, 'add', procs, limitmb)
             latest_names_revids = self._find_latest_names_revids(index)
         finally:
             index.close()
-        # branches and userheads indexes
+        # branches and userheads index
         index = open_dir(index_dir, indexname=BRANCHES)
         try:
-            self._modify_branches_index(index, BRANCHES, self.wikiname,

[ThomasJWaldmann, 2012/07/20 13:14:29]

you give BRANCHES to schema?

that's a little strange as you use BRANCHES for the indexname also.

[breton, 2012/07/21 02:28:57]

right, there should be self.schemas[BRANCHES]. // should return to cycle on the
left side :(

-                                      self.backend.branches, 'add',
-                                      procs, limitmb)
-        finally:
-            index.close()
-        index = open_dir(index_dir, indexname=BRANCHES)

[ThomasJWaldmann, 2012/07/20 13:14:29]

same indexname again?

[breton, 2012/07/21 02:28:57]

thanks, fixed. Should definetely return back to the cycle on the left

-        try:
-            self._modify_userheads_index(index, BRANCHES, self.wikiname,
-                                        self.backend.userheads, 'add',
-                                        procs, limitmb)
+            self._modify_branches_index(index, self.schemas[BRANCHES],
+                                        self.wikiname, self.backend.branches,
+                                        'add', procs, limitmb)
         finally:
             index.close()
 
     def update(self, tmp=False):
         """
         Make sure index reflects current backend state, add missing stuff, remove outdated stuff.
 
         This is intended to be used:
         * after a full rebuild that was done at tmp location
         * after wiki is made read-only or taken offline
@@ skipping 22 matching lines @@
             del_revids = [(revids_mountpoints[revid], revid) for revid in del_revids]
             self._modify_index(index_all, self.schemas[ALL_REVS], self.wikiname, add_revids, 'add')
             self._modify_index(index_all, self.schemas[ALL_REVS], self.wikiname, del_revids, 'delete')
         finally:
             index_all.close()
         index_branches = open_dir(index_dir, indexname=BRANCHES)
         try:
             # now update BRANCHES index:
             with index_branches.searcher() as searcher:
                 ix_branchids = set(doc[BRANCH_ID] for doc in searcher.all_stored_fields())
-            backend_branchids = set(branchid for branch in self.backend.branches)
+            backend_branchids = set(branch for branch in self.backend.branches)
             add_branchids = backend_branchids - ix_branchids
             del_branchids = ix_branchids - backend_branchids
             changed = changed or add_branchids or del_branchids
             self._modify_branches_index(index_branches, self.schemas[BRANCHES],
                                         self.wikiname, add_branchids, 'add')
             self._modify_branches_index(index_branches, self.schemas[BRANCHES],
                                        self.wikiname, del_branchids, 'delete')
         finally:
             index_branches.close()
-        index_userheads = open_dir(index_dir, indexname=USERHEADS)
-        try:
-            # now update userheads index:
-            with index_userheads.searcher() as searcher:
-                ix_userheadids = set(doc[UH_ID] for doc in searcher.all_stored_fields())
-            backend_userheadids = set(userheadid for userhead in self.backend.userheads)
-            add_userheadids = backend_userheadids - ix_userheadids
-            del_userheadids = ix_userheadids - backend_userheadids
-            changed = changed or add_userheadids or del_userheadids
-            self._modify_userhead_index(index_userheads, self.schemas[USERHEADS],
-                                        self.wikiname, add_userheadids, 'add')
-            self._modify_userhead_index(index_userheads, self.schemas[USERHEADS],
-                                        self.wikiname, del_userheadids, 'delete')
-        finally:
-            index_branches.close()
         return changed
 
     def optimize_backend(self):
         """
         Optimize backend / collect garbage to safe space:
 
         * deleted items: destroy them? use a deleted_max_age?
         * user profiles: only keep latest revision?
         * normal wiki items: keep by max_revisions_count / max_age
         * deduplicate data (determine dataids with same hash, fix references to point to one of them)
         * remove unreferenced dataids (destroyed revisions, deduplicated stuff)
         """
         # TODO
 
     def optimize_index(self, tmp=False):
         """
         Optimize whoosh index.
         """
         index_dir = self.index_dir_tmp if tmp else self.index_dir
         for name in INDEXES:
             ix = open_dir(index_dir, indexname=name)
             try:
                 ix.optimize()
             finally:
                 ix.close()
 
-    def dump(self, tmp=False, idx_name=LATEST_REVS):
+    def dump(self, tmp=False, idx_name=ALL_REVS):
         """
         Yield key/value tuple lists for all documents in the indexes, fields sorted.
         """
         index_dir = self.index_dir_tmp if tmp else self.index_dir
         ix = open_dir(index_dir, indexname=idx_name)
         try:
             with ix.searcher() as searcher:
                 for doc in searcher.all_stored_fields():
                     name = doc.pop(NAME, u"")
                     content = doc.pop(CONTENT, u"")
                     yield [(NAME, name), ] + sorted(doc.items()) + [(CONTENT, content), ]
         finally:
             ix.close()
 
-    def query_parser(self, default_fields, idx_name=LATEST_REVS):
+    def query_parser(self, default_fields, idx_name=ALL_REVS):
         """
         Build a query parser for a list of default fields.
         """
         schema = self.schemas[idx_name]
         if len(default_fields) > 1:
             qp = MultifieldParser(default_fields, schema=schema)
         elif len(default_fields) == 1:
             qp = QueryParser(default_fields[0], schema=schema)
         else:
             raise ValueError("default_fields list must at least contain one field name")
         qp.add_plugin(RegexPlugin())
         def username_pseudo_field(node):
             username = node.text
             users = user.search_users(**{NAME_EXACT: username})
             if users:
                 userid = users[0].meta['userid']
                 node = WordNode(userid)
                 node.set_fieldname("userid")
                 return node
             return node
         qp.add_plugin(PseudoFieldPlugin({'username': username_pseudo_field}))
         return qp
 
-    def search(self, q, idx_name=LATEST_REVS, **kw):
+    def search(self, q, idx_name=ALL_REVS, **kw):
         """
         Search with query q, yield Revisions.
         """
         with self.ix[idx_name].searcher() as searcher:
             # Note: callers must consume everything we yield, so the for loop
             # ends and the "with" is left to close the index files.
             for hit in searcher.search(q, **kw):
                 doc = hit.fields()
-                latest_doc = doc if idx_name == LATEST_REVS else None
-                item = Item(self, doc=latest_doc, itemid=doc[ITEMID])
+                item = Item(self, doc=None, itemid=doc[ITEMID])
                 yield item.get_revision(doc[REVID], doc=doc)
 
-    def search_page(self, q, idx_name=LATEST_REVS, pagenum=1, pagelen=10, **kw):
+    def search_page(self, q, idx_name=ALL_REVS, pagenum=1, pagelen=10, **kw):
         """
         Same as search, but with paging support.
         """
         with self.ix[idx_name].searcher() as searcher:
             # Note: callers must consume everything we yield, so the for loop
             # ends and the "with" is left to close the index files.
             for hit in searcher.search_page(q, pagenum, pagelen=pagelen, **kw):
                 doc = hit.fields()
-                latest_doc = doc if idx_name == LATEST_REVS else None
-                item = Item(self, latest_doc=latest_doc, itemid=doc[ITEMID])
+                item = Item(self, latest_doc=None, itemid=doc[ITEMID])
                 yield item.get_revision(doc[REVID], doc=doc)
 
-    def documents(self, idx_name=LATEST_REVS, **kw):
+    def documents(self, idx_name=ALL_REVS, **kw):
         """
         Yield Revisions matching the kw args.
         """
         for doc in self._documents(idx_name, **kw):
-            latest_doc = doc if idx_name == LATEST_REVS else None
-            item = Item(self, latest_doc=latest_doc, itemid=doc[ITEMID])
+            item = Item(self, doc=None, itemid=doc[ITEMID])
             yield item.get_revision(doc[REVID], doc=doc)
 
-    def _documents(self, idx_name=LATEST_REVS, **kw):
+    def _documents(self, idx_name=ALL_REVS, **kw):
         """
         Yield documents matching the kw args (internal use only).
 
         If no kw args are given, this yields all documents.
         """
         with self.ix[idx_name].searcher() as searcher:
             # Note: callers must consume everything we yield, so the for loop
             # ends and the "with" is left to close the index files.
             for doc in searcher.documents(**kw):
                 yield doc
 
-    def document(self, idx_name=LATEST_REVS, **kw):
+    def document(self, idx_name=ALL_REVS, **kw):
         """
         Return a Revision matching the kw args.
         """
         doc = self._document(idx_name, **kw)
         if doc:
-            latest_doc = doc if idx_name == LATEST_REVS else None
-            item = Item(self, latest_doc=latest_doc, itemid=doc[ITEMID])
+            item = Item(self, latest_doc=None, itemid=doc[ITEMID])
             return item.get_revision(doc[REVID], doc=doc)
 
     def _document(self, idx_name=ALL_REVS, **kw):
         """
         Return a document matching the kw args (internal use only).
         """
         with self.ix[idx_name].searcher() as searcher:
             return searcher.document(**kw)
 
     def has_item(self, name):
@@ skipping 26 matching lines @@
 
     def existing_item(self, **query):
         """
         Return item identified by query (must be an existing item).
 
         :kwargs **query: e.g. name_exact=u"Foo" or itemid="..." or ...
                          (must be a unique fieldname=value for the latest-revs index)
         """
         return Item.existing(self, **query)
 
-    def get_users_branch(self):
-        """
-        Return a branchname by looking up the userhead of the current user
-        """
-        user = flaskg.user
-        if user.name == 'anonymous':
-            return 'master'
-        else:
-            userhead = self._document(idx_name=USERHEADS, userid=user.itemid)

[ThomasJWaldmann, 2012/07/20 13:14:29]

this is not the userhead, but an indexed document.
you get the userhead in the following line out of that document:

(please avoid confusing naming)

[breton, 2012/07/21 02:28:57]

in fact, that's exactly the userhead, as defined on 51 of the EP. On the next
line is a branchname or a $-prefixed revid is returned, which is a string.

[breton, 2012/07/21 09:58:15]

Also, I forgot to use itemid here. I think this function belongs to class
indexing.Item rather than to indexing.IndexingMiddleware

-            return userhead[UH_POINTER]
+    def generate_branchname(self, itemid):

[ThomasJWaldmann, 2012/08/07 20:29:51]

what exactly means itemid here?

+        """
+        Return a generated vacant branchname
+        """
+        i = 0
+        while True:
+            branchname = u'branch' + unicode(i)
+            q = {BRANCH_DST: itemid, BRANCH_SRC: branchname}
+            branch = self._document(idx_name=BRANCHES, **{BRANCH_DST: itemid})

[ThomasJWaldmann, 2012/08/07 20:29:51]

i don't understand itemid usage here.

+            if not branch:
+                return branchname
+            else:
+                i += 1
 
 
 class Item(object):
     def __init__(self, indexer, doc=None, **query):
         """
         :param indexer: indexer middleware instance
         :param doc: if caller already has a latest-revs index whoosh document
                            it can be given there, to avoid us fetching same doc again
                            from the index
         :kwargs **query: any unique fieldname=value for the latest-revs index, e.g.:
@@ skipping 54 matching lines @@
         if self:
             for rev in self.indexer.documents(idx_name=ALL_REVS, itemid=self.itemid):
                 yield rev
 
     def __getitem__(self, revid):
         """
         Get Revision with revision id <revid>.
         """
         return Revision(self, revid)
 
-    def get_revision(self, revid, doc=None):
+    def get_revision(self, revid, branch=None, doc=None):
         """
         Similar to item[revid], but you can optionally give an already existing
         whoosh result document for the given revid to avoid backend accesses for some use cases.
         """
-        return Revision(self, revid, doc)
+        return Revision(self, revid, branch, doc)
 
     def get_head_revid_by_branch(self, branchname):
-        if branchname.startswith('$') and len(branchname) == len(make_uuid()) + 1:

[eSyr, 2012/07/20 12:51:16]

check against \$[0-9a-fA-F]{8}-([0-9a-fA-F]{4}-){3}[0-9a-fA-F]{12} maybe?

[ThomasJWaldmann, 2012/07/20 13:14:29]

IIRC we have a constant for this length, so you do not need to compute
len(make_uuid()) over and over again.

[breton, 2012/07/21 02:28:57]

I don't think it'll be very helpful. Also, sane people wouldn't call a branch
with a (8 + 4*3 + 12)-len name, so this check should be enough.

Also, you sure this will never be changed?

[breton, 2012/07/21 02:28:57]

fixed

[ThomasJWaldmann, 2012/07/22 10:45:28]

well, maybe a function get_uuid(s) would be good, that either returns None (no
uuid found) or the uuid.

that internally can then use any reasonable check to determine wheter we have a
uuid and strip whatever prefix there is.

+        if branchname.startswith(u'$') and len(branchname) == UUID_LEN + 1:
             return branchname[1:]  # is a revid already
         else:
-            branch = self.indexer._document(idx_name=BRANCHES,
-                                            name=branchname or 'master',
-                                            itemid=self.itemid)
+            q = {BRANCH_SRC: branchname or MASTER_BRANCH,
+                 BRANCH_ITEMID: self.itemid}
+            branch = self.indexer._document(idx_name=BRANCHES, **q)
             if branch:
-                return branch[BRANCH_REVID]

[ThomasJWaldmann, 2012/07/20 13:14:29]

see comment for line 771 - this is an indexed document, not a branch.

+                return branch[BRANCH_DST]
             # no branch retrieved from index, checking default

[ThomasJWaldmann, 2012/07/20 13:14:29]

the question here is whether we should just fall back silently to the master
branch or maybe rather raise some exception.

[breton, 2012/07/21 02:28:57]

as we decided on EP:83

-            branch = self.indexer._document(idx_name=BRANCHES,
-                                            name='master',
-                                            itemid=self.itemid)
+            q = {BRANCH_SRC: MASTER_BRANCH, BRANCH_ITEMID: self.itemid}
+            branch = self.indexer._document(idx_name=BRANCHES, **q)
             if branch:
-                return branch[BRANCH_REVID]
+                return branch[BRANCH_DST]
             # still no branch; using the first found

[ThomasJWaldmann, 2012/07/20 13:14:29]

see above.

             return self.indexer._document(idx_name=ALL_REVS,
-                                          itemid=self.itemid)[REVID]
-
-    def get_revision_by_branch(self, branch):
-        return Revision(self, self.get_head_revid_by_branch(branch))
+                                          **{BRANCH_ITEMID: self.itemid})[REVID]
 
     def preprocess(self, meta, data):
         """
         preprocess a revision before it gets stored and put into index.
         """
         content = convert_to_indexable(meta, data, is_new=True)
         return meta, data, content
 
     def store_revision(self, meta, data, branch, overwrite=False,
                        trusted=False, # True for loading a serialized representation or other trusted sources
@@ skipping 71 matching lines @@
             revid = meta.get(REVID)
             if revid is not None and revid in backend:
                 raise ValueError('need overwrite=True to overwrite existing revisions')
         meta, data, content = self.preprocess(meta, data)
         data.seek(0)  # rewind file
         revid = backend.store(meta, data)
         meta[REVID] = revid
         self.indexer.index_revision(meta, content)
         # having saved revid, formate and create/update branch
         if not branch:
-            branch = u'master'

[ThomasJWaldmann, 2012/07/20 13:14:29]

sometimes you use 'master', sometimes u'master'.

i suggest your use a constant MASTER_BRANCH or so to get this consistent
everywhere.

[breton, 2012/07/21 02:28:57]

Agreed. Add it to constats.keys?

[ThomasJWaldmann, 2012/07/22 10:45:28]

yes.

-        branch_doc = self.indexer._document(idx_name=BRANCHES, name=branch,
-                                            itemid=self.itemid)
+            # check if a branch with revid=meta[PARENTID] exists
+            # if yes, we should use it. Else generate some name.
+            # meta[PARENTID] is a list, so if there are more than 1 parents
+            # we should generate a name anyway.
+            if len(meta[PARENTID]) > 1:
+                branch = self.indexer.generate_branchname(self.itemid)
+            else:
+                q = {BRANCH_DST: meta[PARENTID][0]}
+                branch_doc = self.indexer._document(idx_name=BRANCHES, **q)
+                if not branch_doc:
+                    branch = self.indexer.generate_branchname(self.itemid)
+                else:
+                    branch = branch_doc[BRANCH_SRC]
+        q = {BRANCH_SRC: branch, BRANCH_ITEMID: self.itemid}
+        branch_doc = self.indexer._document(idx_name=BRANCHES, **q)
         branch_state = {
                 BRANCH_ITEMID: self.itemid,
-                BRANCH_NAME: branch,
+                BRANCH_SRC: branch,
                 }
         if not branch_doc:
-            branch_state[BRANCH_TYPE] = u'branch'

[ThomasJWaldmann, 2012/07/20 13:14:29]

same here.

+            branch_state[BRANCH_TYPE] = BRANCH
             branch_state[BRANCH_ID] = make_uuid()
         else:
-            branch_state[BRANCH_TYPE] = branch_doc.get(BRANCH_TYPE, u'branch')
+            branch_state[BRANCH_TYPE] = branch_doc.get(BRANCH_TYPE, BRANCH)
             branch_state[BRANCH_ID] = branch_doc.get(BRANCH_ID, make_uuid())
-        branch_state[BRANCH_REVID] = revid
-        branchid = backend.store_branch(branch_state)
+        branch_state[BRANCH_DST] = revid
+        branchid = backend.store_branch(branch_state, meta[NAME])
         self.indexer.index_special(branch_state, BRANCHES)
-        # userheads

[ThomasJWaldmann, 2012/07/20 13:14:29]

maybe try to avoid pointless comments.
putting comments is fine, but they should say more than what's obvious anyway.

[breton, 2012/07/21 02:28:57]

just dividing the into sections

-        if flaskg.user.name != 'anonymous':
-            userhead_doc = self.indexer._document(idx_name=USERHEADS,
-                                                  userid=userid,
-                                                  itemid=self.itemid)
+        if flaskg.user.valid:
+            userhead_doc = self.indexer.document(idx_name=BRANCHES,
+                                                 **{UH_USER: userid,
+                                                    UH_ITEMID: self.itemid})
             userhead_state = dict()
             if not userhead_doc:
                 userhead_state[UH_ITEMID] = self.itemid
-                userhead_state[UH_USER] = flaskg.user

[ThomasJWaldmann, 2012/07/20 13:14:29]

this is the complete User object, i doubt you want to index that.

[breton, 2012/07/21 02:28:57]

thanks, fixed.

+                userhead_state[UH_USER] = userid
+                userhead_state[BRANCH_TYPE] = USERHEAD
             else:
                 userhead_state.update(userhead_doc)
-            userhead_state[UH_POINTER] = branch_state[BRANCH_NAME]
-            userheadid = backend.store_userhead(userhead_state)
-            self.indexer.index_special(userhead_state, USERHEADS)
-        
+            userhead_state[UH_POINTER] = branch_state[BRANCH_SRC]
+            userheadid = backend.store_userhead(userhead_state, meta[NAME])
+            self.indexer.index_special(userhead_state, BRANCHES)
+
         return Revision(self, revid)
 
     def store_all_revisions(self, meta, data):
         """
         Store over all revisions of this item.
         """
         for rev in self.iter_revs():
             meta[REVID] = rev.revid
             self.store_revision(meta, data, overwrite=True)
 
     def destroy_revision(self, revid):
         """
         Destroy revision <revid>.
         """
         rev = Revision(self, revid)
         self.backend.remove(rev.name, revid)
         self.indexer.remove_revision(revid)
 
     def destroy_all_revisions(self):
         """
         Destroy all revisions of this item.
         """
         for rev in self.iter_revs():
             self.destroy_revision(rev.revid)
+
+    def get_users_branch(self):
+        """
+        Return a branchname by looking up the userhead of the current user
+        """
+        try:
+            # XXX: now users are stored the same way as the content is. During
+            # login a user needs to be retrieved for password comparison,
+            # which requires a call of this function. But during login
+            # flaskg.user is not set yet. This below is a little workaround.
+            # Consider removal after users are coded in a sanier way
+            user = flaskg.user
+            userid = user.itemid
+        except AttributeError:
+            # user's meta and data are ALWAYS in master branch.
+            return MASTER_BRANCH
+
+        if user.name == 'anonymous':
+            return MASTER_BRANCH
+        else:
+            q = {UH_USER: userid, UH_ITEMID: self.itemid,BRANCH_TYPE: USERHEAD}

[ThomasJWaldmann, 2012/08/07 20:29:51]

a blank missing

+            userhead = self.indexer._document(idx_name=BRANCHES, **q)
+            if not userhead:
+                return MASTER_BRANCH
+            else:
+                return userhead[UH_POINTER]
+
 
 
 class Revision(object):
     """
     An existing revision (exists in the backend).
     """
-    def __init__(self, item, revid=None, doc=None, branch=None):
+    def __init__(self, item, revid=None, branch=None, doc=None):
         is_current = revid == CURRENT
+        self.users_branch = item.get_users_branch()
         if doc is None:
-            if not revid or is_current:
-                # get current user's branchname

[ThomasJWaldmann, 2012/07/20 13:14:29]

see above

-                branchname = item.indexer.get_users_branch()
-                if not branchname:
-                    branchname = 'master'

[ThomasJWaldmann, 2012/07/20 13:14:29]

maybe do that in get_users_branch()?

[breton, 2012/07/21 02:28:57]

in fact, I don't see any reason to do it. Removed.

-                revid = item.get_head_revid_by_branch(branchname)
-            doc = item.indexer._document(idx_name=ALL_REVS, revid=revid)
+            if revid and revid != CURRENT:
+                pass
+            elif branch:
+                revid = item.get_head_revid_by_branch(branch)
+            else:
+                branch = self.users_branch
+                revid = item.get_head_revid_by_branch(branch)
+            doc = item.indexer._document(idx_name=ALL_REVS, **{REVID: revid})
             if doc is None:
                 raise KeyError
         if is_current:
             revid = doc.get(REVID)
             if revid is None:
                 raise KeyError
         self.item = item
         self.revid = revid
         self.backend = item.backend
         self._doc = doc
         self.meta = Meta(self, self._doc)
         self._data = None
+        real_branch = item.indexer._document(idx_name=BRANCHES,
+                                             **{BRANCH_DST: revid})
+        if real_branch:··
+            self.not_on_userhead = real_branch[BRANCH_SRC] == self.users_branch
+            self.real_branch = real_branch[BRANCH_SRC]
+        else:
+            self.not_on_userhead = True
+            self.real_branch = None
+
         # Note: this does not immediately raise a KeyError for non-existing revs any more
         # If you access data or meta, it will, though.
 
     @property
     def name(self):
         return self.meta.get(NAME, 'DoesNotExist')
 
     def _load(self):
         meta, data = self.backend.retrieve(self._doc[NAME], self.revid) # raises KeyError if rev does not exist
         self.meta = Meta(self, self._doc, meta)
@@ skipping 60 matching lines @@
     def __cmp__(self, other):
         if self[REVID] == other[REVID]:
             return 0
         return cmp(self[MTIME], other[MTIME])
 
     def __len__(self):
         return 0 # XXX
 
     def __repr__(self):
         return "Meta _doc: {0!r} _meta: {1!r}".format(self._doc, self._meta)
 

[ThomasJWaldmann, 2012/08/07 20:29:51]

in general, code is hard to follow/understand, i suggest you add more docs.