lib/vstorage.py

   1 # -*- coding: utf-8 -*-
   2 import os
   3 import tempfile
   4 import datetime
   5 import mimetypes
   6 import urllib
   7
   8 # Note: we have to set these before importing Mercurial
   9 os.environ['HGENCODING'] = 'utf-8'
  10 os.environ['HGMERGE'] = "internal:merge"
  11
  12 import mercurial.hg
  13 import mercurial.ui
  14 import mercurial.revlog
  15 import mercurial.util
  16
  17
  18 def urlquote(url, safe='/'):
  19     """Quotes URL
  20
  21     >>> urlquote(u'Za\u017c\xf3\u0142\u0107 g\u0119\u015bl\u0105 ja\u017a\u0144')
  22     'Za%C5%BC%C3%B3%C5%82%C4%87_g%C4%99%C5%9Bl%C4%85_ja%C5%BA%C5%84'
  23     """
  24     return urllib.quote(url.replace(' ', '_').encode('utf-8', 'ignore'), safe)
  25
  26
  27 def urlunquote(url):
  28     """Unqotes URL
  29
  30     # >>> urlunquote('Za%C5%BC%C3%B3%C5%82%C4%87_g%C4%99%C5%9Bl%C4%85_ja%C5%BA%C5%84')
  31     # u'Za\u017c\xf3\u0142\u0107 g\u0119\u015bl\u0105 ja\u017a\u0144'
  32     """
  33     return unicode(urllib.unquote(url), 'utf-8', 'ignore').replace('_', ' ')
  34
  35
  36 def find_repo_path(path):
  37     """Go up the directory tree looking for a Mercurial repository (a directory containing a .hg subdirectory)."""
  38     while not os.path.isdir(os.path.join(path, ".hg")):
  39         old_path, path = path, os.path.dirname(path)
  40         if path == old_path:
  41             return None
  42     return path
  43
  44
  45 def locked_repo(func):
  46     """A decorator for locking the repository when calling a method."""
  47
  48     def new_func(self, *args, **kwargs):
  49         """Wrap the original function in locks."""
  50
  51         wlock = self.repo.wlock()
  52         lock = self.repo.lock()
  53         try:
  54             func(self, *args, **kwargs)
  55         finally:
  56             lock.release()
  57             wlock.release()
  58
  59     return new_func
  60
  61
  62 def guess_mime(file_name):
  63     """
  64     Guess file's mime type based on extension.
  65     Default ot text/x-wiki for files without an extension.
  66
  67     >>> guess_mime('something.txt')
  68     'text/plain'
  69     >>> guess_mime('SomePage')
  70     'text/x-wiki'
  71     >>> guess_mime(u'ąęśUnicodePage')
  72     'text/x-wiki'
  73     >>> guess_mime('image.png')
  74     'image/png'
  75     >>> guess_mime('style.css')
  76     'text/css'
  77     >>> guess_mime('archive.tar.gz')
  78     'archive/gzip'
  79     """
  80
  81     mime, encoding = mimetypes.guess_type(file_name, strict=False)
  82     if encoding:
  83         mime = 'archive/%s' % encoding
  84     if mime is None:
  85         mime = 'text/x-wiki'
  86     return mime
  87
  88
  89 class DocumentNotFound(Exception):
  90     pass
  91
  92
  93 class VersionedStorage(object):
  94     """
  95     Provides means of storing text pages and keeping track of their
  96     change history, using Mercurial repository as the storage method.
  97     """
  98
  99     def __init__(self, path, charset=None):
 100         """
 101         Takes the path to the directory where the pages are to be kept.
 102         If the directory doen't exist, it will be created. If it's inside
 103         a Mercurial repository, that repository will be used, otherwise
 104         a new repository will be created in it.
 105         """
 106
 107         self.charset = charset or 'utf-8'
 108         self.path = path
 109         if not os.path.exists(self.path):
 110             os.makedirs(self.path)
 111         self.repo_path = find_repo_path(self.path)
 112         try:
 113             self.ui = mercurial.ui.ui(report_untrusted=False,
 114                                       interactive=False, quiet=True)
 115         except TypeError:
 116             # Mercurial 1.3 changed the way we setup the ui object.
 117             self.ui = mercurial.ui.ui()
 118             self.ui.quiet = True
 119             self.ui._report_untrusted = False
 120             self.ui.setconfig('ui', 'interactive', False)
 121         if self.repo_path is None:
 122             self.repo_path = self.path
 123             create = True
 124         else:
 125             create = False
 126         self.repo_prefix = self.path[len(self.repo_path):].strip('/')
 127         self.repo = mercurial.hg.repository(self.ui, self.repo_path,
 128                                             create=create)
 129
 130     def reopen(self):
 131         """Close and reopen the repo, to make sure we are up to date."""
 132
 133         self.repo = mercurial.hg.repository(self.ui, self.repo_path)
 134
 135     def _file_path(self, title):
 136         return os.path.join(self.path, urlquote(title, safe=''))
 137
 138     def _title_to_file(self, title):
 139         return os.path.join(self.repo_prefix, urlquote(title, safe=''))
 140
 141     def _file_to_title(self, filename):
 142         assert filename.startswith(self.repo_prefix)
 143         name = filename[len(self.repo_prefix):].strip('/')
 144         return urlunquote(name)
 145
 146     def __contains__(self, title):
 147         return os.path.exists(self._file_path(title))
 148
 149     def __iter__(self):
 150         return self.all_pages()
 151
 152     def merge_changes(self, changectx, repo_file, text, user, parent):
 153         """Commits and merges conflicting changes in the repository."""
 154         tip_node = changectx.node()
 155         filectx = changectx[repo_file].filectx(parent)
 156         parent_node = filectx.changectx().node()
 157
 158         self.repo.dirstate.setparents(parent_node)
 159         node = self._commit([repo_file], text, user)
 160
 161         partial = lambda filename: repo_file == filename
 162
 163         # If p1 is equal to p2, there is no work to do. Even the dirstate is correct.
 164         p1, p2 = self.repo[None].parents()[0], self.repo[tip_node]
 165         if p1 == p2:
 166             return text
 167
 168         # TODO: Check if merge was successful
 169         mercurial.merge.update(self.repo, tip_node, True, False, partial)
 170
 171         self.repo.dirstate.setparents(tip_node, node)
 172         # Mercurial 1.1 and later need updating the merge state
 173         try:
 174             mercurial.merge.mergestate(self.repo).mark(repo_file, "r")
 175         except (AttributeError, KeyError):
 176             pass
 177         return u'merge of edit conflict'
 178
 179     @locked_repo
 180     def save_file(self, title, file_name, author=u'', comment=u'', parent=None):
 181         """Save an existing file as specified page."""
 182
 183         user = author.encode('utf-8') or u'anon'.encode('utf-8')
 184         text = comment.encode('utf-8') or u'comment'.encode('utf-8')
 185         repo_file = self._title_to_file(title)
 186         file_path = self._file_path(title)
 187         mercurial.util.rename(file_name, file_path)
 188         changectx = self._changectx()
 189         try:
 190             filectx_tip = changectx[repo_file]
 191             current_page_rev = filectx_tip.filerev()
 192         except mercurial.revlog.LookupError:
 193             self.repo.add([repo_file])
 194             current_page_rev = -1
 195         if parent is not None and current_page_rev != parent:
 196             msg = self.merge_changes(changectx, repo_file, text, user, parent)
 197             user = '<wiki>'
 198             text = msg.encode('utf-8')
 199         self._commit([repo_file], text, user)
 200
 201
 202     def _commit(self, files, text, user):
 203         try:
 204             return self.repo.commit(files=files, text=text, user=user,
 205                                     force=True, empty_ok=True)
 206         except TypeError:
 207             # Mercurial 1.3 doesn't accept empty_ok or files parameter
 208             match = mercurial.match.exact(self.repo_path, '', list(files))
 209             return self.repo.commit(match=match, text=text, user=user,
 210                                     force=True)
 211
 212
 213     def save_data(self, title, data, author=u'', comment=u'', parent=None):
 214         """Save data as specified page."""
 215
 216         try:
 217             temp_path = tempfile.mkdtemp(dir=self.path)
 218             file_path = os.path.join(temp_path, 'saved')
 219             f = open(file_path, "wb")
 220             f.write(data)
 221             f.close()
 222             self.save_file(title, file_path, author, comment, parent)
 223         finally:
 224             try:
 225                 os.unlink(file_path)
 226             except OSError:
 227                 pass
 228             try:
 229                 os.rmdir(temp_path)
 230             except OSError:
 231                 pass
 232
 233     def save_text(self, title, text, author=u'', comment=u'', parent=None):
 234         """Save text as specified page, encoded to charset."""
 235
 236         data = text.encode(self.charset)
 237         self.save_data(title, data, author, comment, parent)
 238
 239     def page_text(self, title):
 240         """Read unicode text of a page."""
 241
 242         data = self.open_page(title).read()
 243         text = unicode(data, self.charset, 'replace')
 244         return text
 245
 246     def page_lines(self, page):
 247         for data in page:
 248             yield unicode(data, self.charset, 'replace')
 249
 250     @locked_repo
 251     def delete_page(self, title, author=u'', comment=u''):
 252         user = author.encode('utf-8') or 'anon'
 253         text = comment.encode('utf-8') or 'deleted'
 254         repo_file = self._title_to_file(title)
 255         file_path = self._file_path(title)
 256         try:
 257             os.unlink(file_path)
 258         except OSError:
 259             pass
 260         self.repo.remove([repo_file])
 261         self._commit([repo_file], text, user)
 262
 263     def open_page(self, title):
 264         try:
 265             return open(self._file_path(title), "rb")
 266         except IOError:
 267             raise DocumentNotFound()
 268
 269     def page_file_meta(self, title):
 270         """Get page's inode number, size and last modification time."""
 271
 272         try:
 273             (st_mode, st_ino, st_dev, st_nlink, st_uid, st_gid, st_size,
 274              st_atime, st_mtime, st_ctime) = os.stat(self._file_path(title))
 275         except OSError:
 276             return 0, 0, 0
 277         return st_ino, st_size, st_mtime
 278
 279     def page_meta(self, title):
 280         """Get page's revision, date, last editor and his edit comment."""
 281
 282         filectx_tip = self._find_filectx(title)
 283         if filectx_tip is None:
 284             raise DocumentNotFound()
 285             #return -1, None, u'', u''
 286         rev = filectx_tip.filerev()
 287         filectx = filectx_tip.filectx(rev)
 288         date = datetime.datetime.fromtimestamp(filectx.date()[0])
 289         author = unicode(filectx.user(), "utf-8",
 290                          'replace').split('<')[0].strip()
 291         comment = unicode(filectx.description(), "utf-8", 'replace')
 292         return rev, date, author, comment
 293
 294     def repo_revision(self):
 295         return self._changectx().rev()
 296
 297     def page_mime(self, title):
 298         """
 299         Guess page's mime type based on corresponding file name.
 300         Default ot text/x-wiki for files without an extension.
 301         """
 302         return guess_type(self._file_path(title))
 303
 304     def _changectx(self):
 305         """Get the changectx of the tip."""
 306         try:
 307             # This is for Mercurial 1.0
 308             return self.repo.changectx()
 309         except TypeError:
 310             # Mercurial 1.3 (and possibly earlier) needs an argument
 311             return self.repo.changectx('tip')
 312
 313     def _find_filectx(self, title):
 314         """Find the last revision in which the file existed."""
 315
 316         repo_file = self._title_to_file(title)
 317         changectx = self._changectx()
 318         stack = [changectx]
 319         while repo_file not in changectx:
 320             if not stack:
 321                 return None
 322             changectx = stack.pop()
 323             for parent in changectx.parents():
 324                 if parent != changectx:
 325                     stack.append(parent)
 326         return changectx[repo_file]
 327
 328     def page_history(self, title):
 329         """Iterate over the page's history."""
 330
 331         filectx_tip = self._find_filectx(title)
 332         if filectx_tip is None:
 333             return
 334         maxrev = filectx_tip.filerev()
 335         minrev = 0
 336         for rev in range(maxrev, minrev-1, -1):
 337             filectx = filectx_tip.filectx(rev)
 338             date = datetime.datetime.fromtimestamp(filectx.date()[0])
 339             author = unicode(filectx.user(), "utf-8",
 340                              'replace').split('<')[0].strip()
 341             comment = unicode(filectx.description(), "utf-8", 'replace')
 342             yield rev, date, author, comment
 343
 344     def page_revision(self, title, rev):
 345         """Get unicode contents of specified revision of the page."""
 346
 347         filectx_tip = self._find_filectx(title)
 348         if filectx_tip is None:
 349             raise DocumentNotFound()
 350         try:
 351             data = filectx_tip.filectx(rev).data()
 352         except IndexError:
 353             raise DocumentNotFound()
 354         return data
 355
 356     def revision_text(self, title, rev):
 357         data = self.page_revision(title, rev)
 358         text = unicode(data, self.charset, 'replace')
 359         return text
 360
 361     def history(self):
 362         """Iterate over the history of entire wiki."""
 363
 364         changectx = self._changectx()
 365         maxrev = changectx.rev()
 366         minrev = 0
 367         for wiki_rev in range(maxrev, minrev-1, -1):
 368             change = self.repo.changectx(wiki_rev)
 369             date = datetime.datetime.fromtimestamp(change.date()[0])
 370             author = unicode(change.user(), "utf-8",
 371                              'replace').split('<')[0].strip()
 372             comment = unicode(change.description(), "utf-8", 'replace')
 373             for repo_file in change.files():
 374                 if repo_file.startswith(self.repo_prefix):
 375                     title = self._file_to_title(repo_file)
 376                     try:
 377                         rev = change[repo_file].filerev()
 378                     except mercurial.revlog.LookupError:
 379                         rev = -1
 380                     yield title, rev, date, author, comment
 381
 382     def all_pages(self):
 383         """Iterate over the titles of all pages in the wiki."""
 384
 385         for filename in os.listdir(self.path):
 386             if (os.path.isfile(os.path.join(self.path, filename))
 387                 and not filename.startswith('.')):
 388                 yield urlunquote(filename)
 389
 390     def changed_since(self, rev):
 391         """Return all pages that changed since specified repository revision."""
 392
 393         try:
 394             last = self.repo.lookup(int(rev))
 395         except IndexError:
 396             for page in self.all_pages():
 397                 yield page
 398                 return
 399         current = self.repo.lookup('tip')
 400         status = self.repo.status(current, last)
 401         modified, added, removed, deleted, unknown, ignored, clean = status
 402         for filename in modified+added+removed+deleted:
 403             if filename.startswith(self.repo_prefix):
 404                 yield self._file_to_title(filename)