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         if self.ismain():
 110             return True
 111
 112         shared = self.shared()
 113
 114         if shared.parentof(self):
 115             return True
 116
 117         if shared.has_parent_from(self):
 118             return True
 119
 120         return False
 121
 122     def update(self, user):
 123         """Update parts of the document."""
 124         lock = self.library.lock()
 125         try:
 126             if self.ismain():
 127                 # main revision of the document
 128                 return self
 129
 130             # check for children in this branch
 131             if self._revision.has_children(limit_branch=True):
 132                 raise wlrepo.UpdateException("Revision %s has children." % self.revision)
 133
 134             shared = self.shared()
 135
 136             # the shared version comes from our version
 137             if self.parentof(self.shared()):
 138                 return self
 139
 140             # no changes since last update
 141             if shared.ancestorof(self):
 142                 return self
 143
 144             # last share was from this branch
 145             if shared.has_parent_from(self):
 146                 return self
 147
 148             if self._revision.merge_with(sv._revision, user=user,\
 149                 message="$AUTO$ Personal branch update."):
 150                 return self.latest()
 151             else:
 152                 raise wlrepo.UpdateException("Merge failed.")
 153         finally:
 154             lock.release()
 155
 156     def share(self, message):
 157         lock = self.library.lock()
 158         try:
 159
 160             # nothing to do
 161             if self.ismain():
 162                 return self
 163
 164             shared = self.shared()
 165
 166             # we just did this - move on
 167             if self.parentof(shared):
 168                 return shared
 169
 170             # No changes since update
 171             if shared.parentof(self):
 172                 return shared
 173
 174             # The good situation
 175             #
 176             #         * local
 177             #         |
 178             #        >*
 179             #        ||
 180             #       / |
 181             # main *  *
 182             #      |  |
 183             if shared.ancestorof(self):
 184                 success = shared._revision.merge_with(self._revision, user=self.owner, message=message)
 185
 186                 if not success:
 187                     raise wlrepo.LibraryException("Merge failed.")
 188
 189                 return shared.latest()
 190
 191             raise wlrepo.LibraryException("Unrecognized share-state.")
 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