65 import struct

    65 import struct

    66 import re

    66 import re

    67 import collections

    67 import collections

    68 import socket

    68 import socket

    69 import errno

    69 import errno

    70 sha1re = re.compile(r'\b[0-9a-f]{6,40}\b')

    71 sha1re = re.compile(r'\b[0-9a-f]{6,40}\b')

    71 

    72 

    72 import mercurial

    73 import mercurial

    73 from mercurial import util

    74 from mercurial import util

    74 from mercurial import repair

    75 from mercurial import repair

    84     gboptslist = gboptsmap = None

    85     gboptslist = gboptsmap = None

    85 

    86 

    86 # Flags for enabling optional parts of evolve

    87 # Flags for enabling optional parts of evolve

    87 commandopt = 'allnewcommands'

    88 commandopt = 'allnewcommands'

    88 

    89 

    90 from mercurial import cmdutil

    91 from mercurial import cmdutil

    91 from mercurial import commands

    92 from mercurial import commands

    92 from mercurial import context

    93 from mercurial import context

    93 from mercurial import copies

    94 from mercurial import copies

    94 from mercurial import error

    95 from mercurial import error

   114 

   115 

   115 cmdtable = {}

   116 cmdtable = {}

   116 command = cmdutil.command(cmdtable)

   117 command = cmdutil.command(cmdtable)

   117 

   118 

   118 _pack = struct.pack

   119 _pack = struct.pack

   119 

   121 

   120 if gboptsmap is not None:

   122 if gboptsmap is not None:

   121     memfilectx = context.memfilectx

   123     memfilectx = context.memfilectx

   122 elif gboptslist is not None:

   124 elif gboptslist is not None:

   123     oldmemfilectx = context.memfilectx

   125     oldmemfilectx = context.memfilectx

   124     def memfilectx(repo, *args, **kwargs):

   126     def memfilectx(repo, *args, **kwargs):

   125         return oldmemfilectx(*args, **kwargs)

   127         return oldmemfilectx(*args, **kwargs)

   126 else:

   128 else:

   128 

   131 

   129 aliases, entry = cmdutil.findcmd('commit', commands.table)

   132 aliases, entry = cmdutil.findcmd('commit', commands.table)

   130 hasinteractivemode = any(['interactive' in e for e in entry[1]])

   133 hasinteractivemode = any(['interactive' in e for e in entry[1]])

   131 if hasinteractivemode:

   134 if hasinteractivemode:

   132     interactiveopt = [['i', 'interactive', None, _('use interactive mode')]]

   135     interactiveopt = [['i', 'interactive', None, _('use interactive mode')]]

   413         for cmd in evolvecommands:

   416         for cmd in evolvecommands:

   414             matchingevolvecommands = [e for e in cmdtable.keys() if cmd in e]

   417             matchingevolvecommands = [e for e in cmdtable.keys() if cmd in e]

   415             if not matchingevolvecommands:

   418             if not matchingevolvecommands:

   416                 raise error.Abort(_('unknown command: %s') % cmd)

   419                 raise error.Abort(_('unknown command: %s') % cmd)

   417             elif len(matchingevolvecommands) > 1:

   420             elif len(matchingevolvecommands) > 1:

   420             else:

   423             else:

   421                 whitelist.add(matchingevolvecommands[0])

   424                 whitelist.add(matchingevolvecommands[0])

   422         for disabledcmd in set(cmdtable) - whitelist:

   425         for disabledcmd in set(cmdtable) - whitelist:

   423             del cmdtable[disabledcmd]

   426             del cmdtable[disabledcmd]

   424 

   427 

   745 def push(orig, repo, *args, **opts):

   748 def push(orig, repo, *args, **opts):

   746     """Add a hint for "hg evolve" when troubles make push fails

   749     """Add a hint for "hg evolve" when troubles make push fails

   747     """

   750     """

   748     try:

   751     try:

   749         return orig(repo, *args, **opts)

   752         return orig(repo, *args, **opts)

   751         hint = _("use 'hg evolve' to get a stable history "

   754         hint = _("use 'hg evolve' to get a stable history "

   752                  "or --force to ignore warnings")

   755                  "or --force to ignore warnings")

   753         if (len(ex.args) >= 1

   756         if (len(ex.args) >= 1

   754             and ex.args[0].startswith('push includes ')

   757             and ex.args[0].startswith('push includes ')

   755             and ex.hint is None):

   758             and ex.hint is None):

   762         if count:

   765         if count:

   763             ui.write(s)

   766             ui.write(s)

   764         else:

   767         else:

   765             ui.note(s)

   768             ui.note(s)

   766 

   769 

   773 

   781 

   774 @eh.extsetup

   782 @eh.extsetup

   775 def obssummarysetup(ui):

   783 def obssummarysetup(ui):

   776     cmdutil.summaryhooks.add('evolve', summaryhook)

   784     cmdutil.summaryhooks.add('evolve', summaryhook)

   777 

   785 

   787     try:

   795     try:

   788         rebase = extensions.find('rebase')

   796         rebase = extensions.find('rebase')

   789         if rebase:

   797         if rebase:

   790             extensions.wrapcommand(rebase.cmdtable, 'rebase', warnobserrors)

   798             extensions.wrapcommand(rebase.cmdtable, 'rebase', warnobserrors)

   791     except KeyError:

   799     except KeyError:

   793     try:

   801     try:

   794         histedit = extensions.find('histedit')

   802         histedit = extensions.find('histedit')

   795         if histedit:

   803         if histedit:

   796             extensions.wrapcommand(histedit.cmdtable, 'histedit', warnobserrors)

   804             extensions.wrapcommand(histedit.cmdtable, 'histedit', warnobserrors)

   797     except KeyError:

   805     except KeyError:

   799 

   807 

   800 #####################################################################

   808 #####################################################################

   801 ### Old Evolve extension content                                  ###

   809 ### Old Evolve extension content                                  ###

   802 #####################################################################

   810 #####################################################################

   803 

   811 

   888         updatebookmarks(newid)

   896         updatebookmarks(newid)

   889 

   897 

   890         tr.close()

   898         tr.close()

   891         return newid, created

   899         return newid, created

   892     finally:

   900     finally:

   896     pass

   904     pass

   897 

   905 

   899     """rewrite <rev> on dest"""

   907     """rewrite <rev> on dest"""

   900     if orig.rev() == dest.rev():

   908     if orig.rev() == dest.rev():

   902                          hint=_("This shouldn't happen. If you still "

   910                          hint=_("This shouldn't happen. If you still "

   903                                 "need to move changesets, please do so "

   911                                 "need to move changesets, please do so "

   904                                 "manually with nothing to rebase - working "

   912                                 "manually with nothing to rebase - working "

   905                                 "directory parent is also destination"))

   913                                 "directory parent is also destination"))

   906 

   914 

   911     destbookmarks = repo.nodebookmarks(dest.node())

   922     destbookmarks = repo.nodebookmarks(dest.node())

   912     nodesrc = orig.node()

   923     nodesrc = orig.node()

   913     destphase = repo[nodesrc].phase()

   924     destphase = repo[nodesrc].phase()

   914     commitmsg = orig.description()

   925     commitmsg = orig.description()

   915 

   926 

   935             commitmsg = commitmsg.replace(sha1, newsha1[:len(sha1)])

   946             commitmsg = commitmsg.replace(sha1, newsha1[:len(sha1)])

   936         else:

   947         else:

   937             repo.ui.note(_('The stale commit message reference to %s could '

   948             repo.ui.note(_('The stale commit message reference to %s could '

   938                            'not be updated\n') % sha1)

   949                            'not be updated\n') % sha1)

   939 

   950 

   941     try:

   953     try:

   942         try:

   954         try:

   951             if r[-1]:  #some conflict

   956             if r[-1]:  #some conflict

   953                         'unresolved merge conflicts (see hg help resolve)')

   958                         'unresolved merge conflicts (see hg help resolve)')

   971             repo.dirstate.beginparentchange()

   961             repo.dirstate.beginparentchange()

   972             repo.setparents(repo['.'].node(), nullid)

   962             repo.setparents(repo['.'].node(), nullid)

   973             writedirstate(repo.dirstate, tr)

   963             writedirstate(repo.dirstate, tr)

   974             # fix up dirstate for copies and renames

   964             # fix up dirstate for copies and renames

   975             copies.duplicatecopies(repo, dest.rev(), orig.p1().rev())

   965             copies.duplicatecopies(repo, dest.rev(), orig.p1().rev())

   976             repo.dirstate.endparentchange()

   966             repo.dirstate.endparentchange()

   977             class LocalMergeFailure(MergeFailure, exc.__class__):

   967             class LocalMergeFailure(MergeFailure, exc.__class__):

   978                 pass

   968                 pass

   979             exc.__class__ = LocalMergeFailure

   969             exc.__class__ = LocalMergeFailure

   980             raise

   971             raise

   981         oldbookmarks = repo.nodebookmarks(nodesrc)

   972         oldbookmarks = repo.nodebookmarks(nodesrc)

   997     finally:

   974     finally:

   999     return nodenew

   976     return nodenew

  1000 

   977 

  1001 def _bookmarksupdater(repo, oldid, tr):

   978 def _bookmarksupdater(repo, oldid, tr):

  1002     """Return a callable update(newid) updating the current bookmark

   979     """Return a callable update(newid) updating the current bookmark

  1003     and bookmarks bound to oldid to newid.

   980     and bookmarks bound to oldid to newid.

  1014     return updatebookmarks

   991     return updatebookmarks

  1015 

   992 

  1016 ### bookmarks api compatibility layer ###

   993 ### bookmarks api compatibility layer ###

  1017 def bmdeactivate(repo):

   994 def bmdeactivate(repo):

  1018     try:

   995     try:

  1020     except AttributeError:

   997     except AttributeError:

  1022 def bmactivate(repo, book):

   999 def bmactivate(repo, book):

  1023     try:

  1000     try:

  1025     except AttributeError:

  1002     except AttributeError:

  1027 

  1004 

  1028 def bmactive(repo):

  1005 def bmactive(repo):

  1029     try:

  1006     try:

  1030         return repo._activebookmark

  1007         return repo._activebookmark

  1031     except AttributeError:

  1008     except AttributeError:

  1154                     parents = tuple(p.node() for p in ctx.parents())

  1131                     parents = tuple(p.node() for p in ctx.parents())

  1155                     before = len(store._all)

  1132                     before = len(store._all)

  1156                     store.create(tr, mark[0], mark[1], mark[2], marks[3],

  1133                     store.create(tr, mark[0], mark[1], mark[2], marks[3],

  1157                                  parents=parents)

  1134                                  parents=parents)

  1158                     if len(store._all) - before:

  1135                     if len(store._all) - before:

  1160             ui.progress(pgop, idx, total=pgtotal)

  1137             ui.progress(pgop, idx, total=pgtotal)

  1161         tr.close()

  1138         tr.close()

  1162         ui.progress(pgop, None)

  1139         ui.progress(pgop, None)

  1163     finally:

  1140     finally:

  1164         lockmod.release(tr, lock, wlock)

  1141         lockmod.release(tr, lock, wlock)

  1184             clustersmap[n] = c

  1161             clustersmap[n] = c

  1185 

  1162 

  1186     store = repo.obsstore

  1163     store = repo.obsstore

  1187     unfi = repo.unfiltered()

  1164     unfi = repo.unfiltered()

  1188     nm = unfi.changelog.nodemap

  1165     nm = unfi.changelog.nodemap

  1190     sucscount = [0, 0 , 0, 0]

  1167     sucscount = [0, 0 , 0, 0]

  1191     known = 0

  1168     known = 0

  1192     parentsdata = 0

  1169     parentsdata = 0

  1193     metakeys = {}

  1170     metakeys = {}

  1194     # node -> cluster mapping

  1171     # node -> cluster mapping

  1195     #   a cluster is a (set(nodes), set(markers)) tuple

  1172     #   a cluster is a (set(nodes), set(markers)) tuple

  1196     clustersmap = {}

  1173     clustersmap = {}

  1197     # same data using parent information

  1174     # same data using parent information

  1199     for mark in store:

  1176     for mark in store:

  1200         if mark[0] in nm:

  1177         if mark[0] in nm:

  1201             known += 1

  1178             known += 1

  1202         nbsucs = len(mark[1])

  1179         nbsucs = len(mark[1])

  1203         sucscount[min(nbsucs, 3)] += 1

  1180         sucscount[min(nbsucs, 3)] += 1

  1226     # same with parent data

  1203     # same with parent data

  1227     for c in pclustersmap.values():

  1204     for c in pclustersmap.values():

  1228         fc = (frozenset(c[0]), frozenset(c[1]))

  1205         fc = (frozenset(c[0]), frozenset(c[1]))

  1229         for n in fc[0]:

  1206         for n in fc[0]:

  1230             pclustersmap[n] = fc

  1207             pclustersmap[n] = fc

  1233     # successors data

  1210     # successors data

  1238     # meta data info

  1215     # meta data info

  1240     for key in sorted(metakeys):

  1217     for key in sorted(metakeys):

  1242 

  1219 

  1243     allclusters = list(set(clustersmap.values()))

  1220     allclusters = list(set(clustersmap.values()))

  1244     allclusters.sort(key=lambda x: len(x[1]))

  1221     allclusters.sort(key=lambda x: len(x[1]))

  1246 

  1223 

  1247     ui.write('        any known node:     %9i\n'

  1224     ui.write('        any known node:     %9i\n'

  1248              % len([c for c in allclusters

  1225              % len([c for c in allclusters

  1249                     if [n for n in c[0] if nm.get(n) is not None]]))

  1226                     if [n for n in c[0] if nm.get(n) is not None]]))

  1250     if allclusters:

  1227     if allclusters:

  1251         nbcluster = len(allclusters)

  1228         nbcluster = len(allclusters)

  1254         median = len(allclusters[nbcluster//2][1])

  1232         median = len(allclusters[nbcluster//2][1])

  1256         mean = sum(len(x[1]) for x in allclusters) // nbcluster

  1234         mean = sum(len(x[1]) for x in allclusters) // nbcluster

  1258     allpclusters = list(set(pclustersmap.values()))

  1236     allpclusters = list(set(pclustersmap.values()))

  1259     allpclusters.sort(key=lambda x: len(x[1]))

  1237     allpclusters.sort(key=lambda x: len(x[1]))

  1261     ui.write('        any known node:     %9i\n'

  1239     ui.write('        any known node:     %9i\n'

  1262              % len([c for c in allclusters

  1240              % len([c for c in allclusters

  1263                     if [n for n in c[0] if nm.get(n) is not None]]))

  1241                     if [n for n in c[0] if nm.get(n) is not None]]))

  1264     if allpclusters:

  1242     if allpclusters:

  1265         nbcluster = len(allpclusters)

  1243         nbcluster = len(allpclusters)

  1268         median = len(allpclusters[nbcluster//2][1])

  1248         median = len(allpclusters[nbcluster//2][1])

  1270         mean = sum(len(x[1]) for x in allpclusters) // nbcluster

  1250         mean = sum(len(x[1]) for x in allpclusters) // nbcluster

  1272 

  1252 

  1273 def _solveone(ui, repo, ctx, dryrun, confirm, progresscb, category):

  1253 def _solveone(ui, repo, ctx, dryrun, confirm, progresscb, category):

  1274     """Resolve the troubles affecting one revision"""

  1254     """Resolve the troubles affecting one revision"""

  1275     wlock = lock = tr = None

  1255     wlock = lock = tr = None

  1276     try:

  1256     try:

  1365         if othertroubles:

  1345         if othertroubles:

  1366             hint = hintmap['+'.join(othertroubles)]

  1346             hint = hintmap['+'.join(othertroubles)]

  1367         else:

  1347         else:

  1368             l = len(troubled[targetcat])

  1348             l = len(troubled[targetcat])

  1369             if l:

  1349             if l:

  1372             else:

  1352             else:

  1373                 othertroubles = []

  1353                 othertroubles = []

  1374                 for cat in unselectedcategories:

  1354                 for cat in unselectedcategories:

  1375                     if troubled[cat]:

  1355                     if troubled[cat]:

  1376                         othertroubles.append(cat)

  1356                         othertroubles.append(cat)

  1387     else:

  1367     else:

  1388         return 1

  1368         return 1

  1389 

  1369 

  1390 def _cleanup(ui, repo, startnode, showprogress):

  1370 def _cleanup(ui, repo, startnode, showprogress):

  1391     if showprogress:

  1371     if showprogress:

  1393     if repo['.'] != startnode:

  1373     if repo['.'] != startnode:

  1394         ui.status(_('working directory is now at %s\n') % repo['.'])

  1374         ui.status(_('working directory is now at %s\n') % repo['.'])

  1395 

  1375 

  1396 class MultipleSuccessorsError(RuntimeError):

  1376 class MultipleSuccessorsError(RuntimeError):

  1397     """Exception raised by _singlesuccessor when multiple successor sets exists

  1377     """Exception raised by _singlesuccessor when multiple successor sets exists

  1440     for r in revs:

  1420     for r in revs:

  1441         dependencies[r] = set()

  1421         dependencies[r] = set()

  1442         for p in repo[r].parents():

  1422         for p in repo[r].parents():

  1443             try:

  1423             try:

  1444                 succ = _singlesuccessor(repo, p)

  1424                 succ = _singlesuccessor(repo, p)

  1446                 dependencies[r] = exc.successorssets

  1426                 dependencies[r] = exc.successorssets

  1447                 continue

  1427                 continue

  1448             if succ in revs:

  1428             if succ in revs:

  1449                 dependencies[r].add(succ)

  1429                 dependencies[r].add(succ)

  1450                 rdependencies[succ].add(r)

  1430                 rdependencies[succ].add(r)

  1474     if allopt or revopt:

  1454     if allopt or revopt:

  1475         revs = repo.revs(targetcat+'()')

  1455         revs = repo.revs(targetcat+'()')

  1476         if revopt:

  1456         if revopt:

  1477             revs = scmutil.revrange(repo, revopt) & revs

  1457             revs = scmutil.revrange(repo, revopt) & revs

  1478         elif not anyopt and targetcat == 'unstable':

  1458         elif not anyopt and targetcat == 'unstable':

  1480         if targetcat == 'divergent':

  1461         if targetcat == 'divergent':

  1481             # Pick one divergent per group of divergents

  1462             # Pick one divergent per group of divergents

  1482             revs = _dedupedivergents(repo, revs)

  1463             revs = _dedupedivergents(repo, revs)

  1483     elif anyopt:

  1464     elif anyopt:

  1484         revs = repo.revs('first(%s())' % (targetcat))

  1465         revs = repo.revs('first(%s())' % (targetcat))

  1532 @command('^evolve|stabilize|solve',

  1513 @command('^evolve|stabilize|solve',

  1533     [('n', 'dry-run', False,

  1514     [('n', 'dry-run', False,

  1534         _('do not perform actions, just print what would be done')),

  1515         _('do not perform actions, just print what would be done')),

  1535      ('', 'confirm', False,

  1516      ('', 'confirm', False,

  1536         _('ask for confirmation before performing the action')),

  1517         _('ask for confirmation before performing the action')),

  1538     ('r', 'rev', [], _('solves troubles of these revisions')),

  1521     ('r', 'rev', [], _('solves troubles of these revisions')),

  1539     ('', 'bumped', False, _('solves only bumped changesets')),

  1522     ('', 'bumped', False, _('solves only bumped changesets')),

  1540     ('', 'divergent', False, _('solves only divergent changesets')),

  1523     ('', 'divergent', False, _('solves only divergent changesets')),

  1541     ('', 'unstable', False, _('solves only unstable changesets (default)')),

  1524     ('', 'unstable', False, _('solves only unstable changesets (default)')),

  1544     ('c', 'continue', False, _('continue an interrupted evolution')),

  1527     ('c', 'continue', False, _('continue an interrupted evolution')),

  1545     ] + mergetoolopts,

  1528     ] + mergetoolopts,

  1546     _('[OPTIONS]...'))

  1529     _('[OPTIONS]...'))

  1547 def evolve(ui, repo, **opts):

  1530 def evolve(ui, repo, **opts):

  1548     """solve troubled changesets in your repository

  1531     """solve troubled changesets in your repository

  1549 

  1532 

  1553 

  1536 

  1554     - update working copy to a successor

  1537     - update working copy to a successor

  1555     - rebase an unstable changeset

  1538     - rebase an unstable changeset

  1556     - extract the desired changes from a bumped changeset

  1539     - extract the desired changes from a bumped changeset

  1557     - fuse divergent changesets back together

  1540     - fuse divergent changesets back together

  1558 

  1541 

  1559     If you pass no arguments, evolve works in automatic mode: it will execute a

  1542     If you pass no arguments, evolve works in automatic mode: it will execute a

  1567 

  1551 

  1568     Any time evolve creates a changeset, it updates the working copy to the new

  1552     Any time evolve creates a changeset, it updates the working copy to the new

  1571 

  1555 

  1572     Automatic mode only handles common use cases. For example, it avoids taking

  1556     Automatic mode only handles common use cases. For example, it avoids taking

  1576 

  1561 

  1577     Eliminating all instability around your working copy may require multiple

  1562     Eliminating all instability around your working copy may require multiple

  1580     This is more powerful than successive invocations, since ``--all`` handles

  1566     This is more powerful than successive invocations, since ``--all`` handles

  1590 

  1576 

  1591     Alternately, ``--any`` makes evolve search for the next evolvable changeset

  1577     Alternately, ``--any`` makes evolve search for the next evolvable changeset

  1592     regardless of whether it is related to the working copy parent.

  1578     regardless of whether it is related to the working copy parent.

  1593 

  1579 

  1596     first(unstable())``. ``--rev`` and ``--all`` are mutually exclusive, as are

  1582     first(unstable())``. ``--rev`` and ``--all`` are mutually exclusive, as are

  1597     ``--rev`` and ``--any``.

  1583     ``--rev`` and ``--any``.

  1598 

  1584 

  1599     ``hg evolve --any --all`` is useful for cleaning up instability across all

  1585     ``hg evolve --any --all`` is useful for cleaning up instability across all

  1600     branches, letting evolve figure out the appropriate order and destination.

  1586     branches, letting evolve figure out the appropriate order and destination.

  1601 

  1587 

  1607 

  1594 

  1608     """

  1595     """

  1609 

  1596 

  1610     # Options

  1597     # Options

  1611     contopt = opts['continue']

  1598     contopt = opts['continue']

  1618     troublecategories = ['bumped', 'divergent', 'unstable']

  1605     troublecategories = ['bumped', 'divergent', 'unstable']

  1619     specifiedcategories = [t for t in troublecategories if opts[t]]

  1606     specifiedcategories = [t for t in troublecategories if opts[t]]

  1620     targetcat = 'unstable'

  1607     targetcat = 'unstable'

  1621     if 1 < len(specifiedcategories):

  1608     if 1 < len(specifiedcategories):

  1622         msg = _('cannot specify more than one trouble category to solve (yet)')

  1609         msg = _('cannot specify more than one trouble category to solve (yet)')

  1624     elif len(specifiedcategories) == 1:

  1611     elif len(specifiedcategories) == 1:

  1625         targetcat = specifiedcategories[0]

  1612         targetcat = specifiedcategories[0]

  1626     elif repo['.'].obsolete():

  1613     elif repo['.'].obsolete():

  1628         # no args and parent is obsolete, update to successors

  1616         # no args and parent is obsolete, update to successors

  1629         try:

  1617         try:

  1630             ctx = repo[_singlesuccessor(repo, repo['.'])]

  1618             ctx = repo[_singlesuccessor(repo, repo['.'])]

  1632             repo.ui.write_err('parent is obsolete with multiple successors:\n')

  1620             repo.ui.write_err('parent is obsolete with multiple successors:\n')

  1633             for ln in exc.successorssets:

  1621             for ln in exc.successorssets:

  1634                 for n in ln:

  1622                 for n in ln:

  1635                     displayer.show(repo[n])

  1623                     displayer.show(repo[n])

  1636             return 2

  1624             return 2

  1655     count = allopt and len(troubled) or 1

  1643     count = allopt and len(troubled) or 1

  1656     showprogress = allopt

  1644     showprogress = allopt

  1657 

  1645 

  1658     def progresscb():

  1646     def progresscb():

  1659         if revopt or allopt:

  1647         if revopt or allopt:

  1661 

  1649 

  1662     # Continuation handling

  1650     # Continuation handling

  1663     if contopt:

  1651     if contopt:

  1664         if anyopt:

  1652         if anyopt:

  1666         if allopt:

  1654         if allopt:

  1670     cmdutil.bailifchanged(repo)

  1669     cmdutil.bailifchanged(repo)

  1671 

  1670 

  1672 

  1671 

  1673     if revopt and allopt:

  1672     if revopt and allopt:

  1675     if revopt and anyopt:

  1674     if revopt and anyopt:

  1677 

  1676 

  1678     revs = _selectrevs(repo, allopt, revopt, anyopt, targetcat)

  1677     revs = _selectrevs(repo, allopt, revopt, anyopt, targetcat)

  1679 

  1678 

  1680     if not revs:

  1679     if not revs:

  1681         return _handlenotrouble(ui, repo, allopt, revopt, anyopt, targetcat)

  1680         return _handlenotrouble(ui, repo, allopt, revopt, anyopt, targetcat)

  1747     return sorted(result - target)

  1746     return sorted(result - target)

  1748 

  1747 

  1749 def _solveunstable(ui, repo, orig, dryrun=False, confirm=False,

  1748 def _solveunstable(ui, repo, orig, dryrun=False, confirm=False,

  1750                    progresscb=None):

  1749                    progresscb=None):

  1751     """Stabilize an unstable changeset"""

  1750     """Stabilize an unstable changeset"""

  1758         return False

  1763         return False

  1759     newer = obsolete.successorssets(repo, obs.node())

  1765     newer = obsolete.successorssets(repo, obs.node())

  1760     # search of a parent which is not killed

  1766     # search of a parent which is not killed

  1761     while not newer or newer == [()]:

  1767     while not newer or newer == [()]:

  1762         ui.debug("stabilize target %s is plain dead,"

  1768         ui.debug("stabilize target %s is plain dead,"

  1763                  " trying to stabilize on its parent\n" %

  1769                  " trying to stabilize on its parent\n" %

  1764                  obs)

  1770                  obs)

  1765         obs = obs.parents()[0]

  1771         obs = obs.parents()[0]

  1766         newer = obsolete.successorssets(repo, obs.node())

  1772         newer = obsolete.successorssets(repo, obs.node())

  1767     if len(newer) > 1:

  1773     if len(newer) > 1:

  1769         ui.write_err(msg)

  1776         ui.write_err(msg)

  1770         return 2

  1777         return 2

  1771     targets = newer[0]

  1778     targets = newer[0]

  1772     assert targets

  1779     assert targets

  1773     if len(targets) > 1:

  1780     if len(targets) > 1:

  1788         repo.ui.write(_('move:'))

  1795         repo.ui.write(_('move:'))

  1789         displayer.show(orig)

  1796         displayer.show(orig)

  1790         repo.ui.write(_('atop:'))

  1797         repo.ui.write(_('atop:'))

  1791         displayer.show(target)

  1798         displayer.show(target)

  1792     if confirm and ui.prompt('perform evolve? [Ny]', 'n') != 'y':

  1799     if confirm and ui.prompt('perform evolve? [Ny]', 'n') != 'y':

  1794     if progresscb: progresscb()

  1801     if progresscb: progresscb()

  1795     todo = 'hg rebase -r %s -d %s\n' % (orig, target)

  1802     todo = 'hg rebase -r %s -d %s\n' % (orig, target)

  1796     if dryrun:

  1803     if dryrun:

  1797         repo.ui.write(todo)

  1804         repo.ui.write(todo)

  1798     else:

  1805     else:

  1799         repo.ui.note(todo)

  1806         repo.ui.note(todo)

  1800         if progresscb: progresscb()

  1807         if progresscb: progresscb()

  1801         keepbranch = orig.p1().branch() != orig.branch()

  1808         keepbranch = orig.p1().branch() != orig.branch()

  1802         try:

  1809         try:

  1804         except MergeFailure:

  1811         except MergeFailure:

  1806             repo.ui.write_err(_('evolve failed!\n'))

  1813             repo.ui.write_err(_('evolve failed!\n'))

  1807             repo.ui.write_err(

  1814             repo.ui.write_err(

  1808                 _('fix conflict and run "hg evolve --continue"'

  1815                 _('fix conflict and run "hg evolve --continue"'

  1809                   ' or use "hg update -C" to abort\n'))

  1816                   ' or use "hg update -C" to abort\n'))

  1810             raise

  1817             raise

  1820         ui.write_err(msg)

  1827         ui.write_err(msg)

  1821         return 2

  1828         return 2

  1822     prec = repo.set('last(allprecursors(%d) and public())', bumped).next()

  1829     prec = repo.set('last(allprecursors(%d) and public())', bumped).next()

  1823     # For now we deny target merge

  1830     # For now we deny target merge

  1824     if len(prec.parents()) > 1:

  1831     if len(prec.parents()) > 1:

  1826         ui.write_err(msg)

  1834         ui.write_err(msg)

  1827         return 2

  1835         return 2

  1828 

  1836 

  1829     displayer = cmdutil.show_changeset(ui, repo, {'template': shorttemplate})

  1837     displayer = cmdutil.show_changeset(ui, repo, {'template': shorttemplate})

  1830     if not ui.quiet or confirm:

  1838     if not ui.quiet or confirm:

  1831         repo.ui.write(_('recreate:'))

  1839         repo.ui.write(_('recreate:'))

  1832         displayer.show(bumped)

  1840         displayer.show(bumped)

  1833         repo.ui.write(_('atop:'))

  1841         repo.ui.write(_('atop:'))

  1834         displayer.show(prec)

  1842         displayer.show(prec)

  1835     if confirm and ui.prompt('perform evolve? [Ny]', 'n') != 'y':

  1843     if confirm and ui.prompt('perform evolve? [Ny]', 'n') != 'y':

  1837     if dryrun:

  1845     if dryrun:

  1838         todo = 'hg rebase --rev %s --dest %s;\n' % (bumped, prec.p1())

  1846         todo = 'hg rebase --rev %s --dest %s;\n' % (bumped, prec.p1())

  1839         repo.ui.write(todo)

  1847         repo.ui.write(todo)

  1843         return 0

  1851         return 0

  1844     if progresscb: progresscb()

  1852     if progresscb: progresscb()

  1845     newid = tmpctx = None

  1853     newid = tmpctx = None

  1846     tmpctx = bumped

  1854     tmpctx = bumped

  1847     # Basic check for common parent. Far too complicated and fragile

  1855     # Basic check for common parent. Far too complicated and fragile

  1849     bmupdate = _bookmarksupdater(repo, bumped.node(), tr)

  1858     bmupdate = _bookmarksupdater(repo, bumped.node(), tr)

  1850     try:

  1859     try:

  1851         if not list(repo.set('parents(%d) and parents(%d)', bumped, prec)):

  1860         if not list(repo.set('parents(%d) and parents(%d)', bumped, prec)):

  1852             # Need to rebase the changeset at the right place

  1861             # Need to rebase the changeset at the right place

  1853             repo.ui.status(

  1862             repo.ui.status(

  1909         else:

  1918         else:

  1910             phases.retractboundary(repo, tr, bumped.phase(), [newid])

  1919             phases.retractboundary(repo, tr, bumped.phase(), [newid])

  1911             obsolete.createmarkers(repo, [(tmpctx, (repo[newid],))],

  1920             obsolete.createmarkers(repo, [(tmpctx, (repo[newid],))],

  1912                                    flag=obsolete.bumpedfix)

  1921                                    flag=obsolete.bumpedfix)

  1913         bmupdate(newid)

  1922         bmupdate(newid)

  1915         repo.ui.status(_('committed as %s\n') % node.short(newid))

  1923         repo.ui.status(_('committed as %s\n') % node.short(newid))

  1916     finally:

  1924     finally:

  1918     # reroute the working copy parent to the new changeset

  1926     # reroute the working copy parent to the new changeset

  1919     repo.dirstate.beginparentchange()

  1927     repo.dirstate.beginparentchange()

  1920     repo.dirstate.setparents(newid, node.nullid)

  1928     repo.dirstate.setparents(newid, node.nullid)

  1921     repo.dirstate.endparentchange()

  1929     repo.dirstate.endparentchange()

  1922 

  1930 

  1925     repo = repo.unfiltered()

  1933     repo = repo.unfiltered()

  1926     divergent = repo[divergent.rev()]

  1934     divergent = repo[divergent.rev()]

  1927     base, others = divergentdata(divergent)

  1935     base, others = divergentdata(divergent)

  1928     if len(others) > 1:

  1936     if len(others) > 1:

  1929         othersstr = "[%s]" % (','.join([str(i) for i in others]))

  1937         othersstr = "[%s]" % (','.join([str(i) for i in others]))

  1931                  "|[%s]\n"

  1940                  "|[%s]\n"

  1932                  "| This is not handled by automatic evolution yet\n"

  1941                  "| This is not handled by automatic evolution yet\n"

  1933                  "| You have to fallback to manual handling with commands "

  1942                  "| You have to fallback to manual handling with commands "

  1934                  "such as:\n"

  1943                  "such as:\n"

  1935                  "| - hg touch -D\n"

  1944                  "| - hg touch -D\n"

  1936                  "| - hg prune\n"

  1945                  "| - hg prune\n"

  1937                  "| \n"

  1946                  "| \n"

  1938                  "| You should contact your local evolution Guru for help.\n"

  1947                  "| You should contact your local evolution Guru for help.\n"

  1940         ui.write_err(msg)

  1949         ui.write_err(msg)

  1941         return 2

  1950         return 2

  1942     other = others[0]

  1951     other = others[0]

  1943     if len(other.parents()) > 1:

  1952     if len(other.parents()) > 1:

  1945         ui.write_err(msg)

  1955         ui.write_err(msg)

  1946         hint = _("You have to fallback to solving this by hand...\n"

  1956         hint = _("You have to fallback to solving this by hand...\n"

  1947                  "| This probably means redoing the merge and using \n"

  1957                  "| This probably means redoing the merge and using \n"

  1948                  "| `hg prune` to kill older version.\n")

  1958                  "| `hg prune` to kill older version.\n")

  1949         ui.write_err(hint)

  1959         ui.write_err(hint)

  1950         return 2

  1960         return 2

  1951     if other.p1() not in divergent.parents():

  1961     if other.p1() not in divergent.parents():

  1953         hint = _("| %(d)s, %(o)s are not based on the same changeset.\n"

  1964         hint = _("| %(d)s, %(o)s are not based on the same changeset.\n"

  1954                  "| With the current state of its implementation, \n"

  1965                  "| With the current state of its implementation, \n"

  1955                  "| evolve does not work in that case.\n"

  1966                  "| evolve does not work in that case.\n"

  1956                  "| rebase one of them next to the other and run \n"

  1967                  "| rebase one of them next to the other and run \n"

  1957                  "| this command again.\n"

  1968                  "| this command again.\n"

  1958                  "| - either: hg rebase --dest 'p1(%(d)s)' -r %(o)s\n"

  1969                  "| - either: hg rebase --dest 'p1(%(d)s)' -r %(o)s\n"

  1959                  "| - or:     hg rebase --dest 'p1(%(o)s)' -r %(d)s\n"

  1970                  "| - or:     hg rebase --dest 'p1(%(o)s)' -r %(d)s\n"

  1961         ui.write_err(msg)

  1972         ui.write_err(msg)

  1962         ui.write_err(hint)

  1973         ui.write_err(hint)

  1963         return 2

  1974         return 2

  1964 

  1975 

  1965     displayer = cmdutil.show_changeset(ui, repo, {'template': shorttemplate})

  1976     displayer = cmdutil.show_changeset(ui, repo, {'template': shorttemplate})

  1969         ui.write(_('with: '))

  1980         ui.write(_('with: '))

  1970         displayer.show(other)

  1981         displayer.show(other)

  1971         ui.write(_('base: '))

  1982         ui.write(_('base: '))

  1972         displayer.show(base)

  1983         displayer.show(base)

  1973     if confirm and ui.prompt(_('perform evolve? [Ny]'), 'n') != 'y':

  1984     if confirm and ui.prompt(_('perform evolve? [Ny]'), 'n') != 'y':

  1975     if dryrun:

  1986     if dryrun:

  1984         return

  1995         return

  1985     if divergent not in repo[None].parents():

  1996     if divergent not in repo[None].parents():

  1986         repo.ui.status(_('updating to "local" conflict\n'))

  1997         repo.ui.status(_('updating to "local" conflict\n'))

  1987         hg.update(repo, divergent.rev())

  1998         hg.update(repo, divergent.rev())

  1988     repo.ui.note(_('merging divergent changeset\n'))

  1999     repo.ui.note(_('merging divergent changeset\n'))

  1989     if progresscb: progresscb()

  2000     if progresscb: progresscb()

  1997     hg._showstats(repo, stats)

  2018     hg._showstats(repo, stats)

  1998     if stats[3]:

  2019     if stats[3]:

  1999         repo.ui.status(_("use 'hg resolve' to retry unresolved file merges "

  2020         repo.ui.status(_("use 'hg resolve' to retry unresolved file merges "

  2000                          "or 'hg update -C .' to abandon\n"))

  2021                          "or 'hg update -C .' to abandon\n"))

  2001     if stats[3] > 0:

  2022     if stats[3] > 0:

  2003             '(this is not automated yet)',

  2024             '(this is not automated yet)',

  2004             hint="""/!\ You can try:

  2025             hint="""/!\ You can try:

  2005 /!\ * manual merge + resolve => new cset X

  2026 /!\ * manual merge + resolve => new cset X

  2006 /!\ * hg up to the parent of the amended changeset (which are named W and Z)

  2027 /!\ * hg up to the parent of the amended changeset (which are named W and Z)

  2007 /!\ * hg revert --all -r X

  2028 /!\ * hg revert --all -r X

  2008 /!\ * hg ci -m "same message as the amended changeset" => new cset Y

  2029 /!\ * hg ci -m "same message as the amended changeset" => new cset Y

  2009 /!\ * hg kill -n Y W Z

  2030 /!\ * hg kill -n Y W Z

  2010 """)

  2031 """)

  2011     if progresscb: progresscb()

  2032     if progresscb: progresscb()

  2013     try:

  2036     try:

  2014         repo.dirstate.beginparentchange()

  2038         repo.dirstate.beginparentchange()

  2015         repo.dirstate.setparents(divergent.node(), node.nullid)

  2039         repo.dirstate.setparents(divergent.node(), node.nullid)

  2016         repo.dirstate.endparentchange()

  2040         repo.dirstate.endparentchange()

  2017         oldlen = len(repo)

  2041         oldlen = len(repo)

  2018         amend(ui, repo, message='', logfile='')

  2042         amend(ui, repo, message='', logfile='')

  2021             # no changes

  2045             # no changes

  2022         else:

  2046         else:

  2023             new = repo['.']

  2047             new = repo['.']

  2024         obsolete.createmarkers(repo, [(other, (new,))])

  2048         obsolete.createmarkers(repo, [(other, (new,))])

  2025         phases.retractboundary(repo, tr, other.phase(), [new.node()])

  2049         phases.retractboundary(repo, tr, other.phase(), [new.node()])

  2027     finally:

  2050     finally:

  2029 

  2052 

  2030 def divergentdata(ctx):

  2053 def divergentdata(ctx):

  2031     """return base, other part of a conflict

  2054     """return base, other part of a conflict

  2032 

  2055 

  2033     This only return the first one.

  2056     This only return the first one.

  2039         newer = obsolete.successorssets(ctx._repo, base.node())

  2062         newer = obsolete.successorssets(ctx._repo, base.node())

  2040         # drop filter and solution including the original ctx

  2063         # drop filter and solution including the original ctx

  2041         newer = [n for n in newer if n and ctx.node() not in n]

  2064         newer = [n for n in newer if n and ctx.node() not in n]

  2042         if newer:

  2065         if newer:

  2043             return base, tuple(ctx._repo[o] for o in newer[0])

  2066             return base, tuple(ctx._repo[o] for o in newer[0])

  2045                      hint='this case is not yet handled')

  2068                      hint='this case is not yet handled')

  2046 

  2069 

  2047 

  2070 

  2048 

  2071 

  2049 shorttemplate = '[{rev}] {desc|firstline}\n'

  2072 shorttemplate = '[{rev}] {desc|firstline}\n'

  2050 

  2073 

  2051 @command('^previous',

  2074 @command('^previous',

  2052          [('B', 'move-bookmark', False,

  2075          [('B', 'move-bookmark', False,

  2053              _('move active bookmark after update')),

  2076              _('move active bookmark after update')),

  2054           ('', 'merge', False, _('bring uncommitted change along')),

  2077           ('', 'merge', False, _('bring uncommitted change along')),

  2056          '[OPTION]...')

  2080          '[OPTION]...')

  2057 def cmdprevious(ui, repo, **opts):

  2081 def cmdprevious(ui, repo, **opts):

  2058     """update to parent revision

  2082     """update to parent revision

  2059 

  2083 

  2060     Displays the summary line of the destination for clarity."""

  2084     Displays the summary line of the destination for clarity."""

  2061     wkctx = repo[None]

  2085     wkctx = repo[None]

  2062     wparents = wkctx.parents()

  2086     wparents = wkctx.parents()

  2063     dryrunopt = opts['dry_run']

  2087     dryrunopt = opts['dry_run']

  2064     if len(wparents) != 1:

  2088     if len(wparents) != 1:

  2066     if not opts['merge']:

  2090     if not opts['merge']:

  2067         try:

  2091         try:

  2068             cmdutil.bailifchanged(repo)

  2092             cmdutil.bailifchanged(repo)

  2070             exc.hint = _('do you want --merge?')

  2094             exc.hint = _('do you want --merge?')

  2071             raise

  2095             raise

  2072 

  2096 

  2073     parents = wparents[0].parents()

  2097     parents = wparents[0].parents()

  2074     displayer = cmdutil.show_changeset(ui, repo, {'template': shorttemplate})

  2098     displayer = cmdutil.show_changeset(ui, repo, {'template': shorttemplate})

  2075     if len(parents) == 1:

  2099     if len(parents) == 1:

  2076         p = parents[0]

  2100         p = parents[0]

  2077         bm = bmactive(repo)

  2101         bm = bmactive(repo)

  2078         shouldmove = opts.get('move_bookmark') and bm is not None

  2102         shouldmove = opts.get('move_bookmark') and bm is not None

  2079         if dryrunopt:

  2103         if dryrunopt:

  2081             if shouldmove:

  2105             if shouldmove:

  2083         else:

  2107         else:

  2084             ret = hg.update(repo, p.rev())

  2108             ret = hg.update(repo, p.rev())

  2085             if not ret:

  2109             if not ret:

  2086                 wlock = repo.wlock()

  2111                 wlock = repo.wlock()

  2087                 try:

  2112                 try:

  2088                     if shouldmove:

  2115                     if shouldmove:

  2089                         repo._bookmarks[bm] = p.node()

  2116                         repo._bookmarks[bm] = p.node()

  2091                     else:

  2118                     else:

  2092                         bmdeactivate(repo)

  2119                         bmdeactivate(repo)

  2093                 finally:

  2121                 finally:

  2095         displayer.show(p)

  2123         displayer.show(p)

  2096         return 0

  2124         return 0

  2097     else:

  2125     else:

  2098         for p in parents:

  2126         for p in parents:

  2099             displayer.show(p)

  2127             displayer.show(p)

  2103 @command('^next',

  2131 @command('^next',

  2104          [('B', 'move-bookmark', False,

  2132          [('B', 'move-bookmark', False,

  2105              _('move active bookmark after update')),

  2133              _('move active bookmark after update')),

  2106           ('', 'merge', False, _('bring uncommitted change along')),

  2134           ('', 'merge', False, _('bring uncommitted change along')),

  2107           ('', 'evolve', False, _('evolve the next changeset if necessary')),

  2135           ('', 'evolve', False, _('evolve the next changeset if necessary')),

  2110 def cmdnext(ui, repo, **opts):

  2139 def cmdnext(ui, repo, **opts):

  2111     """update to next child revision

  2140     """update to next child revision

  2112 

  2141 

  2113     Use the ``--evolve`` flag to evolve unstable children on demand.

  2142     Use the ``--evolve`` flag to evolve unstable children on demand.

  2114 

  2143 

  2116     """

  2145     """

  2117     wkctx = repo[None]

  2146     wkctx = repo[None]

  2118     wparents = wkctx.parents()

  2147     wparents = wkctx.parents()

  2119     dryrunopt = opts['dry_run']

  2148     dryrunopt = opts['dry_run']

  2120     if len(wparents) != 1:

  2149     if len(wparents) != 1:

  2122     if not opts['merge']:

  2151     if not opts['merge']:

  2123         try:

  2152         try:

  2124             cmdutil.bailifchanged(repo)

  2153             cmdutil.bailifchanged(repo)

  2126             exc.hint = _('do you want --merge?')

  2155             exc.hint = _('do you want --merge?')

  2127             raise

  2156             raise

  2128 

  2157 

  2129     children = [ctx for ctx in wparents[0].children() if not ctx.obsolete()]

  2158     children = [ctx for ctx in wparents[0].children() if not ctx.obsolete()]

  2130     displayer = cmdutil.show_changeset(ui, repo, {'template': shorttemplate})

  2159     displayer = cmdutil.show_changeset(ui, repo, {'template': shorttemplate})

  2131     if len(children) == 1:

  2160     if len(children) == 1:

  2132         c = children[0]

  2161         c = children[0]

  2133         bm = bmactive(repo)

  2162         bm = bmactive(repo)

  2134         shouldmove = opts.get('move_bookmark') and bm is not None

  2163         shouldmove = opts.get('move_bookmark') and bm is not None

  2135         if dryrunopt:

  2164         if dryrunopt:

  2137             if shouldmove:

  2166             if shouldmove:

  2139         else:

  2168         else:

  2140             ret = hg.update(repo, c.rev())

  2169             ret = hg.update(repo, c.rev())

  2141             if not ret:

  2170             if not ret:

  2142                 wlock = repo.wlock()

  2172                 wlock = repo.wlock()

  2143                 try:

  2173                 try:

  2144                     if shouldmove:

  2176                     if shouldmove:

  2145                         repo._bookmarks[bm] = c.node()

  2177                         repo._bookmarks[bm] = c.node()

  2147                     else:

  2179                     else:

  2148                         bmdeactivate(repo)

  2180                         bmdeactivate(repo)

  2149                 finally:

  2182                 finally:

  2151         displayer.show(c)

  2184         displayer.show(c)

  2152         result = 0

  2185         result = 0

  2153     elif children:

  2186     elif children:

  2155         for c in children:

  2188         for c in children:

  2156             displayer.show(c)

  2189             displayer.show(c)

  2157         ui.warn(_('explicitly update to one of them\n'))

  2190         ui.warn(_('explicitly update to one of them\n'))

  2158         result = 1

  2191         result = 1

  2159     else:

  2192     else:

  2179                 ui.status(_('working directory now at %s\n') % repo['.'])

  2212                 ui.status(_('working directory now at %s\n') % repo['.'])

  2180             return result

  2213             return result

  2181         return 1

  2214         return 1

  2182     return result

  2215     return result

  2183 

  2216 

  2185     """filter revisions and bookmarks reachable from the given bookmark

  2218     """filter revisions and bookmarks reachable from the given bookmark

  2186     yoinked from mq.py

  2219     yoinked from mq.py

  2187     """

  2220     """

  2191 

  2225 

  2192     # If the requested bookmark is not the only one pointing to a

  2226     # If the requested bookmark is not the only one pointing to a

  2193     # a revision we have to only delete the bookmark and not strip

  2227     # a revision we have to only delete the bookmark and not strip

  2194     # anything. revsets cannot detect that case.

  2228     # anything. revsets cannot detect that case.

  2215     wlock = lock = tr = None

  2248     wlock = lock = tr = None

  2216     try:

  2249     try:

  2217         wlock = repo.wlock()

  2250         wlock = repo.wlock()

  2218         lock = repo.lock()

  2251         lock = repo.lock()

  2219         tr = repo.transaction('prune')

  2252         tr = repo.transaction('prune')

  2222         tr.close()

  2256         tr.close()

  2224     finally:

  2259     finally:

  2225         lockmod.release(tr, lock, wlock)

  2260         lockmod.release(tr, lock, wlock)

  2226 

  2261 

  2227 

  2262 

  2228 

  2263 

  2241     [('n', 'new', [], _("successor changeset (DEPRECATED)")),

  2276     [('n', 'new', [], _("successor changeset (DEPRECATED)")),

  2242      ('s', 'succ', [], _("successor changeset")),

  2277      ('s', 'succ', [], _("successor changeset")),

  2243      ('r', 'rev', [], _("revisions to prune")),

  2278      ('r', 'rev', [], _("revisions to prune")),

  2244      ('k', 'keep', None, _("does not modify working copy during prune")),

  2279      ('k', 'keep', None, _("does not modify working copy during prune")),

  2245      ('', 'biject', False, _("do a 1-1 map between rev and successor ranges")),

  2280      ('', 'biject', False, _("do a 1-1 map between rev and successor ranges")),

  2249                              " bookmark"))] + metadataopts,

  2286                              " bookmark"))] + metadataopts,

  2250     _('[OPTION] [-r] REV...'))

  2287     _('[OPTION] [-r] REV...'))

  2251     # -U  --noupdate option to prevent wc update and or bookmarks update ?

  2288     # -U  --noupdate option to prevent wc update and or bookmarks update ?

  2252 def cmdprune(ui, repo, *revs, **opts):

  2289 def cmdprune(ui, repo, *revs, **opts):

  2253     """hide changesets by marking them obsolete

  2290     """hide changesets by marking them obsolete

  2273     must acknowledge it by passing ``--split``. Similarly, when you prune multiple

  2310     must acknowledge it by passing ``--split``. Similarly, when you prune multiple

  2274     changesets with a single successor, you must pass the ``--fold`` option.

  2311     changesets with a single successor, you must pass the ``--fold`` option.

  2275     """

  2312     """

  2276     revs = scmutil.revrange(repo, list(revs) + opts.get('rev'))

  2313     revs = scmutil.revrange(repo, list(revs) + opts.get('rev'))

  2277     succs = opts['new'] + opts['succ']

  2314     succs = opts['new'] + opts['succ']

  2279     metadata = _getmetadata(**opts)

  2316     metadata = _getmetadata(**opts)

  2280     biject = opts.get('biject')

  2317     biject = opts.get('biject')

  2281     fold = opts.get('fold')

  2318     fold = opts.get('fold')

  2282     split = opts.get('split')

  2319     split = opts.get('split')

  2283 

  2320 

  2284     options = [o for o in ('biject', 'fold', 'split') if opts.get(o)]

  2321     options = [o for o in ('biject', 'fold', 'split') if opts.get(o)]

  2285     if 1 < len(options):

  2322     if 1 < len(options):

  2290         if not revs:

  2327         if not revs:

  2291             # no revisions to prune - delete bookmark immediately

  2328             # no revisions to prune - delete bookmark immediately

  2293 

  2330 

  2294     if not revs:

  2331     if not revs:

  2296 

  2333 

  2297     wlock = lock = tr = None

  2334     wlock = lock = tr = None

  2298     try:

  2335     try:

  2299         wlock = repo.wlock()

  2336         wlock = repo.wlock()

  2300         lock = repo.lock()

  2337         lock = repo.lock()

  2304         revs.sort()

  2341         revs.sort()

  2305         for p in revs:

  2342         for p in revs:

  2306             cp = repo[p]

  2343             cp = repo[p]

  2307             if not cp.mutable():

  2344             if not cp.mutable():

  2308                 # note: createmarkers() would have raised something anyway

  2345                 # note: createmarkers() would have raised something anyway

  2310                                  hint='see "hg help phases" for details')

  2347                                  hint='see "hg help phases" for details')

  2311             precs.append(cp)

  2348             precs.append(cp)

  2312         if not precs:

  2349         if not precs:

  2314 

  2351 

  2315         if not obsolete.isenabled(repo, obsolete.allowunstableopt):

  2352         if not obsolete.isenabled(repo, obsolete.allowunstableopt):

  2316             if repo.revs("(%ld::) - %ld", revs, revs):

  2353             if repo.revs("(%ld::) - %ld", revs, revs):

  2318 

  2355 

  2319         # defines successors changesets

  2356         # defines successors changesets

  2320         sucs = scmutil.revrange(repo, succs)

  2357         sucs = scmutil.revrange(repo, succs)

  2321         sucs.sort()

  2358         sucs.sort()

  2322         sucs = tuple(repo[n] for n in sucs)

  2359         sucs = tuple(repo[n] for n in sucs)

  2323         if not biject and len(sucs) > 1 and len(precs) > 1:

  2360         if not biject and len(sucs) > 1 and len(precs) > 1:

  2324             msg = "Can't use multiple successors for multiple precursors"

  2361             msg = "Can't use multiple successors for multiple precursors"

  2326         elif biject and len(sucs) != len(precs):

  2363         elif biject and len(sucs) != len(precs):

  2327             msg = "Can't use %d successors for %d precursors" \

  2364             msg = "Can't use %d successors for %d precursors" \

  2328                 % (len(sucs), len(precs))

  2365                 % (len(sucs), len(precs))

  2330         elif (len(precs) == 1 and len(sucs) > 1) and not split:

  2367         elif (len(precs) == 1 and len(sucs) > 1) and not split:

  2331             msg = "please add --split if you want to do a split"

  2368             msg = "please add --split if you want to do a split"

  2333         elif len(sucs) == 1 and len(precs) > 1 and not fold:

  2370         elif len(sucs) == 1 and len(precs) > 1 and not fold:

  2334             msg = "please add --fold if you want to do a fold"

  2371             msg = "please add --fold if you want to do a fold"

  2336         elif biject:

  2373         elif biject:

  2337             relations = [(p, (s,)) for p, s in zip(precs, sucs)]

  2374             relations = [(p, (s,)) for p, s in zip(precs, sucs)]

  2338         else:

  2375         else:

  2339             relations = [(p, sucs) for p in precs]

  2376             relations = [(p, sucs) for p in precs]

  2340 

  2377 

  2360                 # only reset the dirstate for files that would actually change

  2397                 # only reset the dirstate for files that would actually change

  2361                 # between the working context and uctx

  2398                 # between the working context and uctx

  2362                 descendantrevs = repo.revs("%d::." % newnode.rev())

  2399                 descendantrevs = repo.revs("%d::." % newnode.rev())

  2363                 changedfiles = []

  2400                 changedfiles = []

  2364                 for rev in descendantrevs:

  2401                 for rev in descendantrevs:

  2366                     changedfiles.extend(repo[rev].files())

  2404                     changedfiles.extend(repo[rev].files())

  2367 

  2405 

  2368                 # reset files that only changed in the dirstate too

  2406                 # reset files that only changed in the dirstate too

  2369                 dirstate = repo.dirstate

  2407                 dirstate = repo.dirstate

  2370                 dirchanges = [f for f in dirstate if dirstate[f] != 'n']

  2408                 dirchanges = [f for f in dirstate if dirstate[f] != 'n']

  2371                 changedfiles.extend(dirchanges)

  2409                 changedfiles.extend(dirchanges)

  2373                 writedirstate(dirstate, tr)

  2412                 writedirstate(dirstate, tr)

  2374             else:

  2413             else:

  2375                 bookactive = bmactive(repo)

  2414                 bookactive = bmactive(repo)

  2376                 # Active bookmark that we don't want to delete (with -B option)

  2415                 # Active bookmark that we don't want to delete (with -B option)

  2377                 # we deactivate and move it before the update and reactivate it

  2416                 # we deactivate and move it before the update and reactivate it

  2378                 # after

  2417                 # after

  2380                 if movebookmark:

  2419                 if movebookmark:

  2381                     bmdeactivate(repo)

  2420                     bmdeactivate(repo)

  2382                     repo._bookmarks[bookactive] = newnode.node()

  2421                     repo._bookmarks[bookactive] = newnode.node()

  2384                 commands.update(ui, repo, newnode.rev())

  2423                 commands.update(ui, repo, newnode.rev())

  2385                 ui.status(_('working directory now at %s\n') % newnode)

  2424                 ui.status(_('working directory now at %s\n') % newnode)

  2386                 if movebookmark:

  2425                 if movebookmark:

  2387                     bmactivate(repo, bookactive)

  2426                     bmactivate(repo, bookactive)

  2388 

  2427 

  2389         # update bookmarks

  2428         # update bookmarks

  2392 

  2431 

  2393         # create markers

  2432         # create markers

  2394         obsolete.createmarkers(repo, relations, metadata=metadata)

  2433         obsolete.createmarkers(repo, relations, metadata=metadata)

  2395 

  2434 

  2396         # informs that changeset have been pruned

  2435         # informs that changeset have been pruned

  2581     try:

  2620     try:

  2582         wlock = repo.wlock()

  2621         wlock = repo.wlock()

  2583         lock = repo.lock()

  2622         lock = repo.lock()

  2584         wctx = repo[None]

  2623         wctx = repo[None]

  2585         if len(wctx.parents()) <= 0:

  2624         if len(wctx.parents()) <= 0:

  2587         if len(wctx.parents()) > 1:

  2626         if len(wctx.parents()) > 1:

  2589         old = repo['.']

  2628         old = repo['.']

  2590         if old.phase() == phases.public:

  2629         if old.phase() == phases.public:

  2592         if len(old.parents()) > 1:

  2631         if len(old.parents()) > 1:

  2594         oldphase = old.phase()

  2633         oldphase = old.phase()

  2595 

  2634 

  2596 

  2635 

  2597         rev = None

  2636         rev = None

  2598         if opts.get('rev'):

  2637         if opts.get('rev'):

  2599             rev = scmutil.revsingle(repo, opts.get('rev'))

  2638             rev = scmutil.revsingle(repo, opts.get('rev'))

  2600             ctx = repo[None]

  2639             ctx = repo[None]

  2601             if ctx.p1() == rev or ctx.p2() == rev:

  2640             if ctx.p1() == rev or ctx.p2() == rev:

  2603 

  2642 

  2604         onahead = old.rev() in repo.changelog.headrevs()

  2643         onahead = old.rev() in repo.changelog.headrevs()

  2606         if disallowunstable and not onahead:

  2646         if disallowunstable and not onahead:

  2608 

  2648 

  2609         # Recommit the filtered changeset

  2649         # Recommit the filtered changeset

  2610         tr = repo.transaction('uncommit')

  2650         tr = repo.transaction('uncommit')

  2611         updatebookmarks = _bookmarksupdater(repo, old.node(), tr)

  2651         updatebookmarks = _bookmarksupdater(repo, old.node(), tr)

  2612         newid = None

  2652         newid = None

  2613         includeorexclude = opts.get('include') or opts.get('exclude')

  2653         includeorexclude = opts.get('include') or opts.get('exclude')

  2614         if (pats or includeorexclude or opts.get('all')):

  2654         if (pats or includeorexclude or opts.get('all')):

  2615             match = scmutil.match(old, pats, opts)

  2655             match = scmutil.match(old, pats, opts)

  2616             newid = _commitfiltered(repo, old, match, target=rev)

  2656             newid = _commitfiltered(repo, old, match, target=rev)

  2617         if newid is None:

  2657         if newid is None:

  2619                              hint=_("use --all to uncommit all files"))

  2659                              hint=_("use --all to uncommit all files"))

  2620         # Move local changes on filtered changeset

  2660         # Move local changes on filtered changeset

  2621         obsolete.createmarkers(repo, [(old, (repo[newid],))])

  2661         obsolete.createmarkers(repo, [(old, (repo[newid],))])

  2622         phases.retractboundary(repo, tr, oldphase, [newid])

  2662         phases.retractboundary(repo, tr, oldphase, [newid])

  2623         repo.dirstate.beginparentchange()

  2663         repo.dirstate.beginparentchange()

  2632     finally:

  2672     finally:

  2633         lockmod.release(tr, lock, wlock)

  2673         lockmod.release(tr, lock, wlock)

  2634 

  2674 

  2635 @eh.wrapcommand('commit')

  2675 @eh.wrapcommand('commit')

  2636 def commitwrapper(orig, ui, repo, *arg, **kwargs):

  2676 def commitwrapper(orig, ui, repo, *arg, **kwargs):

  2637     if kwargs.get('amend', False):

  2678     if kwargs.get('amend', False):

  2638         wlock = lock = None

  2679         wlock = lock = None

  2639     else:

  2680     else:

  2640         wlock = repo.wlock()

  2681         wlock = repo.wlock()

  2641         lock = repo.lock()

  2682         lock = repo.lock()

  2654             if markers:

  2695             if markers:

  2655                 obsolete.createmarkers(repo, markers)

  2696                 obsolete.createmarkers(repo, markers)

  2656             for book in oldbookmarks:

  2697             for book in oldbookmarks:

  2657                 repo._bookmarks[book] = new.node()

  2698                 repo._bookmarks[book] = new.node()

  2658             if oldbookmarks:

  2699             if oldbookmarks:

  2660         return result

  2707         return result

  2661     finally:

  2708     finally:

  2663 

  2710 

  2664 @command('^split',

  2711 @command('^split',

  2665     [('r', 'rev', [], _("revision to fold")),

  2712     [('r', 'rev', [], _("revision to fold")),

  2666     ] + commitopts + commitopts2,

  2713     ] + commitopts + commitopts2,

  2667     _('hg split [OPTION]... [-r] REV'))

  2714     _('hg split [OPTION]... [-r] REV'))

  2668 def cmdsplit(ui, repo, *revs, **opts):

  2715 def cmdsplit(ui, repo, *revs, **opts):

  2670 

  2717 

  2671     By default, split the current revision by prompting for all its hunks to be

  2718     By default, split the current revision by prompting for all its hunks to be

  2672     redistributed into new changesets.

  2719     redistributed into new changesets.

  2673 

  2720 

  2674     Use --rev to split a given changeset instead.

  2721     Use --rev to split a given changeset instead.

  2675     """

  2722     """

  2676     tr = wlock = lock = None

  2723     tr = wlock = lock = None

  2677     newcommits = []

  2724     newcommits = []

  2678 

  2725 

  2689     try:

  2733     try:

  2690         wlock = repo.wlock()

  2734         wlock = repo.wlock()

  2691         lock = repo.lock()

  2735         lock = repo.lock()

  2692         cmdutil.bailifchanged(repo)

  2736         cmdutil.bailifchanged(repo)

  2693         tr = repo.transaction('split')

  2737         tr = repo.transaction('split')

  2696         disallowunstable = not obsolete.isenabled(repo,

  2740         disallowunstable = not obsolete.isenabled(repo,

  2697                                                   obsolete.allowunstableopt)