Merge branch 'master' of stigma.nowoczesnapolska.org.pl:platforma
[redakcja.git] / lib / wlrepo / mercurial_backend / library.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:33:02$"
8 __doc__ = "Module documentation."
9
10 import mercurial
11 from mercurial import localrepo as hglrepo
12 from mercurial import ui as hgui
13 from mercurial import error
14 import wlrepo
15
16 from wlrepo.mercurial_backend.revision import MercurialRevision
17 from wlrepo.mercurial_backend.document import MercurialDocument
18
19 class MergeStatus(object):
20     def __init__(self, mstatus):
21         self.updated = mstatus[0]
22         self.merged = mstatus[1]
23         self.removed = mstatus[2]
24         self.unresolved = mstatus[3]
25
26     def isclean(self):
27         return self.unresolved == 0
28
29 class UpdateStatus(object):
30
31     def __init__(self, mstatus):
32         self.modified = mstatus[0]
33         self.added = mstatus[1]
34         self.removed = mstatus[2]
35         self.deleted = mstatus[3]
36         self.untracked = mstatus[4]
37         self.ignored = mstatus[5]
38         self.clean = mstatus[6]
39
40     def has_changes(self):
41         return bool(len(self.modified) + len(self.added) + \
42                     len(self.removed) + len(self.deleted))
43
44 class MercurialLibrary(wlrepo.Library):
45     """Mercurial implementation of the Library API"""
46
47     def __init__(self, path, **kwargs):
48         super(wlrepo.Library, self).__init__( ** kwargs)
49
50         self._revcache = {}
51         self._doccache = {}
52
53         self._hgui = hgui.ui()
54         self._hgui.config('ui', 'quiet', 'true')
55         self._hgui.config('ui', 'interactive', 'false')
56
57         import os.path
58         self._ospath = self._sanitize_string(os.path.realpath(path))        
59
60         if os.path.isdir(path):
61             try:
62                 self._hgrepo = hglrepo.localrepository(self._hgui, path)
63             except mercurial.error.RepoError:
64                 raise wlrepo.LibraryException("[HGLibrary] Not a valid repository at path '%s'." % path)
65         elif kwargs.get('create', False):
66             os.makedirs(path)
67             try:
68                 self._hgrepo = hglrepo.localrepository(self._hgui, path, create=1)
69             except mercurial.error.RepoError:
70                 raise wlrepo.LibraryException("[HGLibrary] Can't create a repository on path '%s'." % path)
71         else:
72             raise wlrepo.LibraryException("[HGLibrary] Can't open a library on path '%s'." % path)
73
74
75     def documents(self):
76         return [ key[5:].decode('utf-8') for key in \
77             self._hgrepo.branchmap() if key.startswith("$doc:") ]
78
79     @property
80     def ospath(self):
81         return self._ospath.decode('utf-8')
82
83     def document_for_revision(self, revision):
84         if revision is None:
85             raise ValueError("Revision can't be None.")
86         
87         if not isinstance(revision, MercurialRevision):            
88             rev = self.get_revision(revision)
89         else:
90             rev = revision       
91
92         if not self._doccache.has_key(str(rev)):
93             self._doccache[str(rev)] = MercurialDocument(self, rev)
94
95         # every revision is a document
96         return self._doccache[str(rev)]
97
98     def document(self, docid, user=None, rev=u'latest'):
99         rev = self._sanitize_string(rev)
100         
101         if rev != u'latest':
102             doc = self.document_for_revision(rev)
103
104             if doc.id != docid or (doc.owner != user):
105                 raise wlrepo.RevisionMismatch(self.fulldocid(docid, user)+u'@'+unicode(rev))
106             
107             return doc
108         else:
109             return self.document_for_revision(self.fulldocid(docid, user))
110
111     def get_revision(self, revid):
112         revid = self._sanitize_string(revid)
113
114         log.info("Looking up rev %r (%s)" %(revid, type(revid)) )
115
116         try:           
117             ctx = self._changectx( revid )
118         except mercurial.error.RepoError, e:
119             raise wlrepo.RevisionNotFound(revid)
120
121         if ctx is None:
122             raise wlrepo.RevisionNotFound(revid)
123
124         return self._revision(ctx)       
125
126     def _revision(self, ctx):
127         if self._revcache.has_key(ctx):
128             return self._revcache[ctx]
129         
130         return MercurialRevision(self, ctx)
131
132     def fulldocid(self, docid, user=None):                
133         fulldocid = u''
134         if user is not None:
135             fulldocid += u'$user:' + user
136         fulldocid += u'$doc:' + docid
137         return fulldocid
138
139     def has_revision(self, revid):
140         revid = self._sanitize_string(revid)
141         
142         try:
143             self._hgrepo[revid]
144             return True
145         except mercurial.error.RepoError:
146             return False
147
148     def document_create(self, docid):       
149         
150         # check if it already exists
151         fullid = self.fulldocid(docid)
152
153         if self.has_revision(fullid):
154             raise wlrepo.DocumentAlreadyExists(u"Document %s already exists!" % docid);
155
156         # doesn't exist
157         self._create_branch(self._sanitize_string(fullid))
158         return self.document_for_revision(fullid)
159
160     #
161     # Private methods
162     #
163
164     #
165     # Locking
166     #
167
168     def lock(self, write_mode=False):
169         return self._hgrepo.wlock() # no support for read/write mode yet
170
171     def _transaction(self, write_mode, action):
172         lock = self.lock(write_mode)
173         try:
174             return action(self)
175         finally:
176             lock.release()
177
178     #
179     # Basic repo manipulation
180     #
181
182     def _checkout(self, rev, force=True):
183         return MergeStatus(mercurial.merge.update(self._hgrepo, rev, False, force, None))
184
185     def _merge(self, rev):
186         """ Merge the revision into current working directory """
187         return MergeStatus(mercurial.merge.update(self._hgrepo, rev, True, False, None))
188
189     def _common_ancestor(self, revA, revB):
190         return self._hgrepo[revA].ancestor(self.repo[revB])
191
192     def _commit(self, message, user=u"library"):
193         return self._hgrepo.commit(text=message, user=user)
194
195
196     def _fileexists(self, fileid):
197         return (fileid in self._hgrepo[None])
198
199     def _fileadd(self, fileid):
200         return self._hgrepo.add([fileid])
201
202     def _filesadd(self, fileid_list):
203         return self._hgrepo.add(fileid_list)
204
205     def _filerm(self, fileid):
206         return self._hgrepo.remove([fileid])
207
208     def _filesrm(self, fileid_list):
209         return self._hgrepo.remove(fileid_list)   
210
211     def _fileopen(self, path, mode):
212         return self._hgrepo.wopener(path, mode)
213
214     def _filectx(self, fileid, revid):
215         return self._hgrepo.filectx(fileid, changeid=revid)
216
217     def _changectx(self, nodeid):
218         return self._hgrepo.changectx(nodeid)
219
220     def _rollback(self):
221         return self._hgrepo.rollback()
222
223     #
224     # BASIC BRANCH routines
225     #
226
227     def _bname(self, user, docid):
228         """Returns a branch name for a given document and user."""
229         docid = self._sanitize_string(docid)
230         uname = self._sanitize_string(user)
231         return "personal_" + uname + "_file_" + docid;
232
233     def _has_branch(self, name):
234         return self._hgrepo.branchmap().has_key(self._sanitize_string(name))
235
236     def _branch_tip(self, name):
237         name = self._sanitize_string(name)
238         return self._hgrepo.branchtags()[name]    
239
240     def _create_branch(self, name, parent=None, before_commit=None, message=None):
241         name = self._sanitize_string(name)
242
243         if self._has_branch(name): return # just exit
244
245         if parent is None:
246             parentrev = self._hgrepo['$branchbase'].node()
247         else:
248             parentrev = parent.hgrev()
249
250         self._checkout(parentrev)
251         self._set_branchname(name)
252
253         if before_commit: before_commit(self)
254
255         message = message or "$ADMN$ Initial commit for branch '%s'." % name
256         self._commit(message, user='$library')
257
258     def _set_branchname(self, name):
259         name = self._sanitize_string(name)
260         self._hgrepo.dirstate.setbranch(name)
261
262     def _switch_to_branch(self, branchname):
263         current = self._hgrepo[None].branch()
264
265         if current == branchname:
266             return current # quick exit
267
268         self._checkout(self._branch_tip(branchname))
269         return branchname    
270
271     #
272     # Utils
273     #
274
275     @staticmethod
276     def _sanitize_string(s):
277         if s is None:
278             return None
279
280         if isinstance(s, unicode):
281             s = s.encode('utf-8')        
282
283         return s