userheads

MoinMoin/storage/middleware/protecting.py

 # Copyright: 2011 MoinMoin:ThomasWaldmann
 # License: GNU GPL v2 (or any later version), see LICENSE.txt for details.
 
 """
 MoinMoin - protecting middleware
 
 This checks ACLs (access control lists), so a user will not be able to do
 operations without the respective permissions.
 
 Note: for method / attribute docs, please see the same methods / attributes in
@@ skipping 33 matching lines @@
     def get_acls(self, itemname):
         for prefix, acls in self.acl_mapping:
             if itemname.startswith(prefix):
                 return acls
         else:
             raise ValueError('No acl_mapping entry found for item {0!r}'.format(itemname))
 
     def query_parser(self, default_fields, idx_name=LATEST_REVS):
         return self.indexer.query_parser(default_fields, idx_name=idx_name)
 
-    def search(self, q, idx_name=LATEST_REVS, **kw):
+    def search(self, q, idx_name=ALL_REVS, **kw):
         for rev in self.indexer.search(q, idx_name, **kw):
             rev = ProtectedRevision(self, rev)
             if rev.allows(READ):
                 yield rev
 
     def search_page(self, q, idx_name=LATEST_REVS, pagenum=1, pagelen=10, **kw):
         for rev in self.indexer.search_page(q, idx_name, pagenum, pagelen, **kw):
             rev = ProtectedRevision(self, rev)
             if rev.allows(READ):
                 yield rev
@@ skipping 139 matching lines @@
         self.require(READ)
         if self:
             for rev in self.item.iter_revs():
                 yield ProtectedRevision(self.protector, rev, p_item=self)
 
     def __getitem__(self, revid):
         self.require(READ)  # XXX
         rev = self.item[revid]
         return ProtectedRevision(self.protector, rev, p_item=self)
 
-    def get_revision(self, revid):
-        return self[revid]
-
-    def get_revision_by_branch(self, branch):
-        self.require(READ)  # XXX
-        rev = self.item.get_revision_by_branch(branch)
+    def get_revision(self, revid, branch=None):
+        rev = self.item.get_revision(revid, branch)
         return ProtectedRevision(self.protector, rev, p_item=self)
 
     def store_revision(self, meta, data, branch, overwrite=False, **kw):
         self.require(WRITE)
         if not self:
             self.require(CREATE)
         if overwrite:
             self.require(DESTROY)
         rev = self.item.store_revision(meta, data, branch, overwrite=overwrite, **kw)
         return ProtectedRevision(self.protector, rev, p_item=self)
 
     def store_all_revisions(self, meta, data):
         self.require(DESTROY)
         self.item.store_all_revisions(meta, data)
 
     def destroy_revision(self, revid):
         self.require(DESTROY)
         self.item.destroy_revision(revid)
 
     def destroy_all_revisions(self):
         for rev in self.item.iter_revs():
             self.destroy_revision(rev.revid)
 
+    def get_head_revid_by_branch(self, branch):
+        return self.item.get_head_revid_by_branch(branch)
+
 
 class ProtectedRevision(object):
     def __init__(self, protector, rev, p_item=None):
         """
         :param protector: Protector middleware
         :param rev: Revision to protect
         :param p_item: instance of ProtectedItem for rev.item (optional)
         """
         self.protector = protector
         self.rev = rev
@@ skipping 26 matching lines @@
 
     def __enter__(self):
         return self
 
     def __exit__(self, exc_type, exc_value, exc_tb):
         self.close()
 
     def __cmp__(self, other):
         return cmp(self.meta, other.meta)