mercurial: comparison mercurial/phases.py

equal deleted inserted replaced

-:4ae3ba9e4d7a
+:b6081c2c4647
 - content is pushed as draft
 """
 import errno
-from node import nullid, bin, hex, short
+from node import nullid, nullrev, bin, hex, short
 from i18n import _
 allphases = public, draft, secret = range(3)
 trackedphases = allphases[1:]
 phasenames = ['public', 'draft', 'secret']
 % (short(mnode), phase))
 nodes.symmetric_difference_update(missing)
 updated = True
 return updated
-def readroots(repo, phasedefaults=None):
+def _readroots(repo, phasedefaults=None):
 """Read phase roots from disk
 phasedefaults is a list of fn(repo, roots) callable, which are
 executed if the phase roots file does not exist. When phases are
 being initialized on an existing repository, this could be used to
 dirty = True
 if _filterunknown(repo.ui, repo.changelog, roots):
 dirty = True
 return roots, dirty
-def writeroots(repo, phaseroots):
+class phasecache(object):
-"""Write phase roots from disk"""
+def __init__(self, repo, phasedefaults):
-f = repo.sopener('phaseroots', 'w', atomictemp=True)
+self.phaseroots, self.dirty = _readroots(repo, phasedefaults)
-try:
+self.opener = repo.sopener
-for phase, roots in enumerate(phaseroots):
+self._phaserevs = None
-for h in roots:
-f.write('%i %s\n' % (phase, hex(h)))
+def getphaserevs(self, repo, rebuild=False):
-finally:
+if rebuild or self._phaserevs is None:
-f.close()
+revs = [public] * len(repo.changelog)
+for phase in trackedphases:
+roots = map(repo.changelog.rev, self.phaseroots[phase])
+if roots:
+for rev in roots:
+revs[rev] = phase
+for rev in repo.changelog.descendants(*roots):
+revs[rev] = phase
+self._phaserevs = revs
+return self._phaserevs
+def invalidatephaserevs(self):
+self._phaserevs = None
+def phase(self, repo, rev):
+# We need a repo argument here to be able to build _phaserev
+# if necessary. The repository instance is not stored in
+# phasecache to avoid reference cycles. The changelog instance
+# is not stored because it is a filecache() property and can
+# be replaced without us being notified.
+if rev == nullrev:
+return public
+if self._phaserevs is None or rev >= len(self._phaserevs):
+self._phaserevs = self.getphaserevs(repo, rebuild=True)
+return self._phaserevs[rev]
+def write(self):
+if not self.dirty:
+return
+f = self.opener('phaseroots', 'w', atomictemp=True)
+try:
+for phase, roots in enumerate(self.phaseroots):
+for h in roots:
+f.write('%i %s\n' % (phase, hex(h)))
+finally:
+f.close()
+self.dirty = False
 def advanceboundary(repo, targetphase, nodes):
 """Add nodes to a phase changing other nodes phases if necessary.
 This function move boundary *forward* this means that all nodes are set
 in the target phase or kept in a *lower* phase.
 Simplify boundary to contains phase roots only."""
+phcache = repo._phasecache
 delroots = [] # set of root deleted by this path
 for phase in xrange(targetphase + 1, len(allphases)):
 # filter nodes that are not in a compatible phase already
 # XXX rev phase cache might have been invalidated by a previous loop
 # XXX we need to be smarter here
 nodes = [n for n in nodes if repo[n].phase() >= phase]
 if not nodes:
 break # no roots to move anymore
-roots = repo._phaseroots[phase]
+roots = phcache.phaseroots[phase]
 olds = roots.copy()
 ctxs = list(repo.set('roots((%ln::) - (%ln::%ln))', olds, olds, nodes))
 roots.clear()
 roots.update(ctx.node() for ctx in ctxs)
 if olds != roots:
 # invalidate cache (we probably could be smarter here
-if '_phaserev' in vars(repo):
+phcache.invalidatephaserevs()
-del repo._phaserev
+phcache.dirty = True
-repo._dirtyphases = True
 # some roots may need to be declared for lower phases
 delroots.extend(olds - roots)
 # declare deleted root in the target phase
 if targetphase != 0:
 retractboundary(repo, targetphase, delroots)
 This function move boundary *backward* this means that all nodes are set
 in the target phase or kept in a *higher* phase.
 Simplify boundary to contains phase roots only."""
-currentroots = repo._phaseroots[targetphase]
+phcache = repo._phasecache
+currentroots = phcache.phaseroots[targetphase]
 newroots = [n for n in nodes if repo[n].phase() < targetphase]
 if newroots:
 currentroots.update(newroots)
 ctxs = repo.set('roots(%ln::)', currentroots)
 currentroots.intersection_update(ctx.node() for ctx in ctxs)
-if '_phaserev' in vars(repo):
+phcache.invalidatephaserevs()
-del repo._phaserev
+phcache.dirty = True
-repo._dirtyphases = True
 def listphases(repo):
 """List phases root for serialisation over pushkey"""
 keys = {}
 value = '%i' % draft
-for root in repo._phaseroots[draft]:
+for root in repo._phasecache.phaseroots[draft]:
 keys[hex(root)] = value
 if repo.ui.configbool('phases', 'publish', True):
 # Add an extra data to let remote know we are a publishing repo.
 # Publishing repo can't just pretend they are old repo. When pushing to
 lock.release()
 def visibleheads(repo):
 """return the set of visible head of this repo"""
 # XXX we want a cache on this
-sroots = repo._phaseroots[secret]
+sroots = repo._phasecache.phaseroots[secret]
 if sroots:
 # XXX very slow revset. storing heads or secret "boundary" would help.
 revset = repo.set('heads(not (%ln::))', sroots)
 vheads = [ctx.node() for ctx in revset]
 def visiblebranchmap(repo):
 """return a branchmap for the visible set"""
 # XXX Recomputing this data on the fly is very slow.  We should build a
 # XXX cached version while computin the standard branchmap version.
-sroots = repo._phaseroots[secret]
+sroots = repo._phasecache.phaseroots[secret]
 if sroots:
 vbranchmap = {}
 for branch, nodes in  repo.branchmap().iteritems():
 # search for secret heads.
 for n in nodes:

changeset 16657	b6081c2c4647
parent 16626	503e674fb545
child 16658	6b3d31d04a69