phases: add retractboundary function to move boundary backward

The advanceboundary documentation is updated to highlight the difference.

mercurial/phases.py

@@ -1,83 +1,102 b''
 # Mercurial phases support code
 #
 # Copyright 2011 Pierre-Yves David <[e-mail]>
 #                Logilab SA        <[e-mail]>
 #                Augie Fackler     <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 import errno
 from node import nullid, bin, hex, short
 from i18n import _
 
 allphases = range(2)
 trackedphases = allphases[1:]
 
 def readroots(repo):
     """Read phase roots from disk"""
     roots = [set() for i in allphases]
     roots[0].add(nullid)
     try:
         f = repo.sopener('phaseroots')
         try:
             for line in f:
                 phase, nh = line.strip().split()
                 roots[int(phase)].add(bin(nh))
         finally:
             f.close()
     except IOError, inst:
         if inst.errno != errno.ENOENT:
             raise
     return roots
 
 def writeroots(repo):
     """Write phase roots from disk"""
     f = repo.sopener('phaseroots', 'w', atomictemp=True)
     try:
         for phase, roots in enumerate(repo._phaseroots):
             for h in roots:
                 f.write('%i %s\n' % (phase, hex(h)))
         repo._dirtyphases = False
     finally:
         f.close()
 
 def filterunknown(repo, phaseroots=None):
     """remove unknown nodes from the phase boundary
 
     no data is lost as unknown node only old data for their descentants
     """
     if phaseroots is None:
         phaseroots = repo._phaseroots
     for phase, nodes in enumerate(phaseroots):
         missing = [node for node in nodes if node not in repo]
         if missing:
             for mnode in missing:
                 msg = _('Removing unknown node %(n)s from %(p)i-phase boundary')
                 repo.ui.debug(msg, {'n': short(mnode), 'p': phase})
             nodes.symmetric_difference_update(missing)
             repo._dirtyphases = True
 
 def advanceboundary(repo, targetphase, nodes):
     """Add nodes to a phase changing other nodes phases if necessary.
 
-    Simplify boundary to contains phase roots only."""
+    This function move boundary *forward* this means that all nodes are set
+    in the target phase or kept in a *lower* phase.
 
-    # move roots of lower states
+    Simplify boundary to contains phase roots only."""
     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]
         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):
                 del repo._phaserev
             repo._dirtyphases = True
+
+def retractboundary(repo, targetphase, nodes):
+    """Set nodes back to a phase changing other nodes phases if necessary.
+
+    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]
+    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):
+            del repo._phaserev
+        repo._dirtyphases = True
+