X-Git-Url: https://git.mdrn.pl/redakcja.git/blobdiff_plain/a130412e611a2a29bf0cc9bbbfdefea0b1d0061f..352b8591bd1c7163835a6fa1db34d3e2861c1071:/lib/hg.py

diff --git a/lib/hg.py b/lib/hg.py
index e785b375..06e9f832 100644
--- a/lib/hg.py
+++ b/lib/hg.py
@@ -1,13 +1,17 @@
 # -*- coding: utf-8 -*-
 import os
-import codecs
-from mercurial import localrepo, ui, error, match, node, encoding
+from mercurial import localrepo, ui, encoding, util
+import mercurial.merge, mercurial.error
 
 encoding.encoding = 'utf-8'
 
-class RepositoryDoesNotExist(Exception):
-    pass
+X = 'g\xc5\xbceg\xc5\xbc\xc3\xb3\xc5\x82ka'
 
+def sanitize_string(path):
+    if isinstance(path, unicode): #
+        return path.encode('utf-8')
+    else: # it's a string, so we have no idea what encoding it is
+        return path
 
 class Repository(object):
     """Abstrakcja repozytorium Mercurial. Działa z Mercurial w wersji 1.3.1."""
@@ -17,15 +21,14 @@ class Repository(object):
         self.ui.config('ui', 'quiet', 'true')
         self.ui.config('ui', 'interactive', 'false')
         
-        self.real_path = os.path.realpath(path)
-        self.repo = self.open_repository(self.real_path, create)
-        self._pending_files = []
-    
-    def open_repository(self, path, create=False):
+        self.real_path = sanitize_string(os.path.realpath(path))
+        self.repo = self._open_repository(self.real_path, create)
+
+    def _open_repository(self, path, create=False):
         if os.path.isdir(path):
             try:
                 return localrepo.localrepository(self.ui, path)
-            except error.RepoError:
+            except mercurial.error.RepoError:
                 # dir is not an hg repo, we must init it
                 if create:
                     return localrepo.localrepository(self.ui, path, create=1)
@@ -34,78 +37,199 @@ class Repository(object):
             return localrepo.localrepository(self.ui, path, create=1)
         raise RepositoryDoesNotExist("Repository %s does not exist." % path)
         
-    def all_files(self):
-        return list(self.repo['tip'])
-    
-    def get_file(self, path):
-        ctx = self.repo.changectx(None)
-        return ctx.filectx(path)
+    def file_list(self, branch):
+        return self.in_branch(lambda: self._file_list(), branch)
+
+    def _file_list(self):
+        return list(self.repo[None])
     
-    def add_file(self, path, value):
-        f = codecs.open(os.path.join(self.real_path, path), 'w', encoding='utf-8')
-        f.write(value)
-        f.close()
+    def get_file(self, path, branch):
+        return self.in_branch(lambda: self._get_file(path), branch)
+
+    def _get_file(self, path):
+        path = sanitize_string(path)
+        if not self._file_exists(path):
+            raise RepositoryException("File not availble in this branch.")
+        
+        return self.repo.wread(path)
+
+    def file_exists(self, path, branch):
+        return self.in_branch(lambda: self._file_exists(path), branch)
+
+    def _file_exists(self, path):
+        path = sanitize_string(path)
+        return self.repo.dirstate[path] != "?"
+
+    def write_file(self, path, value, branch):
+        return self.in_branch(lambda: self._write_file(path, value), branch)
+
+    def _write_file(self, path, value):
+        path = sanitize_string(path)
+        return self.repo.wwrite(path, value, [])
+
+    def add_file(self, path, value, branch):
+        return self.in_branch(lambda: self._add_file(path, value), branch)
 
-        if path not in self._pending_files:
-            self._pending_files.append(path)
+    def _add_file(self, path, value):
+        path = sanitize_string(path)
+        self._write_file(path, value)
+        return self.repo.add( [path] )
+
+    def _commit(self, message, user=None):
+        return self.repo.commit(text=sanitize_string(message), user=sanitize_string(user))
     
-    def commit(self, message=u'hgshelve auto commit', key=None, user=None):
-        """
-        Commit unsynchronized data to disk.
-        Arguments::
-
-         - message: mercurial's changeset message
-         - key: supply to sync only one key
-        """
-        if isinstance(message, unicode):
-            message = message.encode('utf-8')
-        if isinstance(user, unicode):
-            user = user.encode('utf-8')
+    def commit(self, message, branch, user=None):
+        return self.in_branch(lambda: self._commit(message, key=key, user=user), branch)
+
+    def in_branch(self, action, bname):
+        wlock = self.repo.wlock()
+        try:
+            old = self._switch_to_branch(bname)
+            try:
+                # do some stuff
+                return action()
+            finally:
+                self._switch_to_branch(old)
+        finally:
+            wlock.release()
+
+    def merge_branches(self, bnameA, bnameB, user, message):
+        wlock = self.repo.wlock()
+        try:
+            return self.merge_revisions(self.get_branch_tip(bnameA),
+                self.get_branch_tip(bnameB), user, message)
+        finally:
+            wlock.release()
+
+    def diff(self, revA, revB):
+        return UpdateStatus(self.repo.status(revA, revB))
+
+    def merge_revisions(self, revA, revB, user, message):
+        wlock = self.repo.wlock()
+        try:
+            old = self.repo[None]
+            
+            self._checkout(revA)
+            mergestatus = self._merge(revB)
+            if not mergestatus.isclean():
+                # revert the failed merge
+                self.repo.recover()
+                raise UncleanMerge(u'Failed to merge %d files.' % len(mergestatus.unresolved))
+
+            # commit the clean merge
+            self._commit(message, user)
+
+            # cleanup after yourself
+            self._checkout(old.rev())
+        except util.Abort, ae:
+            raise RepositoryException(u'Failed merge: ' + ae.message)
+        finally:
+            wlock.release()
+
+    def common_ancestor(self, revA, revB):
+        return self.repo[revA].ancestor(self.repo[revB])
+        
+    def _checkout(self, rev, force=True):
+        return MergeStatus(mercurial.merge.update(self.repo, rev, False, force, None))
         
