lib/wlrepo/mercurial_backend/document.py

   1 # -*- encoding: utf-8 -*-
   2
   3 import logging
   4 log = logging.getLogger('ral.mercurial')
   5
   6 __author__ = "Łukasz Rekucki"
   7 __date__ = "$2009-09-25 09:35:06$"
   8 __doc__ = "Module documentation."
   9
  10 import wlrepo
  11 import mercurial.error
  12 import re
  13
  14 import logging
  15 log = logging.getLogger('wlrepo.document')
  16
  17 class MercurialDocument(wlrepo.Document):
  18
  19     def data(self, entry):
  20         path = self._library._sanitize_string(self.id + u'.' + entry)
  21         try:
  22             return self._library._filectx(path, \
  23                 self._revision.hgrev()).data().decode('utf-8')
  24         except mercurial.error.LookupError, e:
  25             fl = [x.decode('utf-8') for x in self._revision._changectx]
  26             raise wlrepo.EntryNotFound(self._revision, path.decode('utf-8'), fl)
  27
  28     def quickwrite(self, entry, data, msg, user=None):
  29         user = user or self.owner
  30
  31         if isinstance(data, unicode):
  32             data = data.encode('utf-8')
  33
  34         user = self._library._sanitize_string(user)
  35         msg = self._library._sanitize_string(msg)
  36         entry = self._library._sanitize_string(entry)
  37
  38         if user is None:
  39             raise ValueError("Can't determine user.")
  40
  41         def write(l, r):
  42             f = l._fileopen(r(entry), "w+")
  43             f.write(data)
  44             f.close()
  45             l._fileadd(r(entry))
  46
  47         return self.invoke_and_commit(write, lambda d: (msg, \
  48                 self._library._sanitize_string(self.owner)) )
  49
  50     def invoke_and_commit(self, ops, commit_info):
  51         lock = self._library.lock()
  52         try:
  53             self._library._checkout(self._revision.hgrev())
  54
  55             def entry_path(entry):
  56                 return self._library._sanitize_string(self.id + u'.' + entry)
  57
  58             ops(self._library, entry_path)
  59             message, user = commit_info(self)
  60
  61             message = self._library._sanitize_string(message)
  62             user = self._library._sanitize_string(user)
  63
  64             self._library._commit(message, user)
  65             try:
  66                 return self._library.document(docid=self.id, user=user)
  67             except Exception, e:
  68                 # rollback the last commit
  69                 self._library._rollback()
  70                 raise e
  71         finally:
  72             lock.release()
  73
  74     # def commit(self, message, user):
  75     #    """Make a new commit."""
  76     #    self.invoke_and_commit(message, user, lambda *a: True)
  77
  78     def ismain(self):
  79         return self._revision.user_name is None
  80
  81     def islatest(self):
  82         return (self == self.latest())
  83
  84     def shared(self):
  85         if self.ismain():
  86             return self
  87
  88         return self._library.document(docid=self.id)
  89
  90     def latest(self):
  91         return self._library.document(docid=self.id, user=self.owner)
  92
  93     def take(self, user):
  94         fullid = self._library.fulldocid(self.id, user)
  95
  96         def take_action(library, resolve):
  97             # branch from latest
  98             library._set_branchname(fullid)
  99
 100         if not self._library.has_revision(fullid):
 101             log.info("Checking out document %s" % fullid)
 102
 103             self.invoke_and_commit(take_action, \
 104                 lambda d: ("$AUTO$ File checkout.", user) )
 105
 106         return self._library.document_for_rev(fullid)
 107
 108     def up_to_date(self):
 109         return self.ismain() or (\
 110             self.shared().ancestorof(self) )
 111
 112
 113     def update(self, user):
 114         """Update parts of the document."""
 115         lock = self.library.lock()
 116         try:
 117             if self.ismain():
 118                 # main revision of the document
 119                 return self
 120
 121             if self._revision.has_children():
 122                 raise UpdateException("Revision has children.")
 123
 124             sv = self.shared()
 125
 126             if self.parentof(sv):
 127                 return self
 128
 129             if sv.ancestorof(self):
 130                 return self
 131
 132             if self._revision.merge_with(sv._revision, user=user,\
 133                 message="$AUTO$ Personal branch update."):
 134                 return self.latest()
 135             else:
 136                 raise UpdateException("Merge failed.")
 137         finally:
 138             lock.release()
 139
 140     def share(self, message):
 141         lock = self.library.lock()
 142         try:
 143             if self.ismain():
 144                 return False # always shared
 145
 146             user = self._revision.user_name
 147             main = self.shared()._revision
 148             local = self._revision
 149
 150             # Case 1:
 151             #         * local
 152             #         |
 153             #         * <- can also be here!
 154             #        /|
 155             #       / |
 156             # main *  *
 157             #      |  |
 158             # The local branch has been recently updated,
 159             # so we don't need to update yet again, but we need to
 160             # merge down to default branch, even if there was
 161             # no commit's since last update
 162             #
 163             # This is actually the only good case!
 164             if main.ancestorof(local):
 165                 success, changed = main.merge_with(local, user=user, message=message)
 166
 167                 if not success:
 168                     raise LibraryException("Merge failed.")
 169
 170                 return changed
 171
 172             # Case 2:
 173             # main *
 174             #      |
 175             #      * <- this case overlaps with previos one
 176             #      |\
 177             #      | \
 178             #      |  * local
 179             #      |  |
 180             #
 181             # There was a recent merge to the defaul branch and
 182             # no changes to local branch recently.
 183             #
 184             # Nothing to do
 185             elif local.ancestorof(main):
 186                 return False
 187
 188             # In all other cases, the local needs an update
 189             # and possibly conflict resolution, so fail
 190             raise LibraryExcepton("Document not prepared for sharing.")
 191
 192         finally:
 193             lock.release()
 194
 195
 196     def has_conflict_marks(self):
 197         return re.search("^(?:<<<<<<< .*|=======|>>>>>>> .*)$", self.data('xml'), re.MULTILINE)
 198
 199     def __unicode__(self):
 200         return u"Document(%s:%s)" % (self.id, self.owner)
 201
 202     def __str__(self):
 203         return self.__unicode__().encode('utf-8')
 204
 205     def __eq__(self, other):
 206         return (self._revision == other._revision)
 207