-        commited = False
-        rev = None
-        files_to_add = []
-        files_to_remove = []
-        files_to_commit = []
-
-        # first of all, add absent data and clean removed
-        if key is None:
-            # will commit all keys
-            pending_files = self._pending_files
-        else:
-            if keys not in self._pending_files:
-                # key isn't changed
-                return None
-            else:
-                pending_files = [key]
-        for path in pending_files:
-            files_to_commit.append(path)
-            if path in self.all_files():
-                if not os.path.exists(os.path.join(self.real_path, path)):
-                    # file removed
-                    files_to_remove.append(path)
-            else:
-                # file added
-                files_to_add.append(path)
-        # hg add
-        if files_to_add:
-            self.repo.add(files_to_add)
-        # hg forget
-        if files_to_remove:
-            self.repo.forget(files_to_remove)
-        # ---- hg commit
-        if files_to_commit:
-            for i, f in enumerate(files_to_commit):
-                if isinstance(f, unicode):
-                    files_to_commit[i] = f.encode('utf-8')
-            matcher = match.match(self.repo.root, self.repo.root, files_to_commit, default='path')
-            rev = self.repo.commit(message, user=user, match=matcher)
-            commited = True
-        # clean pending keys
-        for key in pending_files:
-            self._pending_files.remove(key)
-        # if commited:
-            # reread keys
-            # self._keys = self.get_persisted_objects_keys()
-            # return node.hex(rev)
+    def _merge(self, rev):
+        """ Merge the revision into current working directory """
+        return MergeStatus(mercurial.merge.update(self.repo, rev, True, False, None))
+
+    def _switch_to_branch(self, bname):
+        bname = sanitize_string(bname)
+        wlock = self.repo.wlock()
+        try:
+            current = self.repo[None].branch()
+            if current == bname:
+                return current
             
+            tip = self.get_branch_tip(bname)
+            status = self._checkout(tip)
+
+            if not status.isclean():
+                raise RepositoryException("Unclean branch switch. This IS REALLY bad.")
+            
+            return current 
+        except KeyError, ke:
+            raise RepositoryException((u"Can't switch to branch '%s': no such branch." % bname) , ke)
+        except util.Abort, ae:
+            raise RepositoryException(u"Can't switch to branch '%s': %s"  % (bname, ae.message), ae)
+        finally:
+            wlock.release()
+
+    def with_wlock(self, action):
+        wlock = self.repo.wlock()
+        try:
+            action()
+        finally:
+            wlock.release()
+
+    def _create_branch(self, name, parent_rev, msg=None, before_commit=None):
+        """WARNING: leaves the working directory in the new branch"""
+        name = sanitize_string(name)
+        
+        if self.has_branch(name): return # just exit
+
+        self._checkout(parent_rev)
+        self.repo.dirstate.setbranch(name)
+        
+        if msg is None:
+            msg = "Initial commit for branch '%s'." % name
+
+        if before_commit: before_commit()        
+        self._commit(msg, user='platform')
+        return self.get_branch_tip(name)
+
+    def write_lock(self):
+        """Returns w write lock to the repository."""
+        return self.repo.wlock()
+
+    def has_branch(self, name):
+        name = sanitize_string(name)
+        return (name in self.repo.branchmap().keys())
+    
+    def get_branch_tip(self, name):
+        name = sanitize_string(name)
+        return self.repo.branchtags()[name]
+
+    def getnode(self, rev):
+        return self.repo[rev]
+
+class MergeStatus(object):
+
+    def __init__(self, mstatus):       
+        self.updated = mstatus[0]
+        self.merged = mstatus[1]
+        self.removed = mstatus[2]
+        self.unresolved = mstatus[3]
+
+    def isclean(self):
+        return self.unresolved == 0
+
+class UpdateStatus(object):
+
+    def __init__(self, mstatus):
+        self.modified = mstatus[0]
+        self.added = mstatus[1]
+        self.removed = mstatus[2]
+        self.deleted = mstatus[3]
+        self.untracked = mstatus[4]
+        self.ignored = mstatus[5]
+        self.clean = mstatus[6]
+
+    def has_changes(self):
+        return bool( len(self.modified) + len(self.added) + \
+            len(self.removed) + len(self.deleted) )
+
+class RepositoryException(Exception):
+    def __init__(self, msg, cause=None):
+        Exception.__init__(self, msg)
+        self.cause = cause
+
+class UncleanMerge(RepositoryException):
+    pass
+
+class RepositoryDoesNotExist(RepositoryException):
+    pass
+