mercurial-scm/hg-stable: hgext/rebase.py annotate

annotate hgext/rebase.py @ 29043:cf7de4aeb86b stable

destutil: add the ability to specify a search space for rebase destination In the 'hg pull --rebase', we don't want to pick a rebase destination unrelated to the pull, we lay down basic infrastructure to allow such restriction on stable (before 3.8 release) in this case. See issue 5214 for details. Actual usage and test will be in the next patch.

author	Pierre-Yves David <pierre-yves.david@ens-lyon.org>
date	Sat, 30 Apr 2016 18:41:08 +0200
parents	b212e01fead0
children	261c25372959

rev	line source
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	1 # rebase.py - rebasing feature for mercurial
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	2 #
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	3 # Copyright 2008 Stefano Tortarolo <stefano.tortarolo at gmail dot com>
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	4 #
8225 46293a0c7e9f updated license to be explicit about GPL version 2 Martin Geisler <mg@lazybytes.net> parents: 8222 diff changeset	5 # This software may be used and distributed according to the terms of the
10263 25e572394f5c Update license to GPLv2+ Matt Mackall <mpm@selenic.com> parents: 9815 diff changeset	6 # GNU General Public License version 2 or any later version.
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	7
8934 9dda4c73fc3b extensions: change descriptions for extensions providing a few commands Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 8706 diff changeset	8 '''command to move sets of revisions to a different ancestor
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	9
7999 b25110140573 rebase: word-wrap help texts at 70 characters Martin Geisler <mg@daimi.au.dk> parents: 7955 diff changeset	10 This extension lets you rebase changesets in an existing Mercurial
b25110140573 rebase: word-wrap help texts at 70 characters Martin Geisler <mg@daimi.au.dk> parents: 7955 diff changeset	11 repository.
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	12
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	13 For more information:
26421 4b0fc75f9403 urls: bulk-change primary website URLs Matt Mackall <mpm@selenic.com> parents: 26360 diff changeset	14 https://mercurial-scm.org/wiki/RebaseExtension
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	15 '''
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	16
14884 c0ccd70df52c rebase: reset bookmarks (issue2265 and issue2873) Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 14635 diff changeset	17 from mercurial import hg, util, repair, merge, cmdutil, commands, bookmarks
18933 42b620fc89e2 rebase: switch from util.Abort to util.InterventionRequired where appropriate (bc) Augie Fackler <raf@durin42.com> parents: 18764 diff changeset	18 from mercurial import extensions, patch, scmutil, phases, obsolete, error
28394 dcb4209bd30d revset: replace extpredicate by revsetpredicate of registrar FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28280 diff changeset	19 from mercurial import copies, destutil, repoview, registrar, revset
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	20 from mercurial.commands import templateopts
23517 4f18e80d9c30 rebase: show more useful status information while rebasing Mads Kiilerich <madski@unity3d.com> parents: 23491 diff changeset	21 from mercurial.node import nullrev, nullid, hex, short
8112 6ee71f78497c switch lock releasing in the extensions from gc to explicit Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de> parents: 8076 diff changeset	22 from mercurial.lock import release
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	23 from mercurial.i18n import _
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	24 import os, errno
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	25
26669 07db7e95c464 rebase: added comments Christian Delahousse <cdelahousse@fb.com> parents: 26587 diff changeset	26 # The following constants are used throughout the rebase module. The ordering of
07db7e95c464 rebase: added comments Christian Delahousse <cdelahousse@fb.com> parents: 26587 diff changeset	27 # their values must be maintained.
07db7e95c464 rebase: added comments Christian Delahousse <cdelahousse@fb.com> parents: 26587 diff changeset	28
07db7e95c464 rebase: added comments Christian Delahousse <cdelahousse@fb.com> parents: 26587 diff changeset	29 # Indicates that a revision needs to be rebased
23490 102f144f6e02 rebase: add a 'revtodo' constant Pierre-Yves David <pierre-yves.david@fb.com> parents: 23489 diff changeset	30 revtodo = -1
10352 66d954e76ffb rebase: add --detach option to detach intermediate revisions (issue1950) Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 10351 diff changeset	31 nullmerge = -2
18447 7159426c8d13 rebase: properly handle unrebased revision between rebased one Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18446 diff changeset	32 revignored = -3
27013 e97132eb841c rebase: remove an unused todo Laurent Charignon <lcharignon@fb.com> parents: 27012 diff changeset	33 # successor in rebase destination
26349 92409f8dff5d rebase: don't rebase obsolete commit whose successor is already rebased Laurent Charignon <lcharignon@fb.com> parents: 26301 diff changeset	34 revprecursor = -4
27013 e97132eb841c rebase: remove an unused todo Laurent Charignon <lcharignon@fb.com> parents: 27012 diff changeset	35 # plain prune (no successor)
27012 5eac7ab59b95 rebase: don't rebase obsolete commits with no successor Laurent Charignon <lcharignon@fb.com> parents: 27010 diff changeset	36 revpruned = -5
27014 4223fc58f952 rebase: refactoring to avoid repetition of expression Laurent Charignon <lcharignon@fb.com> parents: 27013 diff changeset	37 revskipped = (revignored, revprecursor, revpruned)
10352 66d954e76ffb rebase: add --detach option to detach intermediate revisions (issue1950) Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 10351 diff changeset	38
14306 db2a8eabe952 rebase: use cmdutil.command decorator Adrian Buehlmann <adrian@cadifra.com> parents: 14289 diff changeset	39 cmdtable = {}
db2a8eabe952 rebase: use cmdutil.command decorator Adrian Buehlmann <adrian@cadifra.com> parents: 14289 diff changeset	40 command = cmdutil.command(cmdtable)
25186 80c5b2666a96 extensions: document that `testedwith = 'internal'` is special Augie Fackler <augie@google.com> parents: 25102 diff changeset	41 # Note for extension authors: ONLY specify testedwith = 'internal' for
80c5b2666a96 extensions: document that `testedwith = 'internal'` is special Augie Fackler <augie@google.com> parents: 25102 diff changeset	42 # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
80c5b2666a96 extensions: document that `testedwith = 'internal'` is special Augie Fackler <augie@google.com> parents: 25102 diff changeset	43 # be specifying the version(s) of Mercurial they are tested with, or
80c5b2666a96 extensions: document that `testedwith = 'internal'` is special Augie Fackler <augie@google.com> parents: 25102 diff changeset	44 # leave the attribute unspecified.
16743 38caf405d010 hgext: mark all first-party extensions as such Augie Fackler <raf@durin42.com> parents: 16696 diff changeset	45 testedwith = 'internal'
14306 db2a8eabe952 rebase: use cmdutil.command decorator Adrian Buehlmann <adrian@cadifra.com> parents: 14289 diff changeset	46
26671 66dc39cd7d06 rebase: factor out nothing to rebase return code Ryan McElroy <rmcelroy@fb.com> parents: 26669 diff changeset	47 def _nothingtorebase():
66dc39cd7d06 rebase: factor out nothing to rebase return code Ryan McElroy <rmcelroy@fb.com> parents: 26669 diff changeset	48 return 1
66dc39cd7d06 rebase: factor out nothing to rebase return code Ryan McElroy <rmcelroy@fb.com> parents: 26669 diff changeset	49
27976 8f4d3eeb5198 rebase: backout changeset d755a9531fce Siddharth Agarwal <sid0@fb.com> parents: 27975 diff changeset	50 def _savegraft(ctx, extra):
8f4d3eeb5198 rebase: backout changeset d755a9531fce Siddharth Agarwal <sid0@fb.com> parents: 27975 diff changeset	51 s = ctx.extra().get('source', None)
8f4d3eeb5198 rebase: backout changeset d755a9531fce Siddharth Agarwal <sid0@fb.com> parents: 27975 diff changeset	52 if s is not None:
8f4d3eeb5198 rebase: backout changeset d755a9531fce Siddharth Agarwal <sid0@fb.com> parents: 27975 diff changeset	53 extra['source'] = s
8f4d3eeb5198 rebase: backout changeset d755a9531fce Siddharth Agarwal <sid0@fb.com> parents: 27975 diff changeset	54 s = ctx.extra().get('intermediate-source', None)
8f4d3eeb5198 rebase: backout changeset d755a9531fce Siddharth Agarwal <sid0@fb.com> parents: 27975 diff changeset	55 if s is not None:
8f4d3eeb5198 rebase: backout changeset d755a9531fce Siddharth Agarwal <sid0@fb.com> parents: 27975 diff changeset	56 extra['intermediate-source'] = s
8f4d3eeb5198 rebase: backout changeset d755a9531fce Siddharth Agarwal <sid0@fb.com> parents: 27975 diff changeset	57
8f4d3eeb5198 rebase: backout changeset d755a9531fce Siddharth Agarwal <sid0@fb.com> parents: 27975 diff changeset	58 def _savebranch(ctx, extra):
8f4d3eeb5198 rebase: backout changeset d755a9531fce Siddharth Agarwal <sid0@fb.com> parents: 27975 diff changeset	59 extra['branch'] = ctx.branch()
8f4d3eeb5198 rebase: backout changeset d755a9531fce Siddharth Agarwal <sid0@fb.com> parents: 27975 diff changeset	60
19860 6cd9b8428104 rebase: rework extrafn handling to support multiple extrafns Augie Fackler <raf@durin42.com> parents: 19852 diff changeset	61 def _makeextrafn(copiers):
6cd9b8428104 rebase: rework extrafn handling to support multiple extrafns Augie Fackler <raf@durin42.com> parents: 19852 diff changeset	62 """make an extrafn out of the given copy-functions.
6cd9b8428104 rebase: rework extrafn handling to support multiple extrafns Augie Fackler <raf@durin42.com> parents: 19852 diff changeset	63
6cd9b8428104 rebase: rework extrafn handling to support multiple extrafns Augie Fackler <raf@durin42.com> parents: 19852 diff changeset	64 A copy function takes a context and an extra dict, and mutates the
6cd9b8428104 rebase: rework extrafn handling to support multiple extrafns Augie Fackler <raf@durin42.com> parents: 19852 diff changeset	65 extra dict as needed based on the given context.
6cd9b8428104 rebase: rework extrafn handling to support multiple extrafns Augie Fackler <raf@durin42.com> parents: 19852 diff changeset	66 """
6cd9b8428104 rebase: rework extrafn handling to support multiple extrafns Augie Fackler <raf@durin42.com> parents: 19852 diff changeset	67 def extrafn(ctx, extra):
6cd9b8428104 rebase: rework extrafn handling to support multiple extrafns Augie Fackler <raf@durin42.com> parents: 19852 diff changeset	68 for c in copiers:
6cd9b8428104 rebase: rework extrafn handling to support multiple extrafns Augie Fackler <raf@durin42.com> parents: 19852 diff changeset	69 c(ctx, extra)
6cd9b8428104 rebase: rework extrafn handling to support multiple extrafns Augie Fackler <raf@durin42.com> parents: 19852 diff changeset	70 return extrafn
6cd9b8428104 rebase: rework extrafn handling to support multiple extrafns Augie Fackler <raf@durin42.com> parents: 19852 diff changeset	71
29043 cf7de4aeb86b destutil: add the ability to specify a search space for rebase destination Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 28686 diff changeset	72 def _destrebase(repo, sourceset, destspace=None):
28189 fac3a24be50e rebase: choose default destination the same way as 'hg merge' (BC) Pierre-Yves David <pierre-yves.david@fb.com> parents: 28188 diff changeset	73 """small wrapper around destmerge to pass the right extra args
fac3a24be50e rebase: choose default destination the same way as 'hg merge' (BC) Pierre-Yves David <pierre-yves.david@fb.com> parents: 28188 diff changeset	74
fac3a24be50e rebase: choose default destination the same way as 'hg merge' (BC) Pierre-Yves David <pierre-yves.david@fb.com> parents: 28188 diff changeset	75 Please wrap destutil.destmerge instead."""
fac3a24be50e rebase: choose default destination the same way as 'hg merge' (BC) Pierre-Yves David <pierre-yves.david@fb.com> parents: 28188 diff changeset	76 return destutil.destmerge(repo, action='rebase', sourceset=sourceset,
29043 cf7de4aeb86b destutil: add the ability to specify a search space for rebase destination Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 28686 diff changeset	77 onheadcheck=False, destspace=destspace)
26717 1755e1d9d1c3 rebase: extra default destination in its own function Pierre-Yves David <pierre-yves.david@fb.com> parents: 26677 diff changeset	78
28394 dcb4209bd30d revset: replace extpredicate by revsetpredicate of registrar FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28280 diff changeset	79 revsetpredicate = registrar.revsetpredicate()
27586 42910f9fffeb revset: use delayregistrar to register predicate in extension easily FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27577 diff changeset	80
42910f9fffeb revset: use delayregistrar to register predicate in extension easily FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27577 diff changeset	81 @revsetpredicate('_destrebase')
26719 8bed1eae99df rebase: rename and test '_destrebase' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26718 diff changeset	82 def _revsetdestrebase(repo, subset, x):
26301 3f8c5c284c86 rebase: move destination computation in a revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 26165 diff changeset	83 # ``_rebasedefaultdest()``
3f8c5c284c86 rebase: move destination computation in a revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 26165 diff changeset	84
3f8c5c284c86 rebase: move destination computation in a revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 26165 diff changeset	85 # default destination for rebase.
3f8c5c284c86 rebase: move destination computation in a revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 26165 diff changeset	86 # # XXX: Currently private because I expect the signature to change.
3f8c5c284c86 rebase: move destination computation in a revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 26165 diff changeset	87 # # XXX: - bailing out in case of ambiguity vs returning all data.
3f8c5c284c86 rebase: move destination computation in a revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 26165 diff changeset	88 # i18n: "_rebasedefaultdest" is a keyword
28189 fac3a24be50e rebase: choose default destination the same way as 'hg merge' (BC) Pierre-Yves David <pierre-yves.david@fb.com> parents: 28188 diff changeset	89 sourceset = None
fac3a24be50e rebase: choose default destination the same way as 'hg merge' (BC) Pierre-Yves David <pierre-yves.david@fb.com> parents: 28188 diff changeset	90 if x is not None:
fac3a24be50e rebase: choose default destination the same way as 'hg merge' (BC) Pierre-Yves David <pierre-yves.david@fb.com> parents: 28188 diff changeset	91 sourceset = revset.getset(repo, revset.fullreposet(repo), x)
fac3a24be50e rebase: choose default destination the same way as 'hg merge' (BC) Pierre-Yves David <pierre-yves.david@fb.com> parents: 28188 diff changeset	92 return subset & revset.baseset([_destrebase(repo, sourceset)])
26301 3f8c5c284c86 rebase: move destination computation in a revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 26165 diff changeset	93
14306 db2a8eabe952 rebase: use cmdutil.command decorator Adrian Buehlmann <adrian@cadifra.com> parents: 14289 diff changeset	94 @command('rebase',
db2a8eabe952 rebase: use cmdutil.command decorator Adrian Buehlmann <adrian@cadifra.com> parents: 14289 diff changeset	95 [('s', 'source', '',
22789 5f4934487382 rebase: attempt to clarify --base Matt Mackall <mpm@selenic.com> parents: 22405 diff changeset	96 _('rebase the specified changeset and descendants'), _('REV')),
14306 db2a8eabe952 rebase: use cmdutil.command decorator Adrian Buehlmann <adrian@cadifra.com> parents: 14289 diff changeset	97 ('b', 'base', '',
22789 5f4934487382 rebase: attempt to clarify --base Matt Mackall <mpm@selenic.com> parents: 22405 diff changeset	98 _('rebase everything from branching point of specified changeset'),
14306 db2a8eabe952 rebase: use cmdutil.command decorator Adrian Buehlmann <adrian@cadifra.com> parents: 14289 diff changeset	99 _('REV')),
15270 6cb6064f1d50 rebase: add --rev option to rebase Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15269 diff changeset	100 ('r', 'rev', [],
6cb6064f1d50 rebase: add --rev option to rebase Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15269 diff changeset	101 _('rebase these revisions'),
6cb6064f1d50 rebase: add --rev option to rebase Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15269 diff changeset	102 _('REV')),
14306 db2a8eabe952 rebase: use cmdutil.command decorator Adrian Buehlmann <adrian@cadifra.com> parents: 14289 diff changeset	103 ('d', 'dest', '',
db2a8eabe952 rebase: use cmdutil.command decorator Adrian Buehlmann <adrian@cadifra.com> parents: 14289 diff changeset	104 _('rebase onto the specified changeset'), _('REV')),
db2a8eabe952 rebase: use cmdutil.command decorator Adrian Buehlmann <adrian@cadifra.com> parents: 14289 diff changeset	105 ('', 'collapse', False, _('collapse the rebased changesets')),
db2a8eabe952 rebase: use cmdutil.command decorator Adrian Buehlmann <adrian@cadifra.com> parents: 14289 diff changeset	106 ('m', 'message', '',
db2a8eabe952 rebase: use cmdutil.command decorator Adrian Buehlmann <adrian@cadifra.com> parents: 14289 diff changeset	107 _('use text as collapse commit message'), _('TEXT')),
15219 9d58569a8b92 rebase: add --edit switch Matt Mackall <mpm@selenic.com> parents: 15214 diff changeset	108 ('e', 'edit', False, _('invoke editor on commit messages')),
14306 db2a8eabe952 rebase: use cmdutil.command decorator Adrian Buehlmann <adrian@cadifra.com> parents: 14289 diff changeset	109 ('l', 'logfile', '',
db2a8eabe952 rebase: use cmdutil.command decorator Adrian Buehlmann <adrian@cadifra.com> parents: 14289 diff changeset	110 _('read collapse commit message from file'), _('FILE')),
25025 72f7f98bc5e5 rebase: add short -k option for --keep Nat Mote <nmote@fb.com> parents: 24998 diff changeset	111 ('k', 'keep', False, _('keep original changesets')),
14306 db2a8eabe952 rebase: use cmdutil.command decorator Adrian Buehlmann <adrian@cadifra.com> parents: 14289 diff changeset	112 ('', 'keepbranches', False, _('keep original branch names')),
17005 50f434510da6 rebase: do not add second parent to rebased changeset (drop detach option) (BC) Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 16867 diff changeset	113 ('D', 'detach', False, _('(DEPRECATED)')),
22382 d5b04ee8ecf7 rebase: add a deprecated -i/--interactive flag David Soria Parra <davidsp@fb.com> parents: 22251 diff changeset	114 ('i', 'interactive', False, _('(DEPRECATED)')),
14306 db2a8eabe952 rebase: use cmdutil.command decorator Adrian Buehlmann <adrian@cadifra.com> parents: 14289 diff changeset	115 ('t', 'tool', '', _('specify merge tool')),
db2a8eabe952 rebase: use cmdutil.command decorator Adrian Buehlmann <adrian@cadifra.com> parents: 14289 diff changeset	116 ('c', 'continue', False, _('continue an interrupted rebase')),
db2a8eabe952 rebase: use cmdutil.command decorator Adrian Buehlmann <adrian@cadifra.com> parents: 14289 diff changeset	117 ('a', 'abort', False, _('abort an interrupted rebase'))] +
db2a8eabe952 rebase: use cmdutil.command decorator Adrian Buehlmann <adrian@cadifra.com> parents: 14289 diff changeset	118 templateopts,
17325 e4db509c08ec rebase: remove second broken synopsis line (issue3172) Patrick Mezard <patrick@mezard.eu> parents: 17059 diff changeset	119 _('[-s REV \| -b REV] [-d REV] [OPTION]'))
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	120 def rebase(ui, repo, **opts):
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	121 """move changeset (and descendants) to a different branch
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	122
7999 b25110140573 rebase: word-wrap help texts at 70 characters Martin Geisler <mg@daimi.au.dk> parents: 7955 diff changeset	123 Rebase uses repeated merging to graft changesets from one part of
10646 86dc21148bdb rebase: improve help text Greg Ward <greg-hg@gerg.ca> parents: 10436 diff changeset	124 history (the source) onto another (the destination). This can be
11188 b5c0f6a11430 rebase: stress that only local changesets should be rebased Martin Geisler <mg@lazybytes.net> parents: 10762 diff changeset	125 useful for linearizing local changes relative to a master
10646 86dc21148bdb rebase: improve help text Greg Ward <greg-hg@gerg.ca> parents: 10436 diff changeset	126 development tree.
86dc21148bdb rebase: improve help text Greg Ward <greg-hg@gerg.ca> parents: 10436 diff changeset	127
27454 3e3be524a712 rebase: simplify documentation about public commits timeless <timeless@mozdev.org> parents: 27344 diff changeset	128 Published commits cannot be rebased (see :hg:`help phases`).
3e3be524a712 rebase: simplify documentation about public commits timeless <timeless@mozdev.org> parents: 27344 diff changeset	129 To copy commits, see :hg:`help graft`.
18516 9fbeb61b8ad2 rebase: mention phases in the help Kevin Bullock <kbullock@ringworld.org> parents: 18514 diff changeset	130
28189 fac3a24be50e rebase: choose default destination the same way as 'hg merge' (BC) Pierre-Yves David <pierre-yves.david@fb.com> parents: 28188 diff changeset	131 If you don't specify a destination changeset (``-d/--dest``), rebase
fac3a24be50e rebase: choose default destination the same way as 'hg merge' (BC) Pierre-Yves David <pierre-yves.david@fb.com> parents: 28188 diff changeset	132 will use the same logic as :hg:`merge` to pick a destination. if
fac3a24be50e rebase: choose default destination the same way as 'hg merge' (BC) Pierre-Yves David <pierre-yves.david@fb.com> parents: 28188 diff changeset	133 the current branch contains exactly one other head, the other head
fac3a24be50e rebase: choose default destination the same way as 'hg merge' (BC) Pierre-Yves David <pierre-yves.david@fb.com> parents: 28188 diff changeset	134 is merged with by default. Otherwise, an explicit revision with
fac3a24be50e rebase: choose default destination the same way as 'hg merge' (BC) Pierre-Yves David <pierre-yves.david@fb.com> parents: 28188 diff changeset	135 which to merge with must be provided. (destination changeset is not
fac3a24be50e rebase: choose default destination the same way as 'hg merge' (BC) Pierre-Yves David <pierre-yves.david@fb.com> parents: 28188 diff changeset	136 modified by rebasing, but new changesets are added as its
fac3a24be50e rebase: choose default destination the same way as 'hg merge' (BC) Pierre-Yves David <pierre-yves.david@fb.com> parents: 28188 diff changeset	137 descendants.)
10646 86dc21148bdb rebase: improve help text Greg Ward <greg-hg@gerg.ca> parents: 10436 diff changeset	138
27956 f3eb98b8fe12 doc: prevent non-literal text block from being treated as literal one FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27932 diff changeset	139 Here are the ways to select changesets:
27455 a9a047878e14 rebase: simplify documentation about selecting commits to rebase timeless <timeless@mozdev.org> parents: 27454 diff changeset	140
a9a047878e14 rebase: simplify documentation about selecting commits to rebase timeless <timeless@mozdev.org> parents: 27454 diff changeset	141 1. Explicitly select them using ``--rev``.
10646 86dc21148bdb rebase: improve help text Greg Ward <greg-hg@gerg.ca> parents: 10436 diff changeset	142
27455 a9a047878e14 rebase: simplify documentation about selecting commits to rebase timeless <timeless@mozdev.org> parents: 27454 diff changeset	143 2. Use ``--source`` to select a root changeset and include all of its
27959 4322849a5357 doc: use correct indentation for enumeration FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27956 diff changeset	144 descendants.
27455 a9a047878e14 rebase: simplify documentation about selecting commits to rebase timeless <timeless@mozdev.org> parents: 27454 diff changeset	145
a9a047878e14 rebase: simplify documentation about selecting commits to rebase timeless <timeless@mozdev.org> parents: 27454 diff changeset	146 3. Use ``--base`` to select a changeset; rebase will find ancestors
27959 4322849a5357 doc: use correct indentation for enumeration FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27956 diff changeset	147 and their descendants which are not also ancestors of the destination.
18518 0324a1d88a53 rebase: mention --rev in the help Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18516 diff changeset	148
27932 6bc2299cc12f rebase: restore help for rebase w/o args (issue5059) timeless <timeless@mozdev.org> parents: 27866 diff changeset	149 4. If you do not specify any of ``--rev``, ``source``, or ``--base``,
27959 4322849a5357 doc: use correct indentation for enumeration FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27956 diff changeset	150 rebase will use ``--base .`` as above.
27932 6bc2299cc12f rebase: restore help for rebase w/o args (issue5059) timeless <timeless@mozdev.org> parents: 27866 diff changeset	151
27456 2337958596e3 rebase: simplify documentation about --keep timeless <timeless@mozdev.org> parents: 27455 diff changeset	152 Rebase will destroy original changesets unless you use ``--keep``.
2337958596e3 rebase: simplify documentation about --keep timeless <timeless@mozdev.org> parents: 27455 diff changeset	153 It will also move your bookmarks (even if you do).
2337958596e3 rebase: simplify documentation about --keep timeless <timeless@mozdev.org> parents: 27455 diff changeset	154
2337958596e3 rebase: simplify documentation about --keep timeless <timeless@mozdev.org> parents: 27455 diff changeset	155 Some changesets may be dropped if they do not contribute changes
2337958596e3 rebase: simplify documentation about --keep timeless <timeless@mozdev.org> parents: 27455 diff changeset	156 (e.g. merges from the destination branch).
10646 86dc21148bdb rebase: improve help text Greg Ward <greg-hg@gerg.ca> parents: 10436 diff changeset	157
27457 97cc045f1cfe rebase: simplify documentation about heads timeless <timeless@mozdev.org> parents: 27456 diff changeset	158 Unlike ``merge``, rebase will do nothing if you are at the branch tip of
97cc045f1cfe rebase: simplify documentation about heads timeless <timeless@mozdev.org> parents: 27456 diff changeset	159 a named branch with two heads. You will need to explicitly specify source
97cc045f1cfe rebase: simplify documentation about heads timeless <timeless@mozdev.org> parents: 27456 diff changeset	160 and/or destination.
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	161
28001 ade12bf2bf0e rebase: mention help merge-tools in help timeless <timeless@mozdev.org> parents: 27977 diff changeset	162 If you need to use a tool to automate merge/conflict decisions, you
ade12bf2bf0e rebase: mention help merge-tools in help timeless <timeless@mozdev.org> parents: 27977 diff changeset	163 can specify one with ``--tool``, see :hg:`help merge-tools`.
28002 e862b1fd33a8 rebase: document that tool does not apply to deleted files timeless <timeless@mozdev.org> parents: 28001 diff changeset	164 As a caveat: the tool will not be used to mediate when a file was
e862b1fd33a8 rebase: document that tool does not apply to deleted files timeless <timeless@mozdev.org> parents: 28001 diff changeset	165 deleted, there is no hook presently available for this.
28001 ade12bf2bf0e rebase: mention help merge-tools in help timeless <timeless@mozdev.org> parents: 27977 diff changeset	166
27458 d39e743e3578 rebase: mention conflict in documentation instead of merge timeless <timeless@mozdev.org> parents: 27457 diff changeset	167 If a rebase is interrupted to manually resolve a conflict, it can be
8076 5ec526c1a32f help texts: write command line switches as -a/--abc Martin Geisler <mg@lazybytes.net> parents: 8031 diff changeset	168 continued with --continue/-c or aborted with --abort/-a.
11205 d26f662bfbf5 rebase: add error codes Matt Mackall <mpm@selenic.com> parents: 11204 diff changeset	169
22790 c64f9e0beead rebase: add help examples Matt Mackall <mpm@selenic.com> parents: 22789 diff changeset	170 .. container:: verbose
c64f9e0beead rebase: add help examples Matt Mackall <mpm@selenic.com> parents: 22789 diff changeset	171
c64f9e0beead rebase: add help examples Matt Mackall <mpm@selenic.com> parents: 22789 diff changeset	172 Examples:
c64f9e0beead rebase: add help examples Matt Mackall <mpm@selenic.com> parents: 22789 diff changeset	173
c64f9e0beead rebase: add help examples Matt Mackall <mpm@selenic.com> parents: 22789 diff changeset	174 - move "local changes" (current commit back to branching point)
c64f9e0beead rebase: add help examples Matt Mackall <mpm@selenic.com> parents: 22789 diff changeset	175 to the current branch tip after a pull::
c64f9e0beead rebase: add help examples Matt Mackall <mpm@selenic.com> parents: 22789 diff changeset	176
c64f9e0beead rebase: add help examples Matt Mackall <mpm@selenic.com> parents: 22789 diff changeset	177 hg rebase
c64f9e0beead rebase: add help examples Matt Mackall <mpm@selenic.com> parents: 22789 diff changeset	178
c64f9e0beead rebase: add help examples Matt Mackall <mpm@selenic.com> parents: 22789 diff changeset	179 - move a single changeset to the stable branch::
c64f9e0beead rebase: add help examples Matt Mackall <mpm@selenic.com> parents: 22789 diff changeset	180
c64f9e0beead rebase: add help examples Matt Mackall <mpm@selenic.com> parents: 22789 diff changeset	181 hg rebase -r 5f493448 -d stable
c64f9e0beead rebase: add help examples Matt Mackall <mpm@selenic.com> parents: 22789 diff changeset	182
c64f9e0beead rebase: add help examples Matt Mackall <mpm@selenic.com> parents: 22789 diff changeset	183 - splice a commit and all its descendants onto another part of history::
c64f9e0beead rebase: add help examples Matt Mackall <mpm@selenic.com> parents: 22789 diff changeset	184
c64f9e0beead rebase: add help examples Matt Mackall <mpm@selenic.com> parents: 22789 diff changeset	185 hg rebase --source c0c3 --dest 4cf9
c64f9e0beead rebase: add help examples Matt Mackall <mpm@selenic.com> parents: 22789 diff changeset	186
c64f9e0beead rebase: add help examples Matt Mackall <mpm@selenic.com> parents: 22789 diff changeset	187 - rebase everything on a branch marked by a bookmark onto the
c64f9e0beead rebase: add help examples Matt Mackall <mpm@selenic.com> parents: 22789 diff changeset	188 default branch::
c64f9e0beead rebase: add help examples Matt Mackall <mpm@selenic.com> parents: 22789 diff changeset	189
c64f9e0beead rebase: add help examples Matt Mackall <mpm@selenic.com> parents: 22789 diff changeset	190 hg rebase --base myfeature --dest default
c64f9e0beead rebase: add help examples Matt Mackall <mpm@selenic.com> parents: 22789 diff changeset	191
c64f9e0beead rebase: add help examples Matt Mackall <mpm@selenic.com> parents: 22789 diff changeset	192 - collapse a sequence of changes into a single commit::
c64f9e0beead rebase: add help examples Matt Mackall <mpm@selenic.com> parents: 22789 diff changeset	193
c64f9e0beead rebase: add help examples Matt Mackall <mpm@selenic.com> parents: 22789 diff changeset	194 hg rebase --collapse -r 1520:1525 -d .
c64f9e0beead rebase: add help examples Matt Mackall <mpm@selenic.com> parents: 22789 diff changeset	195
c64f9e0beead rebase: add help examples Matt Mackall <mpm@selenic.com> parents: 22789 diff changeset	196 - move a named branch while preserving its name::
c64f9e0beead rebase: add help examples Matt Mackall <mpm@selenic.com> parents: 22789 diff changeset	197
c64f9e0beead rebase: add help examples Matt Mackall <mpm@selenic.com> parents: 22789 diff changeset	198 hg rebase -r "branch(featureX)" -d 1.3 --keepbranches
c64f9e0beead rebase: add help examples Matt Mackall <mpm@selenic.com> parents: 22789 diff changeset	199
19971 2a9bb64faa0b rebase: add description about exit code when there are unresolved conflicts FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 19969 diff changeset	200 Returns 0 on success, 1 if nothing to rebase or there are
2a9bb64faa0b rebase: add description about exit code when there are unresolved conflicts FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 19969 diff changeset	201 unresolved conflicts.
22790 c64f9e0beead rebase: add help examples Matt Mackall <mpm@selenic.com> parents: 22789 diff changeset	202
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	203 """
7280 810ca383da9c remove unused variables Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 7216 diff changeset	204 originalwd = target = None
18755 72412afe4c28 rebase: restore active bookmark after rebase --continue Durham Goode <durham@fb.com> parents: 18549 diff changeset	205 activebookmark = None
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	206 external = nullrev
26781 1aee2ab0f902 spelling: trivial spell checking Mads Kiilerich <madski@unity3d.com> parents: 26748 diff changeset	207 # Mapping between the old revision id and either what is the new rebased
1aee2ab0f902 spelling: trivial spell checking Mads Kiilerich <madski@unity3d.com> parents: 26748 diff changeset	208 # revision or what needs to be done with the old revision. The state dict
26669 07db7e95c464 rebase: added comments Christian Delahousse <cdelahousse@fb.com> parents: 26587 diff changeset	209 # will be what contains most of the rebase progress state.
8454 6d4bf1c1a003 rebase: use set instead of dict Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 8270 diff changeset	210 state = {}
6d4bf1c1a003 rebase: use set instead of dict Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 8270 diff changeset	211 skipped = set()
10351 38fe86fb16e3 rebase: refactoring Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 10263 diff changeset	212 targetancestors = set()
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	213
15219 9d58569a8b92 rebase: add --edit switch Matt Mackall <mpm@selenic.com> parents: 15214 diff changeset	214
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	215 lock = wlock = None
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	216 try:
15874 2305baff673f rebase: take locks in the right order Mads Kiilerich <mads@kiilerich.com> parents: 15801 diff changeset	217 wlock = repo.wlock()
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	218 lock = repo.lock()
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	219
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	220 # Validate input and define rebasing points
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	221 destf = opts.get('dest', None)
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	222 srcf = opts.get('source', None)
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	223 basef = opts.get('base', None)
15270 6cb6064f1d50 rebase: add --rev option to rebase Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15269 diff changeset	224 revf = opts.get('rev', [])
29043 cf7de4aeb86b destutil: add the ability to specify a search space for rebase destination Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 28686 diff changeset	225 # search default destination in this space
cf7de4aeb86b destutil: add the ability to specify a search space for rebase destination Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 28686 diff changeset	226 # used in the 'hg pull --rebase' case, see issue 5214.
cf7de4aeb86b destutil: add the ability to specify a search space for rebase destination Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 28686 diff changeset	227 destspace = opts.get('_destspace')
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	228 contf = opts.get('continue')
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	229 abortf = opts.get('abort')
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	230 collapsef = opts.get('collapse', False)
14635 217b7d83afc3 cmdutil, logmessage: use ui.fin when reading from '-' Idan Kamara <idankk86@gmail.com> parents: 14599 diff changeset	231 collapsemsg = cmdutil.logmessage(ui, opts)
26869 412e8c5e38b4 rebase: pass date parameter to concludenode Stanislau Hlebik <stash@fb.com> parents: 26868 diff changeset	232 date = opts.get('date', None)
19860 6cd9b8428104 rebase: rework extrafn handling to support multiple extrafns Augie Fackler <raf@durin42.com> parents: 19852 diff changeset	233 e = opts.get('extrafn') # internal, used by e.g. hgsubversion
27976 8f4d3eeb5198 rebase: backout changeset d755a9531fce Siddharth Agarwal <sid0@fb.com> parents: 27975 diff changeset	234 extrafns = [_savegraft]
19860 6cd9b8428104 rebase: rework extrafn handling to support multiple extrafns Augie Fackler <raf@durin42.com> parents: 19852 diff changeset	235 if e:
6cd9b8428104 rebase: rework extrafn handling to support multiple extrafns Augie Fackler <raf@durin42.com> parents: 19852 diff changeset	236 extrafns = [e]
7952 b214066b7e1d rebase: store/restore arguments correctly Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 7951 diff changeset	237 keepf = opts.get('keep', False)
b214066b7e1d rebase: store/restore arguments correctly Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 7951 diff changeset	238 keepbranchesf = opts.get('keepbranches', False)
10677 f2558a8228be rebase: add option to not commit after a collapsing Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 10676 diff changeset	239 # keepopen is not meant for use on the command line, but by
f2558a8228be rebase: add option to not commit after a collapsing Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 10676 diff changeset	240 # other extensions
f2558a8228be rebase: add option to not commit after a collapsing Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 10676 diff changeset	241 keepopen = opts.get('keepopen', False)
7468 3e5db4228f8f rebase: add support to keep branch names Augie Fackler <durin42@gmail.com> parents: 7298 diff changeset	242
22382 d5b04ee8ecf7 rebase: add a deprecated -i/--interactive flag David Soria Parra <davidsp@fb.com> parents: 22251 diff changeset	243 if opts.get('interactive'):
26496 b885ab9ca182 rebase: enable histedit for useful help with it timeless@mozdev.org parents: 26495 diff changeset	244 try:
b885ab9ca182 rebase: enable histedit for useful help with it timeless@mozdev.org parents: 26495 diff changeset	245 if extensions.find('histedit'):
b885ab9ca182 rebase: enable histedit for useful help with it timeless@mozdev.org parents: 26495 diff changeset	246 enablehistedit = ''
b885ab9ca182 rebase: enable histedit for useful help with it timeless@mozdev.org parents: 26495 diff changeset	247 except KeyError:
b885ab9ca182 rebase: enable histedit for useful help with it timeless@mozdev.org parents: 26495 diff changeset	248 enablehistedit = " --config extensions.histedit="
b885ab9ca182 rebase: enable histedit for useful help with it timeless@mozdev.org parents: 26495 diff changeset	249 help = "hg%s help -e histedit" % enablehistedit
22382 d5b04ee8ecf7 rebase: add a deprecated -i/--interactive flag David Soria Parra <davidsp@fb.com> parents: 22251 diff changeset	250 msg = _("interactive history editing is supported by the "
26494 832f40d2af53 rebase: factor out histedit help command timeless@mozdev.org parents: 26421 diff changeset	251 "'histedit' extension (see \"%s\")") % help
26587 56b2bcea2529 error: get Abort from 'error' instead of 'util' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26496 diff changeset	252 raise error.Abort(msg)
22382 d5b04ee8ecf7 rebase: add a deprecated -i/--interactive flag David Soria Parra <davidsp@fb.com> parents: 22251 diff changeset	253
13661 ee349e228835 rebase: add -m/--message to rebase --collapse (issue2389) Radomir Dopieralski <sheep@stxnext.pl> parents: 13609 diff changeset	254 if collapsemsg and not collapsef:
26587 56b2bcea2529 error: get Abort from 'error' instead of 'util' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26496 diff changeset	255 raise error.Abort(
13661 ee349e228835 rebase: add -m/--message to rebase --collapse (issue2389) Radomir Dopieralski <sheep@stxnext.pl> parents: 13609 diff changeset	256 _('message can only be specified with collapse'))
ee349e228835 rebase: add -m/--message to rebase --collapse (issue2389) Radomir Dopieralski <sheep@stxnext.pl> parents: 13609 diff changeset	257
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	258 if contf or abortf:
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	259 if contf and abortf:
26587 56b2bcea2529 error: get Abort from 'error' instead of 'util' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26496 diff changeset	260 raise error.Abort(_('cannot use both abort and continue'))
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	261 if collapsef:
26587 56b2bcea2529 error: get Abort from 'error' instead of 'util' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26496 diff changeset	262 raise error.Abort(
11285 f118029e534c rebase: use usual util.abort rather than error.ParseError Matt Mackall <mpm@selenic.com> parents: 11205 diff changeset	263 _('cannot use collapse with continue or abort'))
8117 2b30d8488819 remove unnecessary outer parenthesis in if-statements Martin Geisler <mg@lazybytes.net> parents: 8112 diff changeset	264 if srcf or basef or destf:
26587 56b2bcea2529 error: get Abort from 'error' instead of 'util' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26496 diff changeset	265 raise error.Abort(
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	266 _('abort and continue do not allow specifying revisions'))
26165 927c0d84e09f rebase: fix warning about ignoring tool option on rebase continue (issue4698) liscju <piotr.listkiewicz@gmail.com> parents: 26029 diff changeset	267 if abortf and opts.get('tool', False):
13856 0995eee8ffe4 rebase: add --tool argument for specifying merge tool Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 13778 diff changeset	268 ui.warn(_('tool option will be ignored\n'))
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	269
19848 577f4c562d52 rebase: catch RepoLookupError at restoring rebase state for abort/continue FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 19641 diff changeset	270 try:
577f4c562d52 rebase: catch RepoLookupError at restoring rebase state for abort/continue FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 19641 diff changeset	271 (originalwd, target, state, skipped, collapsef, keepf,
577f4c562d52 rebase: catch RepoLookupError at restoring rebase state for abort/continue FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 19641 diff changeset	272 keepbranchesf, external, activebookmark) = restorestatus(repo)
28185 c7e8948627f3 rebase: adds storing collapse message (issue4792) liscju <piotr.listkiewicz@gmail.com> parents: 28136 diff changeset	273 collapsemsg = restorecollapsemsg(repo)
19848 577f4c562d52 rebase: catch RepoLookupError at restoring rebase state for abort/continue FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 19641 diff changeset	274 except error.RepoLookupError:
577f4c562d52 rebase: catch RepoLookupError at restoring rebase state for abort/continue FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 19641 diff changeset	275 if abortf:
577f4c562d52 rebase: catch RepoLookupError at restoring rebase state for abort/continue FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 19641 diff changeset	276 clearstatus(repo)
28185 c7e8948627f3 rebase: adds storing collapse message (issue4792) liscju <piotr.listkiewicz@gmail.com> parents: 28136 diff changeset	277 clearcollapsemsg(repo)
19848 577f4c562d52 rebase: catch RepoLookupError at restoring rebase state for abort/continue FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 19641 diff changeset	278 repo.ui.warn(_('rebase aborted (no revision is removed,'
577f4c562d52 rebase: catch RepoLookupError at restoring rebase state for abort/continue FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 19641 diff changeset	279 ' only broken state is cleared)\n'))
577f4c562d52 rebase: catch RepoLookupError at restoring rebase state for abort/continue FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 19641 diff changeset	280 return 0
577f4c562d52 rebase: catch RepoLookupError at restoring rebase state for abort/continue FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 19641 diff changeset	281 else:
577f4c562d52 rebase: catch RepoLookupError at restoring rebase state for abort/continue FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 19641 diff changeset	282 msg = _('cannot continue inconsistent rebase')
20313 dcd65ce87260 hgext: fix one typo in rebase Simon Heimberg <simohe@besonet.ch> parents: 20250 diff changeset	283 hint = _('use "hg rebase --abort" to clear broken state')
26587 56b2bcea2529 error: get Abort from 'error' instead of 'util' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26496 diff changeset	284 raise error.Abort(msg, hint=hint)
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	285 if abortf:
24758 d7451adc72f6 rebase: restore bookmark state on abort Tony Tung <tonytung@fb.com> parents: 23970 diff changeset	286 return abort(repo, originalwd, target, state,
d7451adc72f6 rebase: restore bookmark state on abort Tony Tung <tonytung@fb.com> parents: 23970 diff changeset	287 activebookmark=activebookmark)
28686 b212e01fead0 rebase: fix crash when rebase aborts while rebasing obsolete revisions Laurent Charignon <lcharignon@fb.com> parents: 28685 diff changeset	288
b212e01fead0 rebase: fix crash when rebase aborts while rebasing obsolete revisions Laurent Charignon <lcharignon@fb.com> parents: 28685 diff changeset	289 obsoletenotrebased = {}
b212e01fead0 rebase: fix crash when rebase aborts while rebasing obsolete revisions Laurent Charignon <lcharignon@fb.com> parents: 28685 diff changeset	290 if ui.configbool('experimental', 'rebaseskipobsolete',
b212e01fead0 rebase: fix crash when rebase aborts while rebasing obsolete revisions Laurent Charignon <lcharignon@fb.com> parents: 28685 diff changeset	291 default=True):
b212e01fead0 rebase: fix crash when rebase aborts while rebasing obsolete revisions Laurent Charignon <lcharignon@fb.com> parents: 28685 diff changeset	292 rebaseobsrevs = set([r for r, status in state.items()
b212e01fead0 rebase: fix crash when rebase aborts while rebasing obsolete revisions Laurent Charignon <lcharignon@fb.com> parents: 28685 diff changeset	293 if status == revprecursor])
b212e01fead0 rebase: fix crash when rebase aborts while rebasing obsolete revisions Laurent Charignon <lcharignon@fb.com> parents: 28685 diff changeset	294 rebasesetrevs = set(state.keys())
b212e01fead0 rebase: fix crash when rebase aborts while rebasing obsolete revisions Laurent Charignon <lcharignon@fb.com> parents: 28685 diff changeset	295 obsoletenotrebased = _computeobsoletenotrebased(repo,
b212e01fead0 rebase: fix crash when rebase aborts while rebasing obsolete revisions Laurent Charignon <lcharignon@fb.com> parents: 28685 diff changeset	296 rebaseobsrevs,
b212e01fead0 rebase: fix crash when rebase aborts while rebasing obsolete revisions Laurent Charignon <lcharignon@fb.com> parents: 28685 diff changeset	297 target)
b212e01fead0 rebase: fix crash when rebase aborts while rebasing obsolete revisions Laurent Charignon <lcharignon@fb.com> parents: 28685 diff changeset	298 rebaseobsskipped = set(obsoletenotrebased)
b212e01fead0 rebase: fix crash when rebase aborts while rebasing obsolete revisions Laurent Charignon <lcharignon@fb.com> parents: 28685 diff changeset	299 _checkobsrebase(repo, ui, rebaseobsrevs, rebasesetrevs,
b212e01fead0 rebase: fix crash when rebase aborts while rebasing obsolete revisions Laurent Charignon <lcharignon@fb.com> parents: 28685 diff changeset	300 rebaseobsskipped)
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	301 else:
29043 cf7de4aeb86b destutil: add the ability to specify a search space for rebase destination Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 28686 diff changeset	302 dest, rebaseset = _definesets(ui, repo, destf, srcf, basef, revf,
cf7de4aeb86b destutil: add the ability to specify a search space for rebase destination Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 28686 diff changeset	303 destspace=destspace)
28136 5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	304 if dest is None:
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	305 return _nothingtorebase()
15271 84d4a4ce45fd rebase: simplify set generation Matt Mackall <mpm@selenic.com> parents: 15270 diff changeset	306
22952 8792ac090e3b obsolete: add allowunstable option Durham Goode <durham@fb.com> parents: 22951 diff changeset	307 allowunstable = obsolete.isenabled(repo, obsolete.allowunstableopt)
8792ac090e3b obsolete: add allowunstable option Durham Goode <durham@fb.com> parents: 22951 diff changeset	308 if (not (keepf or allowunstable)
18269 9454e40e047b clfilter: drop unnecessary explicit filtering on rebase Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 18164 diff changeset	309 and repo.revs('first(children(%ld) - %ld)',
18164 bacf55bd8f90 rebase: allow non-head rebase-set when obsolete is enabled Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18093 diff changeset	310 rebaseset, rebaseset)):
26587 56b2bcea2529 error: get Abort from 'error' instead of 'util' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26496 diff changeset	311 raise error.Abort(
15272 2889d4574726 rebase: simplify check for orphaned descendants Matt Mackall <mpm@selenic.com> parents: 15271 diff changeset	312 _("can't remove original changesets with"
2889d4574726 rebase: simplify check for orphaned descendants Matt Mackall <mpm@selenic.com> parents: 15271 diff changeset	313 " unrebased descendants"),
2889d4574726 rebase: simplify check for orphaned descendants Matt Mackall <mpm@selenic.com> parents: 15271 diff changeset	314 hint=_('use --keep to keep original changesets'))
2889d4574726 rebase: simplify check for orphaned descendants Matt Mackall <mpm@selenic.com> parents: 15271 diff changeset	315
26349 92409f8dff5d rebase: don't rebase obsolete commit whose successor is already rebased Laurent Charignon <lcharignon@fb.com> parents: 26301 diff changeset	316 obsoletenotrebased = {}
28429 a47881680402 rebase: turn rebaseskipobsolete on by default Kostia Balytskyi <ikostia@fb.com> parents: 28394 diff changeset	317 if ui.configbool('experimental', 'rebaseskipobsolete',
a47881680402 rebase: turn rebaseskipobsolete on by default Kostia Balytskyi <ikostia@fb.com> parents: 28394 diff changeset	318 default=True):
26349 92409f8dff5d rebase: don't rebase obsolete commit whose successor is already rebased Laurent Charignon <lcharignon@fb.com> parents: 26301 diff changeset	319 rebasesetrevs = set(rebaseset)
27790 2d294dada4f8 rebase: small refactoring to allow better extensibility from extensions Laurent Charignon <lcharignon@fb.com> parents: 27746 diff changeset	320 rebaseobsrevs = _filterobsoleterevs(repo, rebasesetrevs)
26349 92409f8dff5d rebase: don't rebase obsolete commit whose successor is already rebased Laurent Charignon <lcharignon@fb.com> parents: 26301 diff changeset	321 obsoletenotrebased = _computeobsoletenotrebased(repo,
27744 f2b8b4e2de20 rebase: minor refactoring of _computeobsoletenotrebased Laurent Charignon <lcharignon@fb.com> parents: 27626 diff changeset	322 rebaseobsrevs,
26349 92409f8dff5d rebase: don't rebase obsolete commit whose successor is already rebased Laurent Charignon <lcharignon@fb.com> parents: 26301 diff changeset	323 dest)
27745 d3a128e8604a rebase: create a new variable to make the next patch more legible Laurent Charignon <lcharignon@fb.com> parents: 27744 diff changeset	324 rebaseobsskipped = set(obsoletenotrebased)
28685 6c4d23fe611c rebase: refactor of error handling code path for rebaseskipobsolete Laurent Charignon <lcharignon@fb.com> parents: 28429 diff changeset	325 _checkobsrebase(repo, ui, rebaseobsrevs,
6c4d23fe611c rebase: refactor of error handling code path for rebaseskipobsolete Laurent Charignon <lcharignon@fb.com> parents: 28429 diff changeset	326 rebasesetrevs,
6c4d23fe611c rebase: refactor of error handling code path for rebaseskipobsolete Laurent Charignon <lcharignon@fb.com> parents: 28429 diff changeset	327 rebaseobsskipped)
27577 f9e755736b0e rebase: better error message when rebased changes are all in destination Laurent Charignon <lcharignon@fb.com> parents: 27458 diff changeset	328
26349 92409f8dff5d rebase: don't rebase obsolete commit whose successor is already rebased Laurent Charignon <lcharignon@fb.com> parents: 26301 diff changeset	329 result = buildstate(repo, dest, rebaseset, collapsef,
92409f8dff5d rebase: don't rebase obsolete commit whose successor is already rebased Laurent Charignon <lcharignon@fb.com> parents: 26301 diff changeset	330 obsoletenotrebased)
92409f8dff5d rebase: don't rebase obsolete commit whose successor is already rebased Laurent Charignon <lcharignon@fb.com> parents: 26301 diff changeset	331
10351 38fe86fb16e3 rebase: refactoring Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 10263 diff changeset	332 if not result:
38fe86fb16e3 rebase: refactoring Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 10263 diff changeset	333 # Empty state built, nothing to rebase
8615 94ca38e63576 use ui instead of repo.ui when the former is in scope Martin Geisler <mg@lazybytes.net> parents: 8454 diff changeset	334 ui.status(_('nothing to rebase\n'))
26671 66dc39cd7d06 rebase: factor out nothing to rebase return code Ryan McElroy <rmcelroy@fb.com> parents: 26669 diff changeset	335 return _nothingtorebase()
20250 f380b191e085 rebase: remove old code for handling empty rebaseset Mads Kiilerich <madski@unity3d.com> parents: 20249 diff changeset	336
f380b191e085 rebase: remove old code for handling empty rebaseset Mads Kiilerich <madski@unity3d.com> parents: 20249 diff changeset	337 root = min(rebaseset)
f380b191e085 rebase: remove old code for handling empty rebaseset Mads Kiilerich <madski@unity3d.com> parents: 20249 diff changeset	338 if not keepf and not repo[root].mutable():
26587 56b2bcea2529 error: get Abort from 'error' instead of 'util' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26496 diff changeset	339 raise error.Abort(_("can't rebase public changeset %s")
19059 53eadcb814fd rebase: check no-op before checking phase (issue3891) Siddharth Agarwal <sid0@fb.com> parents: 18933 diff changeset	340 % repo[root],
23917 3cbb5bf4035d messages: quote "hg help" hints consistently Wagner Bruna <wbruna@yahoo.com> parents: 23877 diff changeset	341 hint=_('see "hg help phases" for details'))
20250 f380b191e085 rebase: remove old code for handling empty rebaseset Mads Kiilerich <madski@unity3d.com> parents: 20249 diff changeset	342
f380b191e085 rebase: remove old code for handling empty rebaseset Mads Kiilerich <madski@unity3d.com> parents: 20249 diff changeset	343 originalwd, target, state = result
f380b191e085 rebase: remove old code for handling empty rebaseset Mads Kiilerich <madski@unity3d.com> parents: 20249 diff changeset	344 if collapsef:
f380b191e085 rebase: remove old code for handling empty rebaseset Mads Kiilerich <madski@unity3d.com> parents: 20249 diff changeset	345 targetancestors = repo.changelog.ancestors([target],
f380b191e085 rebase: remove old code for handling empty rebaseset Mads Kiilerich <madski@unity3d.com> parents: 20249 diff changeset	346 inclusive=True)
f380b191e085 rebase: remove old code for handling empty rebaseset Mads Kiilerich <madski@unity3d.com> parents: 20249 diff changeset	347 external = externalparent(repo, state, targetancestors)
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	348
21027 25ee5dbebc6b rebase: tell when reopening a closed branch head Mads Kiilerich <madski@unity3d.com> parents: 20790 diff changeset	349 if dest.closesbranch() and not keepbranchesf:
25ee5dbebc6b rebase: tell when reopening a closed branch head Mads Kiilerich <madski@unity3d.com> parents: 20790 diff changeset	350 ui.status(_('reopening closed branch head %s\n') % dest)
25ee5dbebc6b rebase: tell when reopening a closed branch head Mads Kiilerich <madski@unity3d.com> parents: 20790 diff changeset	351
27975 6f92d6bd2972 rebase: backout changeset 986d04b9fedd Siddharth Agarwal <sid0@fb.com> parents: 27963 diff changeset	352 if keepbranchesf:
27976 8f4d3eeb5198 rebase: backout changeset d755a9531fce Siddharth Agarwal <sid0@fb.com> parents: 27975 diff changeset	353 # insert _savebranch at the start of extrafns so if
8f4d3eeb5198 rebase: backout changeset d755a9531fce Siddharth Agarwal <sid0@fb.com> parents: 27975 diff changeset	354 # there's a user-provided extrafn it can clobber branch if
8f4d3eeb5198 rebase: backout changeset d755a9531fce Siddharth Agarwal <sid0@fb.com> parents: 27975 diff changeset	355 # desired
8f4d3eeb5198 rebase: backout changeset d755a9531fce Siddharth Agarwal <sid0@fb.com> parents: 27975 diff changeset	356 extrafns.insert(0, _savebranch)
27975 6f92d6bd2972 rebase: backout changeset 986d04b9fedd Siddharth Agarwal <sid0@fb.com> parents: 27963 diff changeset	357 if collapsef:
6f92d6bd2972 rebase: backout changeset 986d04b9fedd Siddharth Agarwal <sid0@fb.com> parents: 27963 diff changeset	358 branches = set()
6f92d6bd2972 rebase: backout changeset 986d04b9fedd Siddharth Agarwal <sid0@fb.com> parents: 27963 diff changeset	359 for rev in state:
6f92d6bd2972 rebase: backout changeset 986d04b9fedd Siddharth Agarwal <sid0@fb.com> parents: 27963 diff changeset	360 branches.add(repo[rev].branch())
6f92d6bd2972 rebase: backout changeset 986d04b9fedd Siddharth Agarwal <sid0@fb.com> parents: 27963 diff changeset	361 if len(branches) > 1:
6f92d6bd2972 rebase: backout changeset 986d04b9fedd Siddharth Agarwal <sid0@fb.com> parents: 27963 diff changeset	362 raise error.Abort(_('cannot collapse multiple named '
6f92d6bd2972 rebase: backout changeset 986d04b9fedd Siddharth Agarwal <sid0@fb.com> parents: 27963 diff changeset	363 'branches'))
14897 b9daa5b7a3af rebase: block collapse with keepbranches on multiple named branches (issue2112) Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 14884 diff changeset	364
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	365 # Rebase
10351 38fe86fb16e3 rebase: refactoring Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 10263 diff changeset	366 if not targetancestors:
18093 9c76da468a19 rebase: use lazy ancestor membership testing Siddharth Agarwal <sid0@fb.com> parents: 17989 diff changeset	367 targetancestors = repo.changelog.ancestors([target], inclusive=True)
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	368
14884 c0ccd70df52c rebase: reset bookmarks (issue2265 and issue2873) Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 14635 diff changeset	369 # Keep track of the current bookmarks in order to reset them later
c0ccd70df52c rebase: reset bookmarks (issue2265 and issue2873) Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 14635 diff changeset	370 currentbookmarks = repo._bookmarks.copy()
24947 a02d293a1079 bookmarks: rename bookmarkcurrent to activebookmark (API) Ryan McElroy <rmcelroy@fb.com> parents: 24945 diff changeset	371 activebookmark = activebookmark or repo._activebookmark
17046 4116504d1ec4 bookmarks: correctly update current bookmarks on rebase (issue2277) David Schleimer <dschleimer@fb.com> parents: 17026 diff changeset	372 if activebookmark:
24944 08ec11e3ae4c bookmarks: rename unsetcurrent to deactivate (API) Ryan McElroy <rmcelroy@fb.com> parents: 24870 diff changeset	373 bookmarks.deactivate(repo)
14884 c0ccd70df52c rebase: reset bookmarks (issue2265 and issue2873) Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 14635 diff changeset	374
19860 6cd9b8428104 rebase: rework extrafn handling to support multiple extrafns Augie Fackler <raf@durin42.com> parents: 19852 diff changeset	375 extrafn = _makeextrafn(extrafns)
6cd9b8428104 rebase: rework extrafn handling to support multiple extrafns Augie Fackler <raf@durin42.com> parents: 19852 diff changeset	376
11729 c91b86a291b0 rebase/progress: Adding progress for rebasing timeless <timeless@gmail.com> parents: 11546 diff changeset	377 sortedstate = sorted(state)
c91b86a291b0 rebase/progress: Adding progress for rebasing timeless <timeless@gmail.com> parents: 11546 diff changeset	378 total = len(sortedstate)
c91b86a291b0 rebase/progress: Adding progress for rebasing timeless <timeless@gmail.com> parents: 11546 diff changeset	379 pos = 0
c91b86a291b0 rebase/progress: Adding progress for rebasing timeless <timeless@gmail.com> parents: 11546 diff changeset	380 for rev in sortedstate:
23517 4f18e80d9c30 rebase: show more useful status information while rebasing Mads Kiilerich <madski@unity3d.com> parents: 23491 diff changeset	381 ctx = repo[rev]
4f18e80d9c30 rebase: show more useful status information while rebasing Mads Kiilerich <madski@unity3d.com> parents: 23491 diff changeset	382 desc = '%d:%s "%s"' % (ctx.rev(), ctx,
4f18e80d9c30 rebase: show more useful status information while rebasing Mads Kiilerich <madski@unity3d.com> parents: 23491 diff changeset	383 ctx.description().split('\n', 1)[0])
4f18e80d9c30 rebase: show more useful status information while rebasing Mads Kiilerich <madski@unity3d.com> parents: 23491 diff changeset	384 names = repo.nodetags(ctx.node()) + repo.nodebookmarks(ctx.node())
4f18e80d9c30 rebase: show more useful status information while rebasing Mads Kiilerich <madski@unity3d.com> parents: 23491 diff changeset	385 if names:
4f18e80d9c30 rebase: show more useful status information while rebasing Mads Kiilerich <madski@unity3d.com> parents: 23491 diff changeset	386 desc += ' (%s)' % ' '.join(names)
11729 c91b86a291b0 rebase/progress: Adding progress for rebasing timeless <timeless@gmail.com> parents: 11546 diff changeset	387 pos += 1
23490 102f144f6e02 rebase: add a 'revtodo' constant Pierre-Yves David <pierre-yves.david@fb.com> parents: 23489 diff changeset	388 if state[rev] == revtodo:
23517 4f18e80d9c30 rebase: show more useful status information while rebasing Mads Kiilerich <madski@unity3d.com> parents: 23491 diff changeset	389 ui.status(_('rebasing %s\n') % desc)
4f18e80d9c30 rebase: show more useful status information while rebasing Mads Kiilerich <madski@unity3d.com> parents: 23491 diff changeset	390 ui.progress(_("rebasing"), pos, ("%d:%s" % (rev, ctx)),
12744 0793d763e413 progress: dropping superfluous space from units timeless <timeless@gmail.com> parents: 12062 diff changeset	391 _('changesets'), total)
23484 cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	392 p1, p2, base = defineparents(repo, rev, target, state,
cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	393 targetancestors)
7952 b214066b7e1d rebase: store/restore arguments correctly Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 7951 diff changeset	394 storestatus(repo, originalwd, target, state, collapsef, keepf,
18755 72412afe4c28 rebase: restore active bookmark after rebase --continue Durham Goode <durham@fb.com> parents: 18549 diff changeset	395 keepbranchesf, external, activebookmark)
28185 c7e8948627f3 rebase: adds storing collapse message (issue4792) liscju <piotr.listkiewicz@gmail.com> parents: 28136 diff changeset	396 storecollapsemsg(repo, collapsemsg)
27167 3fe8cb40c9c5 commands: inline definition of localrepo.parents() and drop the method (API) Augie Fackler <augie@google.com> parents: 27146 diff changeset	397 if len(repo[None].parents()) == 2:
10351 38fe86fb16e3 rebase: refactoring Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 10263 diff changeset	398 repo.ui.debug('resuming interrupted rebase\n')
38fe86fb16e3 rebase: refactoring Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 10263 diff changeset	399 else:
13856 0995eee8ffe4 rebase: add --tool argument for specifying merge tool Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 13778 diff changeset	400 try:
20790 49f2d5644f04 config: set a 'source' in most cases where config don't come from file but code Mads Kiilerich <madski@unity3d.com> parents: 20773 diff changeset	401 ui.setconfig('ui', 'forcemerge', opts.get('tool', ''),
49f2d5644f04 config: set a 'source' in most cases where config don't come from file but code Mads Kiilerich <madski@unity3d.com> parents: 20773 diff changeset	402 'rebase')
23484 cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	403 stats = rebasenode(repo, rev, p1, base, state,
cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	404 collapsef, target)
13856 0995eee8ffe4 rebase: add --tool argument for specifying merge tool Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 13778 diff changeset	405 if stats and stats[3] > 0:
18933 42b620fc89e2 rebase: switch from util.Abort to util.InterventionRequired where appropriate (bc) Augie Fackler <raf@durin42.com> parents: 18764 diff changeset	406 raise error.InterventionRequired(
42b620fc89e2 rebase: switch from util.Abort to util.InterventionRequired where appropriate (bc) Augie Fackler <raf@durin42.com> parents: 18764 diff changeset	407 _('unresolved conflicts (see hg '
42b620fc89e2 rebase: switch from util.Abort to util.InterventionRequired where appropriate (bc) Augie Fackler <raf@durin42.com> parents: 18764 diff changeset	408 'resolve, then hg rebase --continue)'))
13856 0995eee8ffe4 rebase: add --tool argument for specifying merge tool Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 13778 diff changeset	409 finally:
20790 49f2d5644f04 config: set a 'source' in most cases where config don't come from file but code Mads Kiilerich <madski@unity3d.com> parents: 20773 diff changeset	410 ui.setconfig('ui', 'forcemerge', '', 'rebase')
10351 38fe86fb16e3 rebase: refactoring Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 10263 diff changeset	411 if not collapsef:
23461 ffef6d503ab2 rebase: avoid redundant repo[rev].rev() - just keep working in rev space Mads Kiilerich <madski@unity3d.com> parents: 23460 diff changeset	412 merging = p2 != nullrev
22251 d0d3e5c6eb3c rebase: change "editform" to distinguish merge commits from others FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 22206 diff changeset	413 editform = cmdutil.mergeeditform(merging, 'rebase')
d0d3e5c6eb3c rebase: change "editform" to distinguish merge commits from others FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 22206 diff changeset	414 editor = cmdutil.getcommiteditor(editform=editform, **opts)
23459 2e047b1558a5 rebase: clarify naming of variables holding node hashes - don't call them rev Mads Kiilerich <madski@unity3d.com> parents: 23457 diff changeset	415 newnode = concludenode(repo, rev, p1, p2, extrafn=extrafn,
26360 b2415e94b2f5 rebase: avoid losing branch commits with --keepbranch (issue4835) timeless@mozdev.org parents: 26349 diff changeset	416 editor=editor,
26869 412e8c5e38b4 rebase: pass date parameter to concludenode Stanislau Hlebik <stash@fb.com> parents: 26868 diff changeset	417 keepbranches=keepbranchesf,
412e8c5e38b4 rebase: pass date parameter to concludenode Stanislau Hlebik <stash@fb.com> parents: 26868 diff changeset	418 date=date)
10351 38fe86fb16e3 rebase: refactoring Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 10263 diff changeset	419 else:
38fe86fb16e3 rebase: refactoring Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 10263 diff changeset	420 # Skip commit if we are collapsing
22405 6f63c47cbb86 dirstate: wrap setparent calls with begin/endparentchange (issue4353) Durham Goode <durham@fb.com> parents: 22388 diff changeset	421 repo.dirstate.beginparentchange()
16551 ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16531 diff changeset	422 repo.setparents(repo[p1].node())
22405 6f63c47cbb86 dirstate: wrap setparent calls with begin/endparentchange (issue4353) Durham Goode <durham@fb.com> parents: 22388 diff changeset	423 repo.dirstate.endparentchange()
23459 2e047b1558a5 rebase: clarify naming of variables holding node hashes - don't call them rev Mads Kiilerich <madski@unity3d.com> parents: 23457 diff changeset	424 newnode = None
10351 38fe86fb16e3 rebase: refactoring Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 10263 diff changeset	425 # Update the state
23459 2e047b1558a5 rebase: clarify naming of variables holding node hashes - don't call them rev Mads Kiilerich <madski@unity3d.com> parents: 23457 diff changeset	426 if newnode is not None:
2e047b1558a5 rebase: clarify naming of variables holding node hashes - don't call them rev Mads Kiilerich <madski@unity3d.com> parents: 23457 diff changeset	427 state[rev] = repo[newnode].rev()
23519 8872d1bf30da rebase: improve debug messages while processing the list of rebases Mads Kiilerich <madski@unity3d.com> parents: 23518 diff changeset	428 ui.debug('rebased as %s\n' % short(newnode))
10351 38fe86fb16e3 rebase: refactoring Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 10263 diff changeset	429 else:
38fe86fb16e3 rebase: refactoring Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 10263 diff changeset	430 if not collapsef:
26811 d1561a422748 rebase: fix wrong 'no changes to commit' when using --collapse Mads Kiilerich <madski@unity3d.com> parents: 26781 diff changeset	431 ui.warn(_('note: rebase of %d:%s created no changes '
d1561a422748 rebase: fix wrong 'no changes to commit' when using --collapse Mads Kiilerich <madski@unity3d.com> parents: 26781 diff changeset	432 'to commit\n') % (rev, ctx))
10351 38fe86fb16e3 rebase: refactoring Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 10263 diff changeset	433 skipped.add(rev)
38fe86fb16e3 rebase: refactoring Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 10263 diff changeset	434 state[rev] = p1
23519 8872d1bf30da rebase: improve debug messages while processing the list of rebases Mads Kiilerich <madski@unity3d.com> parents: 23518 diff changeset	435 ui.debug('next revision set to %s\n' % p1)
23517 4f18e80d9c30 rebase: show more useful status information while rebasing Mads Kiilerich <madski@unity3d.com> parents: 23491 diff changeset	436 elif state[rev] == nullmerge:
23519 8872d1bf30da rebase: improve debug messages while processing the list of rebases Mads Kiilerich <madski@unity3d.com> parents: 23518 diff changeset	437 ui.debug('ignoring null merge rebase of %s\n' % rev)
23517 4f18e80d9c30 rebase: show more useful status information while rebasing Mads Kiilerich <madski@unity3d.com> parents: 23491 diff changeset	438 elif state[rev] == revignored:
4f18e80d9c30 rebase: show more useful status information while rebasing Mads Kiilerich <madski@unity3d.com> parents: 23491 diff changeset	439 ui.status(_('not rebasing ignored %s\n') % desc)
26349 92409f8dff5d rebase: don't rebase obsolete commit whose successor is already rebased Laurent Charignon <lcharignon@fb.com> parents: 26301 diff changeset	440 elif state[rev] == revprecursor:
92409f8dff5d rebase: don't rebase obsolete commit whose successor is already rebased Laurent Charignon <lcharignon@fb.com> parents: 26301 diff changeset	441 targetctx = repo[obsoletenotrebased[rev]]
92409f8dff5d rebase: don't rebase obsolete commit whose successor is already rebased Laurent Charignon <lcharignon@fb.com> parents: 26301 diff changeset	442 desctarget = '%d:%s "%s"' % (targetctx.rev(), targetctx,
92409f8dff5d rebase: don't rebase obsolete commit whose successor is already rebased Laurent Charignon <lcharignon@fb.com> parents: 26301 diff changeset	443 targetctx.description().split('\n', 1)[0])
92409f8dff5d rebase: don't rebase obsolete commit whose successor is already rebased Laurent Charignon <lcharignon@fb.com> parents: 26301 diff changeset	444 msg = _('note: not rebasing %s, already in destination as %s\n')
92409f8dff5d rebase: don't rebase obsolete commit whose successor is already rebased Laurent Charignon <lcharignon@fb.com> parents: 26301 diff changeset	445 ui.status(msg % (desc, desctarget))
27012 5eac7ab59b95 rebase: don't rebase obsolete commits with no successor Laurent Charignon <lcharignon@fb.com> parents: 27010 diff changeset	446 elif state[rev] == revpruned:
5eac7ab59b95 rebase: don't rebase obsolete commits with no successor Laurent Charignon <lcharignon@fb.com> parents: 27010 diff changeset	447 msg = _('note: not rebasing %s, it has no successor\n')
5eac7ab59b95 rebase: don't rebase obsolete commits with no successor Laurent Charignon <lcharignon@fb.com> parents: 27010 diff changeset	448 ui.status(msg % desc)
23517 4f18e80d9c30 rebase: show more useful status information while rebasing Mads Kiilerich <madski@unity3d.com> parents: 23491 diff changeset	449 else:
4f18e80d9c30 rebase: show more useful status information while rebasing Mads Kiilerich <madski@unity3d.com> parents: 23491 diff changeset	450 ui.status(_('already rebased %s as %s\n') %
4f18e80d9c30 rebase: show more useful status information while rebasing Mads Kiilerich <madski@unity3d.com> parents: 23491 diff changeset	451 (desc, repo[state[rev]]))
10351 38fe86fb16e3 rebase: refactoring Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 10263 diff changeset	452
11729 c91b86a291b0 rebase/progress: Adding progress for rebasing timeless <timeless@gmail.com> parents: 11546 diff changeset	453 ui.progress(_('rebasing'), None)
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	454 ui.note(_('rebase merging completed\n'))
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	455
10677 f2558a8228be rebase: add option to not commit after a collapsing Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 10676 diff changeset	456 if collapsef and not keepopen:
23484 cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	457 p1, p2, _base = defineparents(repo, min(state), target,
cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	458 state, targetancestors)
22206 6122ad50e38f rebase: use "rebase.collapse" as "editform" for "--collapse" always FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 22038 diff changeset	459 editopt = opts.get('edit')
6122ad50e38f rebase: use "rebase.collapse" as "editform" for "--collapse" always FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 22038 diff changeset	460 editform = 'rebase.collapse'
13661 ee349e228835 rebase: add -m/--message to rebase --collapse (issue2389) Radomir Dopieralski <sheep@stxnext.pl> parents: 13609 diff changeset	461 if collapsemsg:
ee349e228835 rebase: add -m/--message to rebase --collapse (issue2389) Radomir Dopieralski <sheep@stxnext.pl> parents: 13609 diff changeset	462 commitmsg = collapsemsg
ee349e228835 rebase: add -m/--message to rebase --collapse (issue2389) Radomir Dopieralski <sheep@stxnext.pl> parents: 13609 diff changeset	463 else:
ee349e228835 rebase: add -m/--message to rebase --collapse (issue2389) Radomir Dopieralski <sheep@stxnext.pl> parents: 13609 diff changeset	464 commitmsg = 'Collapsed revision'
ee349e228835 rebase: add -m/--message to rebase --collapse (issue2389) Radomir Dopieralski <sheep@stxnext.pl> parents: 13609 diff changeset	465 for rebased in state:
18446 c83d36b81df1 rebase: lose the comparison to `nullmerge` Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18444 diff changeset	466 if rebased not in skipped and state[rebased] > nullmerge:
13661 ee349e228835 rebase: add -m/--message to rebase --collapse (issue2389) Radomir Dopieralski <sheep@stxnext.pl> parents: 13609 diff changeset	467 commitmsg += '\n* %s' % repo[rebased].description()
22206 6122ad50e38f rebase: use "rebase.collapse" as "editform" for "--collapse" always FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 22038 diff changeset	468 editopt = True
6122ad50e38f rebase: use "rebase.collapse" as "editform" for "--collapse" always FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 22038 diff changeset	469 editor = cmdutil.getcommiteditor(edit=editopt, editform=editform)
23459 2e047b1558a5 rebase: clarify naming of variables holding node hashes - don't call them rev Mads Kiilerich <madski@unity3d.com> parents: 23457 diff changeset	470 newnode = concludenode(repo, rev, p1, external, commitmsg=commitmsg,
26360 b2415e94b2f5 rebase: avoid losing branch commits with --keepbranch (issue4835) timeless@mozdev.org parents: 26349 diff changeset	471 extrafn=extrafn, editor=editor,
26869 412e8c5e38b4 rebase: pass date parameter to concludenode Stanislau Hlebik <stash@fb.com> parents: 26868 diff changeset	472 keepbranches=keepbranchesf,
412e8c5e38b4 rebase: pass date parameter to concludenode Stanislau Hlebik <stash@fb.com> parents: 26868 diff changeset	473 date=date)
23460 8dc45c905989 rebase: always store rev in state, also when collapsing Mads Kiilerich <madski@unity3d.com> parents: 23459 diff changeset	474 if newnode is None:
8dc45c905989 rebase: always store rev in state, also when collapsing Mads Kiilerich <madski@unity3d.com> parents: 23459 diff changeset	475 newrev = target
8dc45c905989 rebase: always store rev in state, also when collapsing Mads Kiilerich <madski@unity3d.com> parents: 23459 diff changeset	476 else:
8dc45c905989 rebase: always store rev in state, also when collapsing Mads Kiilerich <madski@unity3d.com> parents: 23459 diff changeset	477 newrev = repo[newnode].rev()
19986 ea81f8b2364e rebase: fix working copy location after a --collapse (issue4080) Durham Goode <durham@fb.com> parents: 19984 diff changeset	478 for oldrev in state.iterkeys():
ea81f8b2364e rebase: fix working copy location after a --collapse (issue4080) Durham Goode <durham@fb.com> parents: 19984 diff changeset	479 if state[oldrev] > nullmerge:
23460 8dc45c905989 rebase: always store rev in state, also when collapsing Mads Kiilerich <madski@unity3d.com> parents: 23459 diff changeset	480 state[oldrev] = newrev
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	481
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	482 if 'qtip' in repo.tags():
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	483 updatemq(repo, state, skipped, **opts)
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	484
14884 c0ccd70df52c rebase: reset bookmarks (issue2265 and issue2873) Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 14635 diff changeset	485 if currentbookmarks:
c0ccd70df52c rebase: reset bookmarks (issue2265 and issue2873) Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 14635 diff changeset	486 # Nodeids are needed to reset bookmarks
c0ccd70df52c rebase: reset bookmarks (issue2265 and issue2873) Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 14635 diff changeset	487 nstate = {}
c0ccd70df52c rebase: reset bookmarks (issue2265 and issue2873) Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 14635 diff changeset	488 for k, v in state.iteritems():
18446 c83d36b81df1 rebase: lose the comparison to `nullmerge` Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18444 diff changeset	489 if v > nullmerge:
14884 c0ccd70df52c rebase: reset bookmarks (issue2265 and issue2873) Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 14635 diff changeset	490 nstate[repo[k].node()] = repo[v].node()
18549 12de53323e59 rebase: derive node from target rev (issue3802) Siddharth Agarwal <sid0@fb.com> parents: 18518 diff changeset	491 # XXX this is the same as dest.node() for the non-continue path --
12de53323e59 rebase: derive node from target rev (issue3802) Siddharth Agarwal <sid0@fb.com> parents: 18518 diff changeset	492 # this should probably be cleaned up
12de53323e59 rebase: derive node from target rev (issue3802) Siddharth Agarwal <sid0@fb.com> parents: 18518 diff changeset	493 targetnode = repo[target].node()
14884 c0ccd70df52c rebase: reset bookmarks (issue2265 and issue2873) Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 14635 diff changeset	494
19925 9c78ed396075 rebase: preserve working directory parent (BC) Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 19861 diff changeset	495 # restore original working directory
9c78ed396075 rebase: preserve working directory parent (BC) Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 19861 diff changeset	496 # (we do this before stripping)
9c78ed396075 rebase: preserve working directory parent (BC) Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 19861 diff changeset	497 newwd = state.get(originalwd, originalwd)
23440 57d35d3c1cf1 rebase: ignore negative state when updating back to original wc parent Pierre-Yves David <pierre-yves.david@fb.com> parents: 23246 diff changeset	498 if newwd < 0:
57d35d3c1cf1 rebase: ignore negative state when updating back to original wc parent Pierre-Yves David <pierre-yves.david@fb.com> parents: 23246 diff changeset	499 # original directory is a parent of rebase set root or ignored
57d35d3c1cf1 rebase: ignore negative state when updating back to original wc parent Pierre-Yves David <pierre-yves.david@fb.com> parents: 23246 diff changeset	500 newwd = originalwd
19925 9c78ed396075 rebase: preserve working directory parent (BC) Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 19861 diff changeset	501 if newwd not in [c.rev() for c in repo[None].parents()]:
9c78ed396075 rebase: preserve working directory parent (BC) Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 19861 diff changeset	502 ui.note(_("update back to initial working directory parent\n"))
9c78ed396075 rebase: preserve working directory parent (BC) Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 19861 diff changeset	503 hg.updaterepo(repo, newwd, False)
9c78ed396075 rebase: preserve working directory parent (BC) Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 19861 diff changeset	504
7952 b214066b7e1d rebase: store/restore arguments correctly Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 7951 diff changeset	505 if not keepf:
17613 aafc521668d8 rebase: properly handle --collapse when creating obsolescence marker Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 17612 diff changeset	506 collapsedas = None
aafc521668d8 rebase: properly handle --collapse when creating obsolescence marker Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 17612 diff changeset	507 if collapsef:
23459 2e047b1558a5 rebase: clarify naming of variables holding node hashes - don't call them rev Mads Kiilerich <madski@unity3d.com> parents: 23457 diff changeset	508 collapsedas = newnode
18444 55aff0c2b73c rebase: do not invent successor to skipped changeset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18424 diff changeset	509 clearrebased(ui, repo, state, skipped, collapsedas)
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	510
27866 f54bf1f41566 with: use context manager for transaction in rebase Bryan O'Sullivan <bryano@fb.com> parents: 27790 diff changeset	511 with repo.transaction('bookmark') as tr:
27058 616ea95c8f11 rebase: indentation change to make the next patch more legible Laurent Charignon <lcharignon@fb.com> parents: 27014 diff changeset	512 if currentbookmarks:
27059 405320cd6198 rebase: use bookmarks.recordchange instead of bookmarks.write Laurent Charignon <lcharignon@fb.com> parents: 27058 diff changeset	513 updatebookmarks(repo, targetnode, nstate, currentbookmarks, tr)
27058 616ea95c8f11 rebase: indentation change to make the next patch more legible Laurent Charignon <lcharignon@fb.com> parents: 27014 diff changeset	514 if activebookmark not in repo._bookmarks:
616ea95c8f11 rebase: indentation change to make the next patch more legible Laurent Charignon <lcharignon@fb.com> parents: 27014 diff changeset	515 # active bookmark was divergent one and has been deleted
616ea95c8f11 rebase: indentation change to make the next patch more legible Laurent Charignon <lcharignon@fb.com> parents: 27014 diff changeset	516 activebookmark = None
27229 40a2f972f26d rebase: only clear rebase status after the rebase transaction has completed Laurent Charignon <lcharignon@fb.com> parents: 27167 diff changeset	517 clearstatus(repo)
28185 c7e8948627f3 rebase: adds storing collapse message (issue4792) liscju <piotr.listkiewicz@gmail.com> parents: 28136 diff changeset	518 clearcollapsemsg(repo)
14884 c0ccd70df52c rebase: reset bookmarks (issue2265 and issue2873) Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 14635 diff changeset	519
11203 7a9cf012dddc rebase: only show "rebase completed" message with -v Matt Mackall <mpm@selenic.com> parents: 11201 diff changeset	520 ui.note(_("rebase completed\n"))
18386 03442135dff4 refactoring: use unlinkpath with ignoremissing Mads Kiilerich <madski@unity3d.com> parents: 18269 diff changeset	521 util.unlinkpath(repo.sjoin('undo'), ignoremissing=True)
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	522 if skipped:
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	523 ui.note(_("%d revisions have been skipped\n") % len(skipped))
17046 4116504d1ec4 bookmarks: correctly update current bookmarks on rebase (issue2277) David Schleimer <dschleimer@fb.com> parents: 17026 diff changeset	524
4116504d1ec4 bookmarks: correctly update current bookmarks on rebase (issue2277) David Schleimer <dschleimer@fb.com> parents: 17026 diff changeset	525 if (activebookmark and
19926 0f99747202f9 rebase: preserve active bookmark when not at head (issue3813) Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 19925 diff changeset	526 repo['.'].node() == repo._bookmarks[activebookmark]):
24945 e0b0fbd47491 bookmarks: rename setcurrent to activate (API) Ryan McElroy <rmcelroy@fb.com> parents: 24944 diff changeset	527 bookmarks.activate(repo, activebookmark)
17046 4116504d1ec4 bookmarks: correctly update current bookmarks on rebase (issue2277) David Schleimer <dschleimer@fb.com> parents: 17026 diff changeset	528
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	529 finally:
8112 6ee71f78497c switch lock releasing in the extensions from gc to explicit Ronny Pfannschmidt <Ronny.Pfannschmidt@gmx.de> parents: 8076 diff changeset	530 release(lock, wlock)
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	531
29043 cf7de4aeb86b destutil: add the ability to specify a search space for rebase destination Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 28686 diff changeset	532 def _definesets(ui, repo, destf=None, srcf=None, basef=None, revf=[],
cf7de4aeb86b destutil: add the ability to specify a search space for rebase destination Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 28686 diff changeset	533 destspace=None):
28136 5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	534 """use revisions argument to define destination and rebase set
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	535 """
29043 cf7de4aeb86b destutil: add the ability to specify a search space for rebase destination Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 28686 diff changeset	536 # destspace is here to work around issues with `hg pull --rebase` see
cf7de4aeb86b destutil: add the ability to specify a search space for rebase destination Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 28686 diff changeset	537 # issue5214 for details
28136 5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	538 if srcf and basef:
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	539 raise error.Abort(_('cannot specify both a source and a base'))
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	540 if revf and basef:
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	541 raise error.Abort(_('cannot specify both a revision and a base'))
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	542 if revf and srcf:
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	543 raise error.Abort(_('cannot specify both a revision and a source'))
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	544
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	545 cmdutil.checkunfinished(repo)
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	546 cmdutil.bailifchanged(repo)
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	547
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	548 if destf:
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	549 dest = scmutil.revsingle(repo, destf)
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	550
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	551 if revf:
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	552 rebaseset = scmutil.revrange(repo, revf)
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	553 if not rebaseset:
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	554 ui.status(_('empty "rev" revision set - nothing to rebase\n'))
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	555 return None, None
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	556 elif srcf:
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	557 src = scmutil.revrange(repo, [srcf])
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	558 if not src:
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	559 ui.status(_('empty "source" revision set - nothing to rebase\n'))
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	560 return None, None
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	561 rebaseset = repo.revs('(%ld)::', src)
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	562 assert rebaseset
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	563 else:
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	564 base = scmutil.revrange(repo, [basef or '.'])
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	565 if not base:
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	566 ui.status(_('empty "base" revision set - '
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	567 "can't compute rebase set\n"))
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	568 return None, None
28189 fac3a24be50e rebase: choose default destination the same way as 'hg merge' (BC) Pierre-Yves David <pierre-yves.david@fb.com> parents: 28188 diff changeset	569 if not destf:
29043 cf7de4aeb86b destutil: add the ability to specify a search space for rebase destination Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 28686 diff changeset	570 dest = repo[_destrebase(repo, base, destspace=destspace)]
28189 fac3a24be50e rebase: choose default destination the same way as 'hg merge' (BC) Pierre-Yves David <pierre-yves.david@fb.com> parents: 28188 diff changeset	571 destf = str(dest)
fac3a24be50e rebase: choose default destination the same way as 'hg merge' (BC) Pierre-Yves David <pierre-yves.david@fb.com> parents: 28188 diff changeset	572
28136 5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	573 commonanc = repo.revs('ancestor(%ld, %d)', base, dest).first()
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	574 if commonanc is not None:
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	575 rebaseset = repo.revs('(%d::(%ld) - %d)::',
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	576 commonanc, base, commonanc)
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	577 else:
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	578 rebaseset = []
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	579
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	580 if not rebaseset:
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	581 # transform to list because smartsets are not comparable to
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	582 # lists. This should be improved to honor laziness of
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	583 # smartset.
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	584 if list(base) == [dest.rev()]:
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	585 if basef:
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	586 ui.status(_('nothing to rebase - %s is both "base"'
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	587 ' and destination\n') % dest)
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	588 else:
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	589 ui.status(_('nothing to rebase - working directory '
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	590 'parent is also destination\n'))
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	591 elif not repo.revs('%ld - ::%d', base, dest):
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	592 if basef:
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	593 ui.status(_('nothing to rebase - "base" %s is '
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	594 'already an ancestor of destination '
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	595 '%s\n') %
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	596 ('+'.join(str(repo[r]) for r in base),
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	597 dest))
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	598 else:
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	599 ui.status(_('nothing to rebase - working '
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	600 'directory parent is already an '
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	601 'ancestor of destination %s\n') % dest)
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	602 else: # can it happen?
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	603 ui.status(_('nothing to rebase from %s to %s\n') %
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	604 ('+'.join(str(repo[r]) for r in base), dest))
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	605 return None, None
28189 fac3a24be50e rebase: choose default destination the same way as 'hg merge' (BC) Pierre-Yves David <pierre-yves.david@fb.com> parents: 28188 diff changeset	606
fac3a24be50e rebase: choose default destination the same way as 'hg merge' (BC) Pierre-Yves David <pierre-yves.david@fb.com> parents: 28188 diff changeset	607 if not destf:
29043 cf7de4aeb86b destutil: add the ability to specify a search space for rebase destination Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 28686 diff changeset	608 dest = repo[_destrebase(repo, rebaseset, destspace=destspace)]
28189 fac3a24be50e rebase: choose default destination the same way as 'hg merge' (BC) Pierre-Yves David <pierre-yves.david@fb.com> parents: 28188 diff changeset	609 destf = str(dest)
fac3a24be50e rebase: choose default destination the same way as 'hg merge' (BC) Pierre-Yves David <pierre-yves.david@fb.com> parents: 28188 diff changeset	610
28136 5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	611 return dest, rebaseset
5853878bbc2a rebase: extract rebaseset and destination computation in a function Pierre-Yves David <pierre-yves.david@fb.com> parents: 28122 diff changeset	612
19955 2160c2e0d7d1 rebase: refactor and rename checkexternal - it is a getter more than a setter Mads Kiilerich <madski@unity3d.com> parents: 19951 diff changeset	613 def externalparent(repo, state, targetancestors):
2160c2e0d7d1 rebase: refactor and rename checkexternal - it is a getter more than a setter Mads Kiilerich <madski@unity3d.com> parents: 19951 diff changeset	614 """Return the revision that should be used as the second parent
2160c2e0d7d1 rebase: refactor and rename checkexternal - it is a getter more than a setter Mads Kiilerich <madski@unity3d.com> parents: 19951 diff changeset	615 when the revisions in state is collapsed on top of targetancestors.
2160c2e0d7d1 rebase: refactor and rename checkexternal - it is a getter more than a setter Mads Kiilerich <madski@unity3d.com> parents: 19951 diff changeset	616 Abort if there is more than one parent.
10351 38fe86fb16e3 rebase: refactoring Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 10263 diff changeset	617 """
19955 2160c2e0d7d1 rebase: refactor and rename checkexternal - it is a getter more than a setter Mads Kiilerich <madski@unity3d.com> parents: 19951 diff changeset	618 parents = set()
10351 38fe86fb16e3 rebase: refactoring Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 10263 diff changeset	619 source = min(state)
38fe86fb16e3 rebase: refactoring Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 10263 diff changeset	620 for rev in state:
38fe86fb16e3 rebase: refactoring Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 10263 diff changeset	621 if rev == source:
38fe86fb16e3 rebase: refactoring Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 10263 diff changeset	622 continue
38fe86fb16e3 rebase: refactoring Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 10263 diff changeset	623 for p in repo[rev].parents():
38fe86fb16e3 rebase: refactoring Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 10263 diff changeset	624 if (p.rev() not in state
38fe86fb16e3 rebase: refactoring Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 10263 diff changeset	625 and p.rev() not in targetancestors):
19955 2160c2e0d7d1 rebase: refactor and rename checkexternal - it is a getter more than a setter Mads Kiilerich <madski@unity3d.com> parents: 19951 diff changeset	626 parents.add(p.rev())
2160c2e0d7d1 rebase: refactor and rename checkexternal - it is a getter more than a setter Mads Kiilerich <madski@unity3d.com> parents: 19951 diff changeset	627 if not parents:
2160c2e0d7d1 rebase: refactor and rename checkexternal - it is a getter more than a setter Mads Kiilerich <madski@unity3d.com> parents: 19951 diff changeset	628 return nullrev
2160c2e0d7d1 rebase: refactor and rename checkexternal - it is a getter more than a setter Mads Kiilerich <madski@unity3d.com> parents: 19951 diff changeset	629 if len(parents) == 1:
2160c2e0d7d1 rebase: refactor and rename checkexternal - it is a getter more than a setter Mads Kiilerich <madski@unity3d.com> parents: 19951 diff changeset	630 return parents.pop()
26587 56b2bcea2529 error: get Abort from 'error' instead of 'util' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26496 diff changeset	631 raise error.Abort(_('unable to collapse on top of %s, there is more '
19956 78ab0f85e249 rebase: improve error message for more than one external parent Mads Kiilerich <madski@unity3d.com> parents: 19955 diff changeset	632 'than one external parent: %s') %
78ab0f85e249 rebase: improve error message for more than one external parent Mads Kiilerich <madski@unity3d.com> parents: 19955 diff changeset	633 (max(targetancestors),
78ab0f85e249 rebase: improve error message for more than one external parent Mads Kiilerich <madski@unity3d.com> parents: 19955 diff changeset	634 ', '.join(str(p) for p in sorted(parents))))
10351 38fe86fb16e3 rebase: refactoring Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 10263 diff changeset	635
26360 b2415e94b2f5 rebase: avoid losing branch commits with --keepbranch (issue4835) timeless@mozdev.org parents: 26349 diff changeset	636 def concludenode(repo, rev, p1, p2, commitmsg=None, editor=None, extrafn=None,
26868 a2aa39a725a1 rebase: add date parameter to concludenode function Stanislau Hlebik <stash@fb.com> parents: 26811 diff changeset	637 keepbranches=False, date=None):
23484 cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	638 '''Commit the wd changes with parents p1 and p2. Reuse commit info from rev
cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	639 but also store useful information in extra.
23459 2e047b1558a5 rebase: clarify naming of variables holding node hashes - don't call them rev Mads Kiilerich <madski@unity3d.com> parents: 23457 diff changeset	640 Return node of committed revision.'''
24998 c8a97fa742b7 rebase: use dirstateguard instead of dirstate.invalidate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24947 diff changeset	641 dsguard = cmdutil.dirstateguard(repo, 'rebase')
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	642 try:
16551 ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407) Patrick Mezard <patrick@mezard.eu> parents: 16531 diff changeset	643 repo.setparents(repo[p1].node(), repo[p2].node())
11537 0a044e5ff489 rebase: small cosmetic cleanups Nicolas Dumazet <nicdumz.commits@gmail.com> parents: 11531 diff changeset	644 ctx = repo[rev]
10351 38fe86fb16e3 rebase: refactoring Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 10263 diff changeset	645 if commitmsg is None:
11537 0a044e5ff489 rebase: small cosmetic cleanups Nicolas Dumazet <nicdumz.commits@gmail.com> parents: 11531 diff changeset	646 commitmsg = ctx.description()
26360 b2415e94b2f5 rebase: avoid losing branch commits with --keepbranch (issue4835) timeless@mozdev.org parents: 26349 diff changeset	647 keepbranch = keepbranches and repo[p1].branch() != ctx.branch()
27977 b698abf971e7 rebase: don't preserve most extra fields Siddharth Agarwal <sid0@fb.com> parents: 27976 diff changeset	648 extra = {'rebase_source': ctx.hex()}
10762 129e96f7a87a rebase: fix --collapse with --keepbranches (issue2100) Patrick Mezard <pmezard@gmail.com> parents: 10672 diff changeset	649 if extrafn:
129e96f7a87a rebase: fix --collapse with --keepbranches (issue2100) Patrick Mezard <pmezard@gmail.com> parents: 10672 diff changeset	650 extrafn(ctx, extra)
22038 021becbf024a rebase: do not retract phase boundary by hand Pierre-Yves David <pierre-yves.david@fb.com> parents: 22004 diff changeset	651
021becbf024a rebase: do not retract phase boundary by hand Pierre-Yves David <pierre-yves.david@fb.com> parents: 22004 diff changeset	652 backup = repo.ui.backupconfig('phases', 'new-commit')
021becbf024a rebase: do not retract phase boundary by hand Pierre-Yves David <pierre-yves.david@fb.com> parents: 22004 diff changeset	653 try:
021becbf024a rebase: do not retract phase boundary by hand Pierre-Yves David <pierre-yves.david@fb.com> parents: 22004 diff changeset	654 targetphase = max(ctx.phase(), phases.draft)
021becbf024a rebase: do not retract phase boundary by hand Pierre-Yves David <pierre-yves.david@fb.com> parents: 22004 diff changeset	655 repo.ui.setconfig('phases', 'new-commit', targetphase, 'rebase')
26360 b2415e94b2f5 rebase: avoid losing branch commits with --keepbranch (issue4835) timeless@mozdev.org parents: 26349 diff changeset	656 if keepbranch:
b2415e94b2f5 rebase: avoid losing branch commits with --keepbranch (issue4835) timeless@mozdev.org parents: 26349 diff changeset	657 repo.ui.setconfig('ui', 'allowemptycommit', True)
22038 021becbf024a rebase: do not retract phase boundary by hand Pierre-Yves David <pierre-yves.david@fb.com> parents: 22004 diff changeset	658 # Commit might fail if unresolved files exist
26868 a2aa39a725a1 rebase: add date parameter to concludenode function Stanislau Hlebik <stash@fb.com> parents: 26811 diff changeset	659 if date is None:
a2aa39a725a1 rebase: add date parameter to concludenode function Stanislau Hlebik <stash@fb.com> parents: 26811 diff changeset	660 date = ctx.date()
23459 2e047b1558a5 rebase: clarify naming of variables holding node hashes - don't call them rev Mads Kiilerich <madski@unity3d.com> parents: 23457 diff changeset	661 newnode = repo.commit(text=commitmsg, user=ctx.user(),
26868 a2aa39a725a1 rebase: add date parameter to concludenode function Stanislau Hlebik <stash@fb.com> parents: 26811 diff changeset	662 date=date, extra=extra, editor=editor)
22038 021becbf024a rebase: do not retract phase boundary by hand Pierre-Yves David <pierre-yves.david@fb.com> parents: 22004 diff changeset	663 finally:
021becbf024a rebase: do not retract phase boundary by hand Pierre-Yves David <pierre-yves.david@fb.com> parents: 22004 diff changeset	664 repo.ui.restoreconfig(backup)
021becbf024a rebase: do not retract phase boundary by hand Pierre-Yves David <pierre-yves.david@fb.com> parents: 22004 diff changeset	665
23459 2e047b1558a5 rebase: clarify naming of variables holding node hashes - don't call them rev Mads Kiilerich <madski@unity3d.com> parents: 23457 diff changeset	666 repo.dirstate.setbranch(repo[newnode].branch())
24998 c8a97fa742b7 rebase: use dirstateguard instead of dirstate.invalidate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24947 diff changeset	667 dsguard.close()
23459 2e047b1558a5 rebase: clarify naming of variables holding node hashes - don't call them rev Mads Kiilerich <madski@unity3d.com> parents: 23457 diff changeset	668 return newnode
24998 c8a97fa742b7 rebase: use dirstateguard instead of dirstate.invalidate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24947 diff changeset	669 finally:
c8a97fa742b7 rebase: use dirstateguard instead of dirstate.invalidate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24947 diff changeset	670 release(dsguard)
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	671
23484 cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	672 def rebasenode(repo, rev, p1, base, state, collapse, target):
cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	673 'Rebase a single revision rev on top of p1 using base as merge ancestor'
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	674 # Merge phase
10351 38fe86fb16e3 rebase: refactoring Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 10263 diff changeset	675 # Update to target and merge it with local
23461 ffef6d503ab2 rebase: avoid redundant repo[rev].rev() - just keep working in rev space Mads Kiilerich <madski@unity3d.com> parents: 23460 diff changeset	676 if repo['.'].rev() != p1:
ffef6d503ab2 rebase: avoid redundant repo[rev].rev() - just keep working in rev space Mads Kiilerich <madski@unity3d.com> parents: 23460 diff changeset	677 repo.ui.debug(" update to %d:%s\n" % (p1, repo[p1]))
27344 43c00ca887d1 merge: have merge.update use a matcher instead of partial fn Augie Fackler <augie@google.com> parents: 27261 diff changeset	678 merge.update(repo, p1, False, True)
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	679 else:
10351 38fe86fb16e3 rebase: refactoring Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 10263 diff changeset	680 repo.ui.debug(" already in target\n")
26748 5ba0a99ff27f dirstate: make dirstate.write() callers pass transaction object to it FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 26745 diff changeset	681 repo.dirstate.write(repo.currenttransaction())
23461 ffef6d503ab2 rebase: avoid redundant repo[rev].rev() - just keep working in rev space Mads Kiilerich <madski@unity3d.com> parents: 23460 diff changeset	682 repo.ui.debug(" merge against %d:%s\n" % (rev, repo[rev]))
19969 ad9db007656f rebase: fix selection of base used when rebasing merge (issue4041) Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 19956 diff changeset	683 if base is not None:
23461 ffef6d503ab2 rebase: avoid redundant repo[rev].rev() - just keep working in rev space Mads Kiilerich <madski@unity3d.com> parents: 23460 diff changeset	684 repo.ui.debug(" detach base %d:%s\n" % (base, repo[base]))
16696 d1afbf03e69a rebase: allow collapsing branches in place (issue3111) Patrick Mezard <patrick@mezard.eu> parents: 16566 diff changeset	685 # When collapsing in-place, the parent is the common ancestor, we
d1afbf03e69a rebase: allow collapsing branches in place (issue3111) Patrick Mezard <patrick@mezard.eu> parents: 16566 diff changeset	686 # have to allow merging with it.
27344 43c00ca887d1 merge: have merge.update use a matcher instead of partial fn Augie Fackler <augie@google.com> parents: 27261 diff changeset	687 stats = merge.update(repo, rev, True, True, base, collapse,
21526 3b40e32e88c3 rebase: specify custom conflict marker labels for rebase (BC) Durham Goode <durham@fb.com> parents: 21410 diff changeset	688 labels=['dest', 'source'])
22905 63e889cc610d rebase: move duplicatecopies next to merge Matt Mackall <mpm@selenic.com> parents: 22901 diff changeset	689 if collapse:
63e889cc610d rebase: move duplicatecopies next to merge Matt Mackall <mpm@selenic.com> parents: 22901 diff changeset	690 copies.duplicatecopies(repo, rev, target)
63e889cc610d rebase: move duplicatecopies next to merge Matt Mackall <mpm@selenic.com> parents: 22901 diff changeset	691 else:
63e889cc610d rebase: move duplicatecopies next to merge Matt Mackall <mpm@selenic.com> parents: 22901 diff changeset	692 # If we're not using --collapse, we need to
63e889cc610d rebase: move duplicatecopies next to merge Matt Mackall <mpm@selenic.com> parents: 22901 diff changeset	693 # duplicate copies between the revision we're
63e889cc610d rebase: move duplicatecopies next to merge Matt Mackall <mpm@selenic.com> parents: 22901 diff changeset	694 # rebasing and its first parent, but not
63e889cc610d rebase: move duplicatecopies next to merge Matt Mackall <mpm@selenic.com> parents: 22901 diff changeset	695 # duplicate any copies that have already been
63e889cc610d rebase: move duplicatecopies next to merge Matt Mackall <mpm@selenic.com> parents: 22901 diff changeset	696 # performed in the destination.
63e889cc610d rebase: move duplicatecopies next to merge Matt Mackall <mpm@selenic.com> parents: 22901 diff changeset	697 p1rev = repo[rev].p1().rev()
63e889cc610d rebase: move duplicatecopies next to merge Matt Mackall <mpm@selenic.com> parents: 22901 diff changeset	698 copies.duplicatecopies(repo, rev, p1rev, skiprev=target)
63e889cc610d rebase: move duplicatecopies next to merge Matt Mackall <mpm@selenic.com> parents: 22901 diff changeset	699 return stats
6923 ebf1462f2145 strip trailing whitespace, replace tabs by spaces Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 6906 diff changeset	700
18447 7159426c8d13 rebase: properly handle unrebased revision between rebased one Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18446 diff changeset	701 def nearestrebased(repo, rev, state):
7159426c8d13 rebase: properly handle unrebased revision between rebased one Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18446 diff changeset	702 """return the nearest ancestors of rev in the rebase result"""
7159426c8d13 rebase: properly handle unrebased revision between rebased one Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18446 diff changeset	703 rebased = [r for r in state if state[r] > nullmerge]
7159426c8d13 rebase: properly handle unrebased revision between rebased one Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18446 diff changeset	704 candidates = repo.revs('max(%ld and (::%d))', rebased, rev)
7159426c8d13 rebase: properly handle unrebased revision between rebased one Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18446 diff changeset	705 if candidates:
22820 103dcfbb385f rebase: use `last` instead of direct indexing Pierre-Yves David <pierre-yves.david@fb.com> parents: 22790 diff changeset	706 return state[candidates.first()]
18447 7159426c8d13 rebase: properly handle unrebased revision between rebased one Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18446 diff changeset	707 else:
7159426c8d13 rebase: properly handle unrebased revision between rebased one Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18446 diff changeset	708 return None
7159426c8d13 rebase: properly handle unrebased revision between rebased one Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18446 diff changeset	709
28685 6c4d23fe611c rebase: refactor of error handling code path for rebaseskipobsolete Laurent Charignon <lcharignon@fb.com> parents: 28429 diff changeset	710 def _checkobsrebase(repo, ui,
6c4d23fe611c rebase: refactor of error handling code path for rebaseskipobsolete Laurent Charignon <lcharignon@fb.com> parents: 28429 diff changeset	711 rebaseobsrevs,
6c4d23fe611c rebase: refactor of error handling code path for rebaseskipobsolete Laurent Charignon <lcharignon@fb.com> parents: 28429 diff changeset	712 rebasesetrevs,
6c4d23fe611c rebase: refactor of error handling code path for rebaseskipobsolete Laurent Charignon <lcharignon@fb.com> parents: 28429 diff changeset	713 rebaseobsskipped):
6c4d23fe611c rebase: refactor of error handling code path for rebaseskipobsolete Laurent Charignon <lcharignon@fb.com> parents: 28429 diff changeset	714 """
6c4d23fe611c rebase: refactor of error handling code path for rebaseskipobsolete Laurent Charignon <lcharignon@fb.com> parents: 28429 diff changeset	715 Abort if rebase will create divergence or rebase is noop because of markers
6c4d23fe611c rebase: refactor of error handling code path for rebaseskipobsolete Laurent Charignon <lcharignon@fb.com> parents: 28429 diff changeset	716
6c4d23fe611c rebase: refactor of error handling code path for rebaseskipobsolete Laurent Charignon <lcharignon@fb.com> parents: 28429 diff changeset	717 `rebaseobsrevs`: set of obsolete revision in source
6c4d23fe611c rebase: refactor of error handling code path for rebaseskipobsolete Laurent Charignon <lcharignon@fb.com> parents: 28429 diff changeset	718 `rebasesetrevs`: set of revisions to be rebased from source
6c4d23fe611c rebase: refactor of error handling code path for rebaseskipobsolete Laurent Charignon <lcharignon@fb.com> parents: 28429 diff changeset	719 `rebaseobsskipped`: set of revisions from source skipped because they have
6c4d23fe611c rebase: refactor of error handling code path for rebaseskipobsolete Laurent Charignon <lcharignon@fb.com> parents: 28429 diff changeset	720 successors in destination
6c4d23fe611c rebase: refactor of error handling code path for rebaseskipobsolete Laurent Charignon <lcharignon@fb.com> parents: 28429 diff changeset	721 """
6c4d23fe611c rebase: refactor of error handling code path for rebaseskipobsolete Laurent Charignon <lcharignon@fb.com> parents: 28429 diff changeset	722 # Obsolete node with successors not in dest leads to divergence
6c4d23fe611c rebase: refactor of error handling code path for rebaseskipobsolete Laurent Charignon <lcharignon@fb.com> parents: 28429 diff changeset	723 divergenceok = ui.configbool('experimental',
6c4d23fe611c rebase: refactor of error handling code path for rebaseskipobsolete Laurent Charignon <lcharignon@fb.com> parents: 28429 diff changeset	724 'allowdivergence')
6c4d23fe611c rebase: refactor of error handling code path for rebaseskipobsolete Laurent Charignon <lcharignon@fb.com> parents: 28429 diff changeset	725 divergencebasecandidates = rebaseobsrevs - rebaseobsskipped
6c4d23fe611c rebase: refactor of error handling code path for rebaseskipobsolete Laurent Charignon <lcharignon@fb.com> parents: 28429 diff changeset	726
6c4d23fe611c rebase: refactor of error handling code path for rebaseskipobsolete Laurent Charignon <lcharignon@fb.com> parents: 28429 diff changeset	727 if divergencebasecandidates and not divergenceok:
6c4d23fe611c rebase: refactor of error handling code path for rebaseskipobsolete Laurent Charignon <lcharignon@fb.com> parents: 28429 diff changeset	728 divhashes = (str(repo[r])
6c4d23fe611c rebase: refactor of error handling code path for rebaseskipobsolete Laurent Charignon <lcharignon@fb.com> parents: 28429 diff changeset	729 for r in divergencebasecandidates)
6c4d23fe611c rebase: refactor of error handling code path for rebaseskipobsolete Laurent Charignon <lcharignon@fb.com> parents: 28429 diff changeset	730 msg = _("this rebase will cause "
6c4d23fe611c rebase: refactor of error handling code path for rebaseskipobsolete Laurent Charignon <lcharignon@fb.com> parents: 28429 diff changeset	731 "divergences from: %s")
6c4d23fe611c rebase: refactor of error handling code path for rebaseskipobsolete Laurent Charignon <lcharignon@fb.com> parents: 28429 diff changeset	732 h = _("to force the rebase please set "
6c4d23fe611c rebase: refactor of error handling code path for rebaseskipobsolete Laurent Charignon <lcharignon@fb.com> parents: 28429 diff changeset	733 "experimental.allowdivergence=True")
6c4d23fe611c rebase: refactor of error handling code path for rebaseskipobsolete Laurent Charignon <lcharignon@fb.com> parents: 28429 diff changeset	734 raise error.Abort(msg % (",".join(divhashes),), hint=h)
6c4d23fe611c rebase: refactor of error handling code path for rebaseskipobsolete Laurent Charignon <lcharignon@fb.com> parents: 28429 diff changeset	735
6c4d23fe611c rebase: refactor of error handling code path for rebaseskipobsolete Laurent Charignon <lcharignon@fb.com> parents: 28429 diff changeset	736 # - plain prune (no successor) changesets are rebased
6c4d23fe611c rebase: refactor of error handling code path for rebaseskipobsolete Laurent Charignon <lcharignon@fb.com> parents: 28429 diff changeset	737 # - split changesets are not rebased if at least one of the
6c4d23fe611c rebase: refactor of error handling code path for rebaseskipobsolete Laurent Charignon <lcharignon@fb.com> parents: 28429 diff changeset	738 # changeset resulting from the split is an ancestor of dest
6c4d23fe611c rebase: refactor of error handling code path for rebaseskipobsolete Laurent Charignon <lcharignon@fb.com> parents: 28429 diff changeset	739 rebaseset = rebasesetrevs - rebaseobsskipped
6c4d23fe611c rebase: refactor of error handling code path for rebaseskipobsolete Laurent Charignon <lcharignon@fb.com> parents: 28429 diff changeset	740 if rebasesetrevs and not rebaseset:
6c4d23fe611c rebase: refactor of error handling code path for rebaseskipobsolete Laurent Charignon <lcharignon@fb.com> parents: 28429 diff changeset	741 msg = _('all requested changesets have equivalents '
6c4d23fe611c rebase: refactor of error handling code path for rebaseskipobsolete Laurent Charignon <lcharignon@fb.com> parents: 28429 diff changeset	742 'or were marked as obsolete')
6c4d23fe611c rebase: refactor of error handling code path for rebaseskipobsolete Laurent Charignon <lcharignon@fb.com> parents: 28429 diff changeset	743 hint = _('to force the rebase, set the config '
6c4d23fe611c rebase: refactor of error handling code path for rebaseskipobsolete Laurent Charignon <lcharignon@fb.com> parents: 28429 diff changeset	744 'experimental.rebaseskipobsolete to False')
6c4d23fe611c rebase: refactor of error handling code path for rebaseskipobsolete Laurent Charignon <lcharignon@fb.com> parents: 28429 diff changeset	745 raise error.Abort(msg, hint=hint)
6c4d23fe611c rebase: refactor of error handling code path for rebaseskipobsolete Laurent Charignon <lcharignon@fb.com> parents: 28429 diff changeset	746
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	747 def defineparents(repo, rev, target, state, targetancestors):
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	748 'Return the new parent relationship of the revision that will be rebased'
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	749 parents = repo[rev].parents()
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	750 p1 = p2 = nullrev
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	751
22906 75d0edb68b41 rebase: fix some weird mixed-case naming Matt Mackall <mpm@selenic.com> parents: 22905 diff changeset	752 p1n = parents[0].rev()
75d0edb68b41 rebase: fix some weird mixed-case naming Matt Mackall <mpm@selenic.com> parents: 22905 diff changeset	753 if p1n in targetancestors:
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	754 p1 = target
22906 75d0edb68b41 rebase: fix some weird mixed-case naming Matt Mackall <mpm@selenic.com> parents: 22905 diff changeset	755 elif p1n in state:
75d0edb68b41 rebase: fix some weird mixed-case naming Matt Mackall <mpm@selenic.com> parents: 22905 diff changeset	756 if state[p1n] == nullmerge:
10352 66d954e76ffb rebase: add --detach option to detach intermediate revisions (issue1950) Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 10351 diff changeset	757 p1 = target
27014 4223fc58f952 rebase: refactoring to avoid repetition of expression Laurent Charignon <lcharignon@fb.com> parents: 27013 diff changeset	758 elif state[p1n] in revskipped:
22906 75d0edb68b41 rebase: fix some weird mixed-case naming Matt Mackall <mpm@selenic.com> parents: 22905 diff changeset	759 p1 = nearestrebased(repo, p1n, state)
18447 7159426c8d13 rebase: properly handle unrebased revision between rebased one Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18446 diff changeset	760 if p1 is None:
7159426c8d13 rebase: properly handle unrebased revision between rebased one Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18446 diff changeset	761 p1 = target
10352 66d954e76ffb rebase: add --detach option to detach intermediate revisions (issue1950) Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 10351 diff changeset	762 else:
22906 75d0edb68b41 rebase: fix some weird mixed-case naming Matt Mackall <mpm@selenic.com> parents: 22905 diff changeset	763 p1 = state[p1n]
75d0edb68b41 rebase: fix some weird mixed-case naming Matt Mackall <mpm@selenic.com> parents: 22905 diff changeset	764 else: # p1n external
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	765 p1 = target
22906 75d0edb68b41 rebase: fix some weird mixed-case naming Matt Mackall <mpm@selenic.com> parents: 22905 diff changeset	766 p2 = p1n
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	767
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	768 if len(parents) == 2 and parents[1].rev() not in targetancestors:
22906 75d0edb68b41 rebase: fix some weird mixed-case naming Matt Mackall <mpm@selenic.com> parents: 22905 diff changeset	769 p2n = parents[1].rev()
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	770 # interesting second parent
22906 75d0edb68b41 rebase: fix some weird mixed-case naming Matt Mackall <mpm@selenic.com> parents: 22905 diff changeset	771 if p2n in state:
75d0edb68b41 rebase: fix some weird mixed-case naming Matt Mackall <mpm@selenic.com> parents: 22905 diff changeset	772 if p1 == target: # p1n in targetancestors or external
75d0edb68b41 rebase: fix some weird mixed-case naming Matt Mackall <mpm@selenic.com> parents: 22905 diff changeset	773 p1 = state[p2n]
27014 4223fc58f952 rebase: refactoring to avoid repetition of expression Laurent Charignon <lcharignon@fb.com> parents: 27013 diff changeset	774 elif state[p2n] in revskipped:
22906 75d0edb68b41 rebase: fix some weird mixed-case naming Matt Mackall <mpm@selenic.com> parents: 22905 diff changeset	775 p2 = nearestrebased(repo, p2n, state)
18447 7159426c8d13 rebase: properly handle unrebased revision between rebased one Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18446 diff changeset	776 if p2 is None:
7159426c8d13 rebase: properly handle unrebased revision between rebased one Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18446 diff changeset	777 # no ancestors rebased yet, detach
7159426c8d13 rebase: properly handle unrebased revision between rebased one Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18446 diff changeset	778 p2 = target
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	779 else:
22906 75d0edb68b41 rebase: fix some weird mixed-case naming Matt Mackall <mpm@selenic.com> parents: 22905 diff changeset	780 p2 = state[p2n]
75d0edb68b41 rebase: fix some weird mixed-case naming Matt Mackall <mpm@selenic.com> parents: 22905 diff changeset	781 else: # p2n external
75d0edb68b41 rebase: fix some weird mixed-case naming Matt Mackall <mpm@selenic.com> parents: 22905 diff changeset	782 if p2 != nullrev: # p1n external too => rev is a merged revision
26587 56b2bcea2529 error: get Abort from 'error' instead of 'util' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26496 diff changeset	783 raise error.Abort(_('cannot use revision %d as base, result '
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	784 'would have 3 parents') % rev)
22906 75d0edb68b41 rebase: fix some weird mixed-case naming Matt Mackall <mpm@selenic.com> parents: 22905 diff changeset	785 p2 = p2n
10351 38fe86fb16e3 rebase: refactoring Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 10263 diff changeset	786 repo.ui.debug(" future parents are %d and %d\n" %
38fe86fb16e3 rebase: refactoring Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 10263 diff changeset	787 (repo[p1].rev(), repo[p2].rev()))
23484 cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	788
27963 07a5de79ec30 rebase: better way to detect non-detaching revisions (issue5044) Martijn Pieters <mj@zopatista.com> parents: 27959 diff changeset	789 if not any(p.rev() in state for p in parents):
07a5de79ec30 rebase: better way to detect non-detaching revisions (issue5044) Martijn Pieters <mj@zopatista.com> parents: 27959 diff changeset	790 # Case (1) root changeset of a non-detaching rebase set.
23484 cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	791 # Let the merge mechanism find the base itself.
cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	792 base = None
cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	793 elif not repo[rev].p2():
cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	794 # Case (2) detaching the node with a single parent, use this parent
cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	795 base = repo[rev].p1().rev()
cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	796 else:
23732 c51d6c043bb1 rebase: clarify comment about merge ancestor when rebasing merges Mads Kiilerich <madski@unity3d.com> parents: 23520 diff changeset	797 # Assuming there is a p1, this is the case where there also is a p2.
c51d6c043bb1 rebase: clarify comment about merge ancestor when rebasing merges Mads Kiilerich <madski@unity3d.com> parents: 23520 diff changeset	798 # We are thus rebasing a merge and need to pick the right merge base.
23484 cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	799 #
cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	800 # Imagine we have:
23732 c51d6c043bb1 rebase: clarify comment about merge ancestor when rebasing merges Mads Kiilerich <madski@unity3d.com> parents: 23520 diff changeset	801 # - M: current rebase revision in this step
23484 cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	802 # - A: one parent of M
23732 c51d6c043bb1 rebase: clarify comment about merge ancestor when rebasing merges Mads Kiilerich <madski@unity3d.com> parents: 23520 diff changeset	803 # - B: other parent of M
23484 cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	804 # - D: destination of this merge step (p1 var)
cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	805 #
23732 c51d6c043bb1 rebase: clarify comment about merge ancestor when rebasing merges Mads Kiilerich <madski@unity3d.com> parents: 23520 diff changeset	806 # Consider the case where D is a descendant of A or B and the other is
c51d6c043bb1 rebase: clarify comment about merge ancestor when rebasing merges Mads Kiilerich <madski@unity3d.com> parents: 23520 diff changeset	807 # 'outside'. In this case, the right merge base is the D ancestor.
c51d6c043bb1 rebase: clarify comment about merge ancestor when rebasing merges Mads Kiilerich <madski@unity3d.com> parents: 23520 diff changeset	808 #
c51d6c043bb1 rebase: clarify comment about merge ancestor when rebasing merges Mads Kiilerich <madski@unity3d.com> parents: 23520 diff changeset	809 # An informal proof, assuming A is 'outside' and B is the D ancestor:
23484 cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	810 #
cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	811 # If we pick B as the base, the merge involves:
cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	812 # - changes from B to M (actual changeset payload)
cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	813 # - changes from B to D (induced by rebase) as D is a rebased
cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	814 # version of B)
cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	815 # Which exactly represent the rebase operation.
cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	816 #
23732 c51d6c043bb1 rebase: clarify comment about merge ancestor when rebasing merges Mads Kiilerich <madski@unity3d.com> parents: 23520 diff changeset	817 # If we pick A as the base, the merge involves:
23484 cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	818 # - changes from A to M (actual changeset payload)
cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	819 # - changes from A to D (with include changes between unrelated A and B
cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	820 # plus changes induced by rebase)
cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	821 # Which does not represent anything sensible and creates a lot of
23732 c51d6c043bb1 rebase: clarify comment about merge ancestor when rebasing merges Mads Kiilerich <madski@unity3d.com> parents: 23520 diff changeset	822 # conflicts. A is thus not the right choice - B is.
c51d6c043bb1 rebase: clarify comment about merge ancestor when rebasing merges Mads Kiilerich <madski@unity3d.com> parents: 23520 diff changeset	823 #
c51d6c043bb1 rebase: clarify comment about merge ancestor when rebasing merges Mads Kiilerich <madski@unity3d.com> parents: 23520 diff changeset	824 # Note: The base found in this 'proof' is only correct in the specified
c51d6c043bb1 rebase: clarify comment about merge ancestor when rebasing merges Mads Kiilerich <madski@unity3d.com> parents: 23520 diff changeset	825 # case. This base does not make sense if is not D a descendant of A or B
c51d6c043bb1 rebase: clarify comment about merge ancestor when rebasing merges Mads Kiilerich <madski@unity3d.com> parents: 23520 diff changeset	826 # or if the other is not parent 'outside' (especially not if the other
c51d6c043bb1 rebase: clarify comment about merge ancestor when rebasing merges Mads Kiilerich <madski@unity3d.com> parents: 23520 diff changeset	827 # parent has been rebased). The current implementation does not
c51d6c043bb1 rebase: clarify comment about merge ancestor when rebasing merges Mads Kiilerich <madski@unity3d.com> parents: 23520 diff changeset	828 # make it feasible to consider different cases separately. In these
c51d6c043bb1 rebase: clarify comment about merge ancestor when rebasing merges Mads Kiilerich <madski@unity3d.com> parents: 23520 diff changeset	829 # other cases we currently just leave it to the user to correctly
c51d6c043bb1 rebase: clarify comment about merge ancestor when rebasing merges Mads Kiilerich <madski@unity3d.com> parents: 23520 diff changeset	830 # resolve an impossible merge using a wrong ancestor.
23484 cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	831 for p in repo[rev].parents():
cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	832 if state.get(p.rev()) == p1:
cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	833 base = p.rev()
cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	834 break
cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	835 else: # fallback when base not found
cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	836 base = None
cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	837
cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	838 # Raise because this function is called wrong (see issue 4106)
cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	839 raise AssertionError('no base found to rebase on '
cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	840 '(defineparents called wrong)')
cf3495dfd7ed rebase: move base calculation from rebasenode() to defineparents() Mads Kiilerich <madski@unity3d.com> parents: 23461 diff changeset	841 return p1, p2, base
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	842
7955 c3d4ff03ec72 rebase: keep original mq patch format (Issue1574) Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 7954 diff changeset	843 def isagitpatch(repo, patchname):
c3d4ff03ec72 rebase: keep original mq patch format (Issue1574) Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 7954 diff changeset	844 'Return true if the given patch is in git format'
c3d4ff03ec72 rebase: keep original mq patch format (Issue1574) Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 7954 diff changeset	845 mqpatch = os.path.join(repo.mq.path, patchname)
c3d4ff03ec72 rebase: keep original mq patch format (Issue1574) Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 7954 diff changeset	846 for line in patch.linereader(file(mqpatch, 'rb')):
c3d4ff03ec72 rebase: keep original mq patch format (Issue1574) Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 7954 diff changeset	847 if line.startswith('diff --git'):
c3d4ff03ec72 rebase: keep original mq patch format (Issue1574) Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 7954 diff changeset	848 return True
c3d4ff03ec72 rebase: keep original mq patch format (Issue1574) Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 7954 diff changeset	849 return False
c3d4ff03ec72 rebase: keep original mq patch format (Issue1574) Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 7954 diff changeset	850
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	851 def updatemq(repo, state, skipped, **opts):
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	852 'Update rebased mq patches - finalize and then import them'
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	853 mqrebase = {}
11537 0a044e5ff489 rebase: small cosmetic cleanups Nicolas Dumazet <nicdumz.commits@gmail.com> parents: 11531 diff changeset	854 mq = repo.mq
14572 8ff2957c1d82 mq: rename full_series to fullseries Adrian Buehlmann <adrian@cadifra.com> parents: 14509 diff changeset	855 original_series = mq.fullseries[:]
16531 b9f51f49bf2a rebase: preserve mq series order, guarded patches (issue2849) Patrick Mezard <patrick@mezard.eu> parents: 16280 diff changeset	856 skippedpatches = set()
14497 ea585f2b1adc rebase: restore mq guards after rebasing (issue2107) Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 13894 diff changeset	857
11537 0a044e5ff489 rebase: small cosmetic cleanups Nicolas Dumazet <nicdumz.commits@gmail.com> parents: 11531 diff changeset	858 for p in mq.applied:
0a044e5ff489 rebase: small cosmetic cleanups Nicolas Dumazet <nicdumz.commits@gmail.com> parents: 11531 diff changeset	859 rev = repo[p.node].rev()
0a044e5ff489 rebase: small cosmetic cleanups Nicolas Dumazet <nicdumz.commits@gmail.com> parents: 11531 diff changeset	860 if rev in state:
9467 4c041f1ee1b4 do not attempt to translate ui.debug output Martin Geisler <mg@lazybytes.net> parents: 9301 diff changeset	861 repo.ui.debug('revision %d is an mq patch (%s), finalize it.\n' %
11537 0a044e5ff489 rebase: small cosmetic cleanups Nicolas Dumazet <nicdumz.commits@gmail.com> parents: 11531 diff changeset	862 (rev, p.name))
0a044e5ff489 rebase: small cosmetic cleanups Nicolas Dumazet <nicdumz.commits@gmail.com> parents: 11531 diff changeset	863 mqrebase[rev] = (p.name, isagitpatch(repo, p.name))
16531 b9f51f49bf2a rebase: preserve mq series order, guarded patches (issue2849) Patrick Mezard <patrick@mezard.eu> parents: 16280 diff changeset	864 else:
b9f51f49bf2a rebase: preserve mq series order, guarded patches (issue2849) Patrick Mezard <patrick@mezard.eu> parents: 16280 diff changeset	865 # Applied but not rebased, not sure this should happen
b9f51f49bf2a rebase: preserve mq series order, guarded patches (issue2849) Patrick Mezard <patrick@mezard.eu> parents: 16280 diff changeset	866 skippedpatches.add(p.name)
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	867
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	868 if mqrebase:
11537 0a044e5ff489 rebase: small cosmetic cleanups Nicolas Dumazet <nicdumz.commits@gmail.com> parents: 11531 diff changeset	869 mq.finish(repo, mqrebase.keys())
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	870
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	871 # We must start import from the newest revision
8210 344751cd8cb8 replace various uses of list.reverse() Matt Mackall <mpm@selenic.com> parents: 8209 diff changeset	872 for rev in sorted(mqrebase, reverse=True):
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	873 if rev not in skipped:
11537 0a044e5ff489 rebase: small cosmetic cleanups Nicolas Dumazet <nicdumz.commits@gmail.com> parents: 11531 diff changeset	874 name, isgit = mqrebase[rev]
23520 de143427c499 rebase: show a note for updated mq patches Mads Kiilerich <mads@kiilerich.com> parents: 23519 diff changeset	875 repo.ui.note(_('updating mq patch %s to %s:%s\n') %
de143427c499 rebase: show a note for updated mq patches Mads Kiilerich <mads@kiilerich.com> parents: 23519 diff changeset	876 (name, state[rev], repo[state[rev]]))
11537 0a044e5ff489 rebase: small cosmetic cleanups Nicolas Dumazet <nicdumz.commits@gmail.com> parents: 11531 diff changeset	877 mq.qimport(repo, (), patchname=name, git=isgit,
0a044e5ff489 rebase: small cosmetic cleanups Nicolas Dumazet <nicdumz.commits@gmail.com> parents: 11531 diff changeset	878 rev=[str(state[rev])])
16531 b9f51f49bf2a rebase: preserve mq series order, guarded patches (issue2849) Patrick Mezard <patrick@mezard.eu> parents: 16280 diff changeset	879 else:
b9f51f49bf2a rebase: preserve mq series order, guarded patches (issue2849) Patrick Mezard <patrick@mezard.eu> parents: 16280 diff changeset	880 # Rebased and skipped
b9f51f49bf2a rebase: preserve mq series order, guarded patches (issue2849) Patrick Mezard <patrick@mezard.eu> parents: 16280 diff changeset	881 skippedpatches.add(mqrebase[rev][0])
14497 ea585f2b1adc rebase: restore mq guards after rebasing (issue2107) Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 13894 diff changeset	882
16531 b9f51f49bf2a rebase: preserve mq series order, guarded patches (issue2849) Patrick Mezard <patrick@mezard.eu> parents: 16280 diff changeset	883 # Patches were either applied and rebased and imported in
b9f51f49bf2a rebase: preserve mq series order, guarded patches (issue2849) Patrick Mezard <patrick@mezard.eu> parents: 16280 diff changeset	884 # order, applied and removed or unapplied. Discard the removed
b9f51f49bf2a rebase: preserve mq series order, guarded patches (issue2849) Patrick Mezard <patrick@mezard.eu> parents: 16280 diff changeset	885 # ones while preserving the original series order and guards.
b9f51f49bf2a rebase: preserve mq series order, guarded patches (issue2849) Patrick Mezard <patrick@mezard.eu> parents: 16280 diff changeset	886 newseries = [s for s in original_series
b9f51f49bf2a rebase: preserve mq series order, guarded patches (issue2849) Patrick Mezard <patrick@mezard.eu> parents: 16280 diff changeset	887 if mq.guard_re.split(s, 1)[0] not in skippedpatches]
b9f51f49bf2a rebase: preserve mq series order, guarded patches (issue2849) Patrick Mezard <patrick@mezard.eu> parents: 16280 diff changeset	888 mq.fullseries[:] = newseries
b9f51f49bf2a rebase: preserve mq series order, guarded patches (issue2849) Patrick Mezard <patrick@mezard.eu> parents: 16280 diff changeset	889 mq.seriesdirty = True
14580 92101ea35015 mq: rename save_dirty to savedirty Adrian Buehlmann <adrian@cadifra.com> parents: 14572 diff changeset	890 mq.savedirty()
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	891
27059 405320cd6198 rebase: use bookmarks.recordchange instead of bookmarks.write Laurent Charignon <lcharignon@fb.com> parents: 27058 diff changeset	892 def updatebookmarks(repo, targetnode, nstate, originalbookmarks, tr):
18514 2a1fac3650a5 rebase: delete divergent bookmarks on destination (issue3685) Siddharth Agarwal <sid0@fb.com> parents: 18512 diff changeset	893 'Move bookmarks to their correct changesets, and delete divergent ones'
17922 7f5dab94e48c bookmarks: introduce a bmstore to manage bookmark persistence Augie Fackler <raf@durin42.com> parents: 17615 diff changeset	894 marks = repo._bookmarks
14884 c0ccd70df52c rebase: reset bookmarks (issue2265 and issue2873) Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 14635 diff changeset	895 for k, v in originalbookmarks.iteritems():
c0ccd70df52c rebase: reset bookmarks (issue2265 and issue2873) Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 14635 diff changeset	896 if v in nstate:
18512 22978b82ab4b rebase: remove bogus nullmerge check in updatebookmarks Siddharth Agarwal <sid0@fb.com> parents: 18447 diff changeset	897 # update the bookmarks for revs that have moved
22978b82ab4b rebase: remove bogus nullmerge check in updatebookmarks Siddharth Agarwal <sid0@fb.com> parents: 18447 diff changeset	898 marks[k] = nstate[v]
18549 12de53323e59 rebase: derive node from target rev (issue3802) Siddharth Agarwal <sid0@fb.com> parents: 18518 diff changeset	899 bookmarks.deletedivergent(repo, [targetnode], k)
27059 405320cd6198 rebase: use bookmarks.recordchange instead of bookmarks.write Laurent Charignon <lcharignon@fb.com> parents: 27058 diff changeset	900 marks.recordchange(tr)
14884 c0ccd70df52c rebase: reset bookmarks (issue2265 and issue2873) Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 14635 diff changeset	901
28185 c7e8948627f3 rebase: adds storing collapse message (issue4792) liscju <piotr.listkiewicz@gmail.com> parents: 28136 diff changeset	902 def storecollapsemsg(repo, collapsemsg):
c7e8948627f3 rebase: adds storing collapse message (issue4792) liscju <piotr.listkiewicz@gmail.com> parents: 28136 diff changeset	903 'Store the collapse message to allow recovery'
c7e8948627f3 rebase: adds storing collapse message (issue4792) liscju <piotr.listkiewicz@gmail.com> parents: 28136 diff changeset	904 collapsemsg = collapsemsg or ''
c7e8948627f3 rebase: adds storing collapse message (issue4792) liscju <piotr.listkiewicz@gmail.com> parents: 28136 diff changeset	905 f = repo.vfs("last-message.txt", "w")
c7e8948627f3 rebase: adds storing collapse message (issue4792) liscju <piotr.listkiewicz@gmail.com> parents: 28136 diff changeset	906 f.write("%s\n" % collapsemsg)
c7e8948627f3 rebase: adds storing collapse message (issue4792) liscju <piotr.listkiewicz@gmail.com> parents: 28136 diff changeset	907 f.close()
c7e8948627f3 rebase: adds storing collapse message (issue4792) liscju <piotr.listkiewicz@gmail.com> parents: 28136 diff changeset	908
c7e8948627f3 rebase: adds storing collapse message (issue4792) liscju <piotr.listkiewicz@gmail.com> parents: 28136 diff changeset	909 def clearcollapsemsg(repo):
c7e8948627f3 rebase: adds storing collapse message (issue4792) liscju <piotr.listkiewicz@gmail.com> parents: 28136 diff changeset	910 'Remove collapse message file'
c7e8948627f3 rebase: adds storing collapse message (issue4792) liscju <piotr.listkiewicz@gmail.com> parents: 28136 diff changeset	911 util.unlinkpath(repo.join("last-message.txt"), ignoremissing=True)
c7e8948627f3 rebase: adds storing collapse message (issue4792) liscju <piotr.listkiewicz@gmail.com> parents: 28136 diff changeset	912
c7e8948627f3 rebase: adds storing collapse message (issue4792) liscju <piotr.listkiewicz@gmail.com> parents: 28136 diff changeset	913 def restorecollapsemsg(repo):
c7e8948627f3 rebase: adds storing collapse message (issue4792) liscju <piotr.listkiewicz@gmail.com> parents: 28136 diff changeset	914 'Restore previously stored collapse message'
c7e8948627f3 rebase: adds storing collapse message (issue4792) liscju <piotr.listkiewicz@gmail.com> parents: 28136 diff changeset	915 try:
c7e8948627f3 rebase: adds storing collapse message (issue4792) liscju <piotr.listkiewicz@gmail.com> parents: 28136 diff changeset	916 f = repo.vfs("last-message.txt")
c7e8948627f3 rebase: adds storing collapse message (issue4792) liscju <piotr.listkiewicz@gmail.com> parents: 28136 diff changeset	917 collapsemsg = f.readline().strip()
c7e8948627f3 rebase: adds storing collapse message (issue4792) liscju <piotr.listkiewicz@gmail.com> parents: 28136 diff changeset	918 f.close()
c7e8948627f3 rebase: adds storing collapse message (issue4792) liscju <piotr.listkiewicz@gmail.com> parents: 28136 diff changeset	919 except IOError as err:
c7e8948627f3 rebase: adds storing collapse message (issue4792) liscju <piotr.listkiewicz@gmail.com> parents: 28136 diff changeset	920 if err.errno != errno.ENOENT:
c7e8948627f3 rebase: adds storing collapse message (issue4792) liscju <piotr.listkiewicz@gmail.com> parents: 28136 diff changeset	921 raise
c7e8948627f3 rebase: adds storing collapse message (issue4792) liscju <piotr.listkiewicz@gmail.com> parents: 28136 diff changeset	922 raise error.Abort(_('no rebase in progress'))
c7e8948627f3 rebase: adds storing collapse message (issue4792) liscju <piotr.listkiewicz@gmail.com> parents: 28136 diff changeset	923 return collapsemsg
c7e8948627f3 rebase: adds storing collapse message (issue4792) liscju <piotr.listkiewicz@gmail.com> parents: 28136 diff changeset	924
7952 b214066b7e1d rebase: store/restore arguments correctly Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 7951 diff changeset	925 def storestatus(repo, originalwd, target, state, collapse, keep, keepbranches,
18755 72412afe4c28 rebase: restore active bookmark after rebase --continue Durham Goode <durham@fb.com> parents: 18549 diff changeset	926 external, activebookmark):
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	927 'Store the current status to allow recovery'
23877 7cc77030c557 localrepo: remove all external users of localrepo.opener Angel Ezquerra <angel.ezquerra@gmail.com> parents: 23732 diff changeset	928 f = repo.vfs("rebasestate", "w")
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	929 f.write(repo[originalwd].hex() + '\n')
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	930 f.write(repo[target].hex() + '\n')
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	931 f.write(repo[external].hex() + '\n')
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	932 f.write('%d\n' % int(collapse))
7952 b214066b7e1d rebase: store/restore arguments correctly Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 7951 diff changeset	933 f.write('%d\n' % int(keep))
b214066b7e1d rebase: store/restore arguments correctly Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 7951 diff changeset	934 f.write('%d\n' % int(keepbranches))
18755 72412afe4c28 rebase: restore active bookmark after rebase --continue Durham Goode <durham@fb.com> parents: 18549 diff changeset	935 f.write('%s\n' % (activebookmark or ''))
7622 4dd7b28003d2 use dict.iteritems() rather than dict.items() Dirkjan Ochtman <dirkjan@ochtman.nl> parents: 7599 diff changeset	936 for d, v in state.iteritems():
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	937 oldrev = repo[d].hex()
23491 9972758ab4c5 rebase: handle revtodo as a special value when storing/restoring state Pierre-Yves David <pierre-yves.david@fb.com> parents: 23490 diff changeset	938 if v >= 0:
15464 3411a83e232a rebase: treat nullmerge as a special case in rebasestate (issue3046) Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 15289 diff changeset	939 newrev = repo[v].hex()
23491 9972758ab4c5 rebase: handle revtodo as a special value when storing/restoring state Pierre-Yves David <pierre-yves.david@fb.com> parents: 23490 diff changeset	940 elif v == revtodo:
9972758ab4c5 rebase: handle revtodo as a special value when storing/restoring state Pierre-Yves David <pierre-yves.david@fb.com> parents: 23490 diff changeset	941 # To maintain format compatibility, we have to use nullid.
9972758ab4c5 rebase: handle revtodo as a special value when storing/restoring state Pierre-Yves David <pierre-yves.david@fb.com> parents: 23490 diff changeset	942 # Please do remove this special case when upgrading the format.
9972758ab4c5 rebase: handle revtodo as a special value when storing/restoring state Pierre-Yves David <pierre-yves.david@fb.com> parents: 23490 diff changeset	943 newrev = hex(nullid)
15464 3411a83e232a rebase: treat nullmerge as a special case in rebasestate (issue3046) Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 15289 diff changeset	944 else:
3411a83e232a rebase: treat nullmerge as a special case in rebasestate (issue3046) Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 15289 diff changeset	945 newrev = v
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	946 f.write("%s:%s\n" % (oldrev, newrev))
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	947 f.close()
9467 4c041f1ee1b4 do not attempt to translate ui.debug output Martin Geisler <mg@lazybytes.net> parents: 9301 diff changeset	948 repo.ui.debug('rebase status stored\n')
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	949
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	950 def clearstatus(repo):
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	951 'Remove the status files'
23970 8a544fb645bb rebase: ensure rebase revision remains visible (issue4504) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23917 diff changeset	952 _clearrebasesetvisibiliy(repo)
18386 03442135dff4 refactoring: use unlinkpath with ignoremissing Mads Kiilerich <madski@unity3d.com> parents: 18269 diff changeset	953 util.unlinkpath(repo.join("rebasestate"), ignoremissing=True)
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	954
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	955 def restorestatus(repo):
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	956 'Restore a previously stored status'
26745 8af610bce239 rebase: reduce scope of try catch in restorestate Christian Delahousse <cdelahousse@fb.com> parents: 26744 diff changeset	957 keepbranches = None
8af610bce239 rebase: reduce scope of try catch in restorestate Christian Delahousse <cdelahousse@fb.com> parents: 26744 diff changeset	958 target = None
8af610bce239 rebase: reduce scope of try catch in restorestate Christian Delahousse <cdelahousse@fb.com> parents: 26744 diff changeset	959 collapse = False
8af610bce239 rebase: reduce scope of try catch in restorestate Christian Delahousse <cdelahousse@fb.com> parents: 26744 diff changeset	960 external = nullrev
8af610bce239 rebase: reduce scope of try catch in restorestate Christian Delahousse <cdelahousse@fb.com> parents: 26744 diff changeset	961 activebookmark = None
8af610bce239 rebase: reduce scope of try catch in restorestate Christian Delahousse <cdelahousse@fb.com> parents: 26744 diff changeset	962 state = {}
8af610bce239 rebase: reduce scope of try catch in restorestate Christian Delahousse <cdelahousse@fb.com> parents: 26744 diff changeset	963
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	964 try:
23877 7cc77030c557 localrepo: remove all external users of localrepo.opener Angel Ezquerra <angel.ezquerra@gmail.com> parents: 23732 diff changeset	965 f = repo.vfs("rebasestate")
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	966 for i, l in enumerate(f.read().splitlines()):
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	967 if i == 0:
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	968 originalwd = repo[l].rev()
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	969 elif i == 1:
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	970 target = repo[l].rev()
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	971 elif i == 2:
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	972 external = repo[l].rev()
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	973 elif i == 3:
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	974 collapse = bool(int(l))
7952 b214066b7e1d rebase: store/restore arguments correctly Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 7951 diff changeset	975 elif i == 4:
b214066b7e1d rebase: store/restore arguments correctly Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 7951 diff changeset	976 keep = bool(int(l))
b214066b7e1d rebase: store/restore arguments correctly Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 7951 diff changeset	977 elif i == 5:
b214066b7e1d rebase: store/restore arguments correctly Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 7951 diff changeset	978 keepbranches = bool(int(l))
18755 72412afe4c28 rebase: restore active bookmark after rebase --continue Durham Goode <durham@fb.com> parents: 18549 diff changeset	979 elif i == 6 and not (len(l) == 81 and ':' in l):
72412afe4c28 rebase: restore active bookmark after rebase --continue Durham Goode <durham@fb.com> parents: 18549 diff changeset	980 # line 6 is a recent addition, so for backwards compatibility
72412afe4c28 rebase: restore active bookmark after rebase --continue Durham Goode <durham@fb.com> parents: 18549 diff changeset	981 # check that the line doesn't look like the oldrev:newrev lines
72412afe4c28 rebase: restore active bookmark after rebase --continue Durham Goode <durham@fb.com> parents: 18549 diff changeset	982 activebookmark = l
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	983 else:
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	984 oldrev, newrev = l.split(':')
26349 92409f8dff5d rebase: don't rebase obsolete commit whose successor is already rebased Laurent Charignon <lcharignon@fb.com> parents: 26301 diff changeset	985 if newrev in (str(nullmerge), str(revignored),
27012 5eac7ab59b95 rebase: don't rebase obsolete commits with no successor Laurent Charignon <lcharignon@fb.com> parents: 27010 diff changeset	986 str(revprecursor), str(revpruned)):
18447 7159426c8d13 rebase: properly handle unrebased revision between rebased one Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18446 diff changeset	987 state[repo[oldrev].rev()] = int(newrev)
23491 9972758ab4c5 rebase: handle revtodo as a special value when storing/restoring state Pierre-Yves David <pierre-yves.david@fb.com> parents: 23490 diff changeset	988 elif newrev == nullid:
9972758ab4c5 rebase: handle revtodo as a special value when storing/restoring state Pierre-Yves David <pierre-yves.david@fb.com> parents: 23490 diff changeset	989 state[repo[oldrev].rev()] = revtodo
9972758ab4c5 rebase: handle revtodo as a special value when storing/restoring state Pierre-Yves David <pierre-yves.david@fb.com> parents: 23490 diff changeset	990 # Legacy compat special case
18447 7159426c8d13 rebase: properly handle unrebased revision between rebased one Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18446 diff changeset	991 else:
15464 3411a83e232a rebase: treat nullmerge as a special case in rebasestate (issue3046) Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: 15289 diff changeset	992 state[repo[oldrev].rev()] = repo[newrev].rev()
20327 46c2331fc750 rebase: abort cleanly when we encounter a damaged rebasestate (issue4155) Matt Mackall <mpm@selenic.com> parents: 20313 diff changeset	993
25660 328739ea70c3 global: mass rewrite to use modern exception syntax Gregory Szorc <gregory.szorc@gmail.com> parents: 25411 diff changeset	994 except IOError as err:
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	995 if err.errno != errno.ENOENT:
808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	996 raise
28122 6025ddb4e649 rebase: suggest the correct tool to continue (not rebase) timeless <timeless@mozdev.org> parents: 28118 diff changeset	997 cmdutil.wrongtooltocontinue(repo, _('rebase'))
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	998
26745 8af610bce239 rebase: reduce scope of try catch in restorestate Christian Delahousse <cdelahousse@fb.com> parents: 26744 diff changeset	999 if keepbranches is None:
8af610bce239 rebase: reduce scope of try catch in restorestate Christian Delahousse <cdelahousse@fb.com> parents: 26744 diff changeset	1000 raise error.Abort(_('.hg/rebasestate is incomplete'))
8af610bce239 rebase: reduce scope of try catch in restorestate Christian Delahousse <cdelahousse@fb.com> parents: 26744 diff changeset	1001
8af610bce239 rebase: reduce scope of try catch in restorestate Christian Delahousse <cdelahousse@fb.com> parents: 26744 diff changeset	1002 skipped = set()
8af610bce239 rebase: reduce scope of try catch in restorestate Christian Delahousse <cdelahousse@fb.com> parents: 26744 diff changeset	1003 # recompute the set of skipped revs
8af610bce239 rebase: reduce scope of try catch in restorestate Christian Delahousse <cdelahousse@fb.com> parents: 26744 diff changeset	1004 if not collapse:
8af610bce239 rebase: reduce scope of try catch in restorestate Christian Delahousse <cdelahousse@fb.com> parents: 26744 diff changeset	1005 seen = set([target])
8af610bce239 rebase: reduce scope of try catch in restorestate Christian Delahousse <cdelahousse@fb.com> parents: 26744 diff changeset	1006 for old, new in sorted(state.items()):
8af610bce239 rebase: reduce scope of try catch in restorestate Christian Delahousse <cdelahousse@fb.com> parents: 26744 diff changeset	1007 if new != revtodo and new in seen:
8af610bce239 rebase: reduce scope of try catch in restorestate Christian Delahousse <cdelahousse@fb.com> parents: 26744 diff changeset	1008 skipped.add(old)
8af610bce239 rebase: reduce scope of try catch in restorestate Christian Delahousse <cdelahousse@fb.com> parents: 26744 diff changeset	1009 seen.add(new)
8af610bce239 rebase: reduce scope of try catch in restorestate Christian Delahousse <cdelahousse@fb.com> parents: 26744 diff changeset	1010 repo.ui.debug('computed skipped revs: %s\n' %
8af610bce239 rebase: reduce scope of try catch in restorestate Christian Delahousse <cdelahousse@fb.com> parents: 26744 diff changeset	1011 (' '.join(str(r) for r in sorted(skipped)) or None))
8af610bce239 rebase: reduce scope of try catch in restorestate Christian Delahousse <cdelahousse@fb.com> parents: 26744 diff changeset	1012 repo.ui.debug('rebase status resumed\n')
8af610bce239 rebase: reduce scope of try catch in restorestate Christian Delahousse <cdelahousse@fb.com> parents: 26744 diff changeset	1013 _setrebasesetvisibility(repo, state.keys())
8af610bce239 rebase: reduce scope of try catch in restorestate Christian Delahousse <cdelahousse@fb.com> parents: 26744 diff changeset	1014 return (originalwd, target, state, skipped,
8af610bce239 rebase: reduce scope of try catch in restorestate Christian Delahousse <cdelahousse@fb.com> parents: 26744 diff changeset	1015 collapse, keep, keepbranches, external, activebookmark)
8af610bce239 rebase: reduce scope of try catch in restorestate Christian Delahousse <cdelahousse@fb.com> parents: 26744 diff changeset	1016
25070 bd98d073a34f rebase: clear merge when aborting before any rebasing (issue4661) Jordi Guti?rrez Hermoso <jordigh@octave.org> parents: 24870 diff changeset	1017 def needupdate(repo, state):
bd98d073a34f rebase: clear merge when aborting before any rebasing (issue4661) Jordi Guti?rrez Hermoso <jordigh@octave.org> parents: 24870 diff changeset	1018 '''check whether we should `update --clean` away from a merge, or if
bd98d073a34f rebase: clear merge when aborting before any rebasing (issue4661) Jordi Guti?rrez Hermoso <jordigh@octave.org> parents: 24870 diff changeset	1019 somehow the working dir got forcibly updated, e.g. by older hg'''
27167 3fe8cb40c9c5 commands: inline definition of localrepo.parents() and drop the method (API) Augie Fackler <augie@google.com> parents: 27146 diff changeset	1020 parents = [p.rev() for p in repo[None].parents()]
25070 bd98d073a34f rebase: clear merge when aborting before any rebasing (issue4661) Jordi Guti?rrez Hermoso <jordigh@octave.org> parents: 24870 diff changeset	1021
bd98d073a34f rebase: clear merge when aborting before any rebasing (issue4661) Jordi Guti?rrez Hermoso <jordigh@octave.org> parents: 24870 diff changeset	1022 # Are we in a merge state at all?
bd98d073a34f rebase: clear merge when aborting before any rebasing (issue4661) Jordi Guti?rrez Hermoso <jordigh@octave.org> parents: 24870 diff changeset	1023 if len(parents) < 2:
bd98d073a34f rebase: clear merge when aborting before any rebasing (issue4661) Jordi Guti?rrez Hermoso <jordigh@octave.org> parents: 24870 diff changeset	1024 return False
bd98d073a34f rebase: clear merge when aborting before any rebasing (issue4661) Jordi Guti?rrez Hermoso <jordigh@octave.org> parents: 24870 diff changeset	1025
bd98d073a34f rebase: clear merge when aborting before any rebasing (issue4661) Jordi Guti?rrez Hermoso <jordigh@octave.org> parents: 24870 diff changeset	1026 # We should be standing on the first as-of-yet unrebased commit.
bd98d073a34f rebase: clear merge when aborting before any rebasing (issue4661) Jordi Guti?rrez Hermoso <jordigh@octave.org> parents: 24870 diff changeset	1027 firstunrebased = min([old for old, new in state.iteritems()
bd98d073a34f rebase: clear merge when aborting before any rebasing (issue4661) Jordi Guti?rrez Hermoso <jordigh@octave.org> parents: 24870 diff changeset	1028 if new == nullrev])
bd98d073a34f rebase: clear merge when aborting before any rebasing (issue4661) Jordi Guti?rrez Hermoso <jordigh@octave.org> parents: 24870 diff changeset	1029 if firstunrebased in parents:
19516 fe78eb7bcca0 rebase: don't clobber wd on --abort when we've updated away (issue4009) Matt Mackall <mpm@selenic.com> parents: 19496 diff changeset	1030 return True
fe78eb7bcca0 rebase: don't clobber wd on --abort when we've updated away (issue4009) Matt Mackall <mpm@selenic.com> parents: 19496 diff changeset	1031
fe78eb7bcca0 rebase: don't clobber wd on --abort when we've updated away (issue4009) Matt Mackall <mpm@selenic.com> parents: 19496 diff changeset	1032 return False
fe78eb7bcca0 rebase: don't clobber wd on --abort when we've updated away (issue4009) Matt Mackall <mpm@selenic.com> parents: 19496 diff changeset	1033
24758 d7451adc72f6 rebase: restore bookmark state on abort Tony Tung <tonytung@fb.com> parents: 23970 diff changeset	1034 def abort(repo, originalwd, target, state, activebookmark=None):
d7451adc72f6 rebase: restore bookmark state on abort Tony Tung <tonytung@fb.com> parents: 23970 diff changeset	1035 '''Restore the repository to its original state. Additional args:
d7451adc72f6 rebase: restore bookmark state on abort Tony Tung <tonytung@fb.com> parents: 23970 diff changeset	1036
d7451adc72f6 rebase: restore bookmark state on abort Tony Tung <tonytung@fb.com> parents: 23970 diff changeset	1037 activebookmark: the name of the bookmark that should be active after the
d7451adc72f6 rebase: restore bookmark state on abort Tony Tung <tonytung@fb.com> parents: 23970 diff changeset	1038 restore'''
26677 e9b3d523f2e6 rebase: properly abort when destination is public (issue4896) Christian Delahousse <cdelahousse@fb.com> parents: 26675 diff changeset	1039
26744 21e50e36de02 rebase: on abort delete rebase state file no matter what Christian Delahousse <cdelahousse@fb.com> parents: 26719 diff changeset	1040 try:
21e50e36de02 rebase: on abort delete rebase state file no matter what Christian Delahousse <cdelahousse@fb.com> parents: 26719 diff changeset	1041 # If the first commits in the rebased set get skipped during the rebase,
21e50e36de02 rebase: on abort delete rebase state file no matter what Christian Delahousse <cdelahousse@fb.com> parents: 26719 diff changeset	1042 # their values within the state mapping will be the target rev id. The
21e50e36de02 rebase: on abort delete rebase state file no matter what Christian Delahousse <cdelahousse@fb.com> parents: 26719 diff changeset	1043 # dstates list must must not contain the target rev (issue4896)
21e50e36de02 rebase: on abort delete rebase state file no matter what Christian Delahousse <cdelahousse@fb.com> parents: 26719 diff changeset	1044 dstates = [s for s in state.values() if s >= 0 and s != target]
21e50e36de02 rebase: on abort delete rebase state file no matter what Christian Delahousse <cdelahousse@fb.com> parents: 26719 diff changeset	1045 immutable = [d for d in dstates if not repo[d].mutable()]
21e50e36de02 rebase: on abort delete rebase state file no matter what Christian Delahousse <cdelahousse@fb.com> parents: 26719 diff changeset	1046 cleanup = True
21e50e36de02 rebase: on abort delete rebase state file no matter what Christian Delahousse <cdelahousse@fb.com> parents: 26719 diff changeset	1047 if immutable:
21e50e36de02 rebase: on abort delete rebase state file no matter what Christian Delahousse <cdelahousse@fb.com> parents: 26719 diff changeset	1048 repo.ui.warn(_("warning: can't clean up public changesets %s\n")
21e50e36de02 rebase: on abort delete rebase state file no matter what Christian Delahousse <cdelahousse@fb.com> parents: 26719 diff changeset	1049 % ', '.join(str(repo[r]) for r in immutable),
21e50e36de02 rebase: on abort delete rebase state file no matter what Christian Delahousse <cdelahousse@fb.com> parents: 26719 diff changeset	1050 hint=_('see "hg help phases" for details'))
21e50e36de02 rebase: on abort delete rebase state file no matter what Christian Delahousse <cdelahousse@fb.com> parents: 26719 diff changeset	1051 cleanup = False
16280 0806823370d8 rebase: properly calculate descendant set when aborting (issue3332) Matt Mackall <mpm@selenic.com> parents: 16228 diff changeset	1052
26744 21e50e36de02 rebase: on abort delete rebase state file no matter what Christian Delahousse <cdelahousse@fb.com> parents: 26719 diff changeset	1053 descendants = set()
21e50e36de02 rebase: on abort delete rebase state file no matter what Christian Delahousse <cdelahousse@fb.com> parents: 26719 diff changeset	1054 if dstates:
21e50e36de02 rebase: on abort delete rebase state file no matter what Christian Delahousse <cdelahousse@fb.com> parents: 26719 diff changeset	1055 descendants = set(repo.changelog.descendants(dstates))
21e50e36de02 rebase: on abort delete rebase state file no matter what Christian Delahousse <cdelahousse@fb.com> parents: 26719 diff changeset	1056 if descendants - set(dstates):
21e50e36de02 rebase: on abort delete rebase state file no matter what Christian Delahousse <cdelahousse@fb.com> parents: 26719 diff changeset	1057 repo.ui.warn(_("warning: new changesets detected on target branch, "
21e50e36de02 rebase: on abort delete rebase state file no matter what Christian Delahousse <cdelahousse@fb.com> parents: 26719 diff changeset	1058 "can't strip\n"))
21e50e36de02 rebase: on abort delete rebase state file no matter what Christian Delahousse <cdelahousse@fb.com> parents: 26719 diff changeset	1059 cleanup = False
19518 12843143663d rebase: allow aborting when descendants detected Matt Mackall <mpm@selenic.com> parents: 19517 diff changeset	1060
26744 21e50e36de02 rebase: on abort delete rebase state file no matter what Christian Delahousse <cdelahousse@fb.com> parents: 26719 diff changeset	1061 if cleanup:
27988 61f4d59e9a0b rebase: update working directory when aborting (issue5084) timeless <timeless@mozdev.org> parents: 27977 diff changeset	1062 shouldupdate = False
61f4d59e9a0b rebase: update working directory when aborting (issue5084) timeless <timeless@mozdev.org> parents: 27977 diff changeset	1063 rebased = filter(lambda x: x >= 0 and x != target, state.values())
61f4d59e9a0b rebase: update working directory when aborting (issue5084) timeless <timeless@mozdev.org> parents: 27977 diff changeset	1064 if rebased:
61f4d59e9a0b rebase: update working directory when aborting (issue5084) timeless <timeless@mozdev.org> parents: 27977 diff changeset	1065 strippoints = [
61f4d59e9a0b rebase: update working directory when aborting (issue5084) timeless <timeless@mozdev.org> parents: 27977 diff changeset	1066 c.node() for c in repo.set('roots(%ld)', rebased)]
61f4d59e9a0b rebase: update working directory when aborting (issue5084) timeless <timeless@mozdev.org> parents: 27977 diff changeset	1067 shouldupdate = len([
61f4d59e9a0b rebase: update working directory when aborting (issue5084) timeless <timeless@mozdev.org> parents: 27977 diff changeset	1068 c.node() for c in repo.set('. & (%ld)', rebased)]) > 0
61f4d59e9a0b rebase: update working directory when aborting (issue5084) timeless <timeless@mozdev.org> parents: 27977 diff changeset	1069
26744 21e50e36de02 rebase: on abort delete rebase state file no matter what Christian Delahousse <cdelahousse@fb.com> parents: 26719 diff changeset	1070 # Update away from the rebase if necessary
27988 61f4d59e9a0b rebase: update working directory when aborting (issue5084) timeless <timeless@mozdev.org> parents: 27977 diff changeset	1071 if shouldupdate or needupdate(repo, state):
27344 43c00ca887d1 merge: have merge.update use a matcher instead of partial fn Augie Fackler <augie@google.com> parents: 27261 diff changeset	1072 merge.update(repo, originalwd, False, True)
19516 fe78eb7bcca0 rebase: don't clobber wd on --abort when we've updated away (issue4009) Matt Mackall <mpm@selenic.com> parents: 19496 diff changeset	1073
26744 21e50e36de02 rebase: on abort delete rebase state file no matter what Christian Delahousse <cdelahousse@fb.com> parents: 26719 diff changeset	1074 # Strip from the first rebased revision
21e50e36de02 rebase: on abort delete rebase state file no matter what Christian Delahousse <cdelahousse@fb.com> parents: 26719 diff changeset	1075 if rebased:
21e50e36de02 rebase: on abort delete rebase state file no matter what Christian Delahousse <cdelahousse@fb.com> parents: 26719 diff changeset	1076 # no backup of rebased cset versions needed
21e50e36de02 rebase: on abort delete rebase state file no matter what Christian Delahousse <cdelahousse@fb.com> parents: 26719 diff changeset	1077 repair.strip(repo.ui, repo, strippoints)
19518 12843143663d rebase: allow aborting when descendants detected Matt Mackall <mpm@selenic.com> parents: 19517 diff changeset	1078
26744 21e50e36de02 rebase: on abort delete rebase state file no matter what Christian Delahousse <cdelahousse@fb.com> parents: 26719 diff changeset	1079 if activebookmark and activebookmark in repo._bookmarks:
21e50e36de02 rebase: on abort delete rebase state file no matter what Christian Delahousse <cdelahousse@fb.com> parents: 26719 diff changeset	1080 bookmarks.activate(repo, activebookmark)
24758 d7451adc72f6 rebase: restore bookmark state on abort Tony Tung <tonytung@fb.com> parents: 23970 diff changeset	1081
26744 21e50e36de02 rebase: on abort delete rebase state file no matter what Christian Delahousse <cdelahousse@fb.com> parents: 26719 diff changeset	1082 finally:
21e50e36de02 rebase: on abort delete rebase state file no matter what Christian Delahousse <cdelahousse@fb.com> parents: 26719 diff changeset	1083 clearstatus(repo)
28185 c7e8948627f3 rebase: adds storing collapse message (issue4792) liscju <piotr.listkiewicz@gmail.com> parents: 28136 diff changeset	1084 clearcollapsemsg(repo)
26744 21e50e36de02 rebase: on abort delete rebase state file no matter what Christian Delahousse <cdelahousse@fb.com> parents: 26719 diff changeset	1085 repo.ui.warn(_('rebase aborted\n'))
19518 12843143663d rebase: allow aborting when descendants detected Matt Mackall <mpm@selenic.com> parents: 19517 diff changeset	1086 return 0
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	1087
26349 92409f8dff5d rebase: don't rebase obsolete commit whose successor is already rebased Laurent Charignon <lcharignon@fb.com> parents: 26301 diff changeset	1088 def buildstate(repo, dest, rebaseset, collapse, obsoletenotrebased):
15267 3bfdfefea2fc rebase: use revset as soon as possible in internal logic Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15219 diff changeset	1089 '''Define which revisions are going to be rebased and where
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	1090
15267 3bfdfefea2fc rebase: use revset as soon as possible in internal logic Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15219 diff changeset	1091 repo: repo
3bfdfefea2fc rebase: use revset as soon as possible in internal logic Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15219 diff changeset	1092 dest: context
3bfdfefea2fc rebase: use revset as soon as possible in internal logic Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15219 diff changeset	1093 rebaseset: set of rev
17005 50f434510da6 rebase: do not add second parent to rebased changeset (drop detach option) (BC) Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 16867 diff changeset	1094 '''
23970 8a544fb645bb rebase: ensure rebase revision remains visible (issue4504) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23917 diff changeset	1095 _setrebasesetvisibility(repo, rebaseset)
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	1096
10672 c2e1e637d4da rebase: always check if rebasing onto an applied mq patch. Greg Ward <greg-hg@gerg.ca> parents: 10659 diff changeset	1097 # This check isn't strictly necessary, since mq detects commits over an
c2e1e637d4da rebase: always check if rebasing onto an applied mq patch. Greg Ward <greg-hg@gerg.ca> parents: 10659 diff changeset	1098 # applied patch. But it prevents messing up the working directory when
c2e1e637d4da rebase: always check if rebasing onto an applied mq patch. Greg Ward <greg-hg@gerg.ca> parents: 10659 diff changeset	1099 # a partially completed rebase is blocked by mq.
15267 3bfdfefea2fc rebase: use revset as soon as possible in internal logic Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15219 diff changeset	1100 if 'qtip' in repo.tags() and (dest.node() in
10678 da2a0c9c895d mq: avoid many hex/bin conversions, keep the binary node when possible Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 10677 diff changeset	1101 [s.node for s in repo.mq.applied]):
26587 56b2bcea2529 error: get Abort from 'error' instead of 'util' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26496 diff changeset	1102 raise error.Abort(_('cannot rebase onto an applied mq patch'))
10672 c2e1e637d4da rebase: always check if rebasing onto an applied mq patch. Greg Ward <greg-hg@gerg.ca> parents: 10659 diff changeset	1103
15267 3bfdfefea2fc rebase: use revset as soon as possible in internal logic Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15219 diff changeset	1104 roots = list(repo.set('roots(%ld)', rebaseset))
3bfdfefea2fc rebase: use revset as soon as possible in internal logic Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15219 diff changeset	1105 if not roots:
26587 56b2bcea2529 error: get Abort from 'error' instead of 'util' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26496 diff changeset	1106 raise error.Abort(_('no matching revisions'))
18424 100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1107 roots.sort()
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1108 state = {}
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1109 detachset = set()
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1110 for root in roots:
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1111 commonbase = root.ancestor(dest)
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1112 if commonbase == root:
26587 56b2bcea2529 error: get Abort from 'error' instead of 'util' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26496 diff changeset	1113 raise error.Abort(_('source is ancestor of destination'))
18424 100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1114 if commonbase == dest:
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1115 samebranch = root.branch() == dest.branch()
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1116 if not collapse and samebranch and root in dest.children():
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1117 repo.ui.debug('source is a child of destination\n')
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1118 return None
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	1119
20545 5936058f6bad rebase: fix 'rebase onto %d starting from %s' - show root instead of list repr Mads Kiilerich <madski@unity3d.com> parents: 20523 diff changeset	1120 repo.ui.debug('rebase onto %d starting from %s\n' % (dest, root))
23490 102f144f6e02 rebase: add a 'revtodo' constant Pierre-Yves David <pierre-yves.david@fb.com> parents: 23489 diff changeset	1121 state.update(dict.fromkeys(rebaseset, revtodo))
18424 100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1122 # Rebase tries to turn <dest> into a parent of <root> while
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1123 # preserving the number of parents of rebased changesets:
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1124 #
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1125 # - A changeset with a single parent will always be rebased as a
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1126 # changeset with a single parent.
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1127 #
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1128 # - A merge will be rebased as merge unless its parents are both
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1129 # ancestors of <dest> or are themselves in the rebased set and
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1130 # pruned while rebased.
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1131 #
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1132 # If one parent of <root> is an ancestor of <dest>, the rebased
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1133 # version of this parent will be <dest>. This is always true with
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1134 # --base option.
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1135 #
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1136 # Otherwise, we need to replace the original parents with
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1137 # <dest>. This "detaches" the rebased set from its former location
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1138 # and rebases it onto <dest>. Changes introduced by ancestors of
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1139 # <root> not common with <dest> (the detachset, marked as
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1140 # nullmerge) are "removed" from the rebased changesets.
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1141 #
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1142 # - If <root> has a single parent, set it to <dest>.
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1143 #
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1144 # - If <root> is a merge, we cannot decide which parent to
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1145 # replace, the rebase operation is not clearly defined.
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1146 #
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1147 # The table below sums up this behavior:
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1148 #
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1149 # +------------------+----------------------+-------------------------+
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1150 # \| \| one parent \| merge \|
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1151 # +------------------+----------------------+-------------------------+
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1152 # \| parent in \| new parent is <dest> \| parents in ::<dest> are \|
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1153 # \| ::<dest> \| \| remapped to <dest> \|
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1154 # +------------------+----------------------+-------------------------+
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1155 # \| unrelated source \| new parent is <dest> \| ambiguous, abort \|
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1156 # +------------------+----------------------+-------------------------+
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1157 #
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1158 # The actual abort is handled by `defineparents`
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1159 if len(root.parents()) <= 1:
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1160 # ancestors of <root> not ancestors of <dest>
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1161 detachset.update(repo.changelog.findmissingrevs([commonbase.rev()],
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1162 [root.rev()]))
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1163 for r in detachset:
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1164 if r not in state:
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1165 state[r] = nullmerge
18447 7159426c8d13 rebase: properly handle unrebased revision between rebased one Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18446 diff changeset	1166 if len(roots) > 1:
7159426c8d13 rebase: properly handle unrebased revision between rebased one Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18446 diff changeset	1167 # If we have multiple roots, we may have "hole" in the rebase set.
7159426c8d13 rebase: properly handle unrebased revision between rebased one Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18446 diff changeset	1168 # Rebase roots that descend from those "hole" should not be detached as
7159426c8d13 rebase: properly handle unrebased revision between rebased one Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18446 diff changeset	1169 # other root are. We use the special `revignored` to inform rebase that
18644 3e92772d5383 spelling: fix some minor issues found by spell checker Mads Kiilerich <mads@kiilerich.com> parents: 18549 diff changeset	1170 # the revision should be ignored but that `defineparents` should search
3e92772d5383 spelling: fix some minor issues found by spell checker Mads Kiilerich <mads@kiilerich.com> parents: 18549 diff changeset	1171 # a rebase destination that make sense regarding rebased topology.
18447 7159426c8d13 rebase: properly handle unrebased revision between rebased one Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18446 diff changeset	1172 rebasedomain = set(repo.revs('%ld::%ld', rebaseset, rebaseset))
7159426c8d13 rebase: properly handle unrebased revision between rebased one Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18446 diff changeset	1173 for ignored in set(rebasedomain) - set(rebaseset):
7159426c8d13 rebase: properly handle unrebased revision between rebased one Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18446 diff changeset	1174 state[ignored] = revignored
26349 92409f8dff5d rebase: don't rebase obsolete commit whose successor is already rebased Laurent Charignon <lcharignon@fb.com> parents: 26301 diff changeset	1175 for r in obsoletenotrebased:
27012 5eac7ab59b95 rebase: don't rebase obsolete commits with no successor Laurent Charignon <lcharignon@fb.com> parents: 27010 diff changeset	1176 if obsoletenotrebased[r] is None:
5eac7ab59b95 rebase: don't rebase obsolete commits with no successor Laurent Charignon <lcharignon@fb.com> parents: 27010 diff changeset	1177 state[r] = revpruned
5eac7ab59b95 rebase: don't rebase obsolete commits with no successor Laurent Charignon <lcharignon@fb.com> parents: 27010 diff changeset	1178 else:
5eac7ab59b95 rebase: don't rebase obsolete commits with no successor Laurent Charignon <lcharignon@fb.com> parents: 27010 diff changeset	1179 state[r] = revprecursor
15267 3bfdfefea2fc rebase: use revset as soon as possible in internal logic Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15219 diff changeset	1180 return repo['.'].rev(), dest.rev(), state
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	1181
18444 55aff0c2b73c rebase: do not invent successor to skipped changeset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18424 diff changeset	1182 def clearrebased(ui, repo, state, skipped, collapsedas=None):
17613 aafc521668d8 rebase: properly handle --collapse when creating obsolescence marker Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 17612 diff changeset	1183 """dispose of rebased revision at the end of the rebase
aafc521668d8 rebase: properly handle --collapse when creating obsolescence marker Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 17612 diff changeset	1184
aafc521668d8 rebase: properly handle --collapse when creating obsolescence marker Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 17612 diff changeset	1185 If `collapsedas` is not None, the rebase was a collapse whose result if the
aafc521668d8 rebase: properly handle --collapse when creating obsolescence marker Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 17612 diff changeset	1186 `collapsedas` node."""
22951 6c86c673dde6 obsolete: add createmarkers option Durham Goode <durham@fb.com> parents: 22906 diff changeset	1187 if obsolete.isenabled(repo, obsolete.createmarkersopt):
17612 fc2a6114f0a0 rebase: allow creation obsolescence relation instead of stripping Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 17611 diff changeset	1188 markers = []
fc2a6114f0a0 rebase: allow creation obsolescence relation instead of stripping Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 17611 diff changeset	1189 for rev, newrev in sorted(state.items()):
fc2a6114f0a0 rebase: allow creation obsolescence relation instead of stripping Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 17611 diff changeset	1190 if newrev >= 0:
18444 55aff0c2b73c rebase: do not invent successor to skipped changeset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18424 diff changeset	1191 if rev in skipped:
55aff0c2b73c rebase: do not invent successor to skipped changeset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18424 diff changeset	1192 succs = ()
55aff0c2b73c rebase: do not invent successor to skipped changeset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18424 diff changeset	1193 elif collapsedas is not None:
55aff0c2b73c rebase: do not invent successor to skipped changeset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18424 diff changeset	1194 succs = (repo[collapsedas],)
55aff0c2b73c rebase: do not invent successor to skipped changeset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18424 diff changeset	1195 else:
55aff0c2b73c rebase: do not invent successor to skipped changeset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18424 diff changeset	1196 succs = (repo[newrev],)
55aff0c2b73c rebase: do not invent successor to skipped changeset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18424 diff changeset	1197 markers.append((repo[rev], succs))
17612 fc2a6114f0a0 rebase: allow creation obsolescence relation instead of stripping Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 17611 diff changeset	1198 if markers:
fc2a6114f0a0 rebase: allow creation obsolescence relation instead of stripping Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 17611 diff changeset	1199 obsolete.createmarkers(repo, markers)
fc2a6114f0a0 rebase: allow creation obsolescence relation instead of stripping Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 17611 diff changeset	1200 else:
18446 c83d36b81df1 rebase: lose the comparison to `nullmerge` Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18444 diff changeset	1201 rebased = [rev for rev in state if state[rev] > nullmerge]
17612 fc2a6114f0a0 rebase: allow creation obsolescence relation instead of stripping Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 17611 diff changeset	1202 if rebased:
18424 100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1203 stripped = []
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1204 for root in repo.set('roots(%ld)', rebased):
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1205 if set(repo.changelog.descendants([root.rev()])) - set(state):
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1206 ui.warn(_("warning: new changesets detected "
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1207 "on source branch, not stripping\n"))
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1208 else:
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1209 stripped.append(root.node())
100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1210 if stripped:
17612 fc2a6114f0a0 rebase: allow creation obsolescence relation instead of stripping Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 17611 diff changeset	1211 # backup the old csets by default
18424 100fdc84670f rebase: support multiple roots for rebaseset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18386 diff changeset	1212 repair.strip(ui, repo, stripped, "all")
17611 910123eac887 rebase: extract final changesets cleanup logic in a dedicated function Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17325 diff changeset	1213
910123eac887 rebase: extract final changesets cleanup logic in a dedicated function Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17325 diff changeset	1214
7216 292fb2ad2846 extensions: use new wrapper functions Matt Mackall <mpm@selenic.com> parents: 7213 diff changeset	1215 def pullrebase(orig, ui, repo, args, *opts):
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	1216 'Call rebase after pull if the latter has been invoked with --rebase'
26960 6979fe2a6d75 rebase: add returning value from pullrebase function liscju <piotr.listkiewicz@gmail.com> parents: 26811 diff changeset	1217 ret = None
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	1218 if opts.get('rebase'):
26029 563ea14c62d4 rebase: lock the repo during the full rebase operation Pierre-Yves David <pierre-yves.david@fb.com> parents: 25660 diff changeset	1219 wlock = lock = None
563ea14c62d4 rebase: lock the repo during the full rebase operation Pierre-Yves David <pierre-yves.david@fb.com> parents: 25660 diff changeset	1220 try:
563ea14c62d4 rebase: lock the repo during the full rebase operation Pierre-Yves David <pierre-yves.david@fb.com> parents: 25660 diff changeset	1221 wlock = repo.wlock()
563ea14c62d4 rebase: lock the repo during the full rebase operation Pierre-Yves David <pierre-yves.david@fb.com> parents: 25660 diff changeset	1222 lock = repo.lock()
563ea14c62d4 rebase: lock the repo during the full rebase operation Pierre-Yves David <pierre-yves.david@fb.com> parents: 25660 diff changeset	1223 if opts.get('update'):
563ea14c62d4 rebase: lock the repo during the full rebase operation Pierre-Yves David <pierre-yves.david@fb.com> parents: 25660 diff changeset	1224 del opts['update']
563ea14c62d4 rebase: lock the repo during the full rebase operation Pierre-Yves David <pierre-yves.david@fb.com> parents: 25660 diff changeset	1225 ui.debug('--update and --rebase are not compatible, ignoring '
563ea14c62d4 rebase: lock the repo during the full rebase operation Pierre-Yves David <pierre-yves.david@fb.com> parents: 25660 diff changeset	1226 'the update flag\n')
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	1227
26029 563ea14c62d4 rebase: lock the repo during the full rebase operation Pierre-Yves David <pierre-yves.david@fb.com> parents: 25660 diff changeset	1228 revsprepull = len(repo)
563ea14c62d4 rebase: lock the repo during the full rebase operation Pierre-Yves David <pierre-yves.david@fb.com> parents: 25660 diff changeset	1229 origpostincoming = commands.postincoming
563ea14c62d4 rebase: lock the repo during the full rebase operation Pierre-Yves David <pierre-yves.david@fb.com> parents: 25660 diff changeset	1230 def _dummy(args, *kwargs):
563ea14c62d4 rebase: lock the repo during the full rebase operation Pierre-Yves David <pierre-yves.david@fb.com> parents: 25660 diff changeset	1231 pass
563ea14c62d4 rebase: lock the repo during the full rebase operation Pierre-Yves David <pierre-yves.david@fb.com> parents: 25660 diff changeset	1232 commands.postincoming = _dummy
563ea14c62d4 rebase: lock the repo during the full rebase operation Pierre-Yves David <pierre-yves.david@fb.com> parents: 25660 diff changeset	1233 try:
26960 6979fe2a6d75 rebase: add returning value from pullrebase function liscju <piotr.listkiewicz@gmail.com> parents: 26811 diff changeset	1234 ret = orig(ui, repo, args, *opts)
26029 563ea14c62d4 rebase: lock the repo during the full rebase operation Pierre-Yves David <pierre-yves.david@fb.com> parents: 25660 diff changeset	1235 finally:
563ea14c62d4 rebase: lock the repo during the full rebase operation Pierre-Yves David <pierre-yves.david@fb.com> parents: 25660 diff changeset	1236 commands.postincoming = origpostincoming
563ea14c62d4 rebase: lock the repo during the full rebase operation Pierre-Yves David <pierre-yves.david@fb.com> parents: 25660 diff changeset	1237 revspostpull = len(repo)
563ea14c62d4 rebase: lock the repo during the full rebase operation Pierre-Yves David <pierre-yves.david@fb.com> parents: 25660 diff changeset	1238 if revspostpull > revsprepull:
563ea14c62d4 rebase: lock the repo during the full rebase operation Pierre-Yves David <pierre-yves.david@fb.com> parents: 25660 diff changeset	1239 # --rev option from pull conflict with rebase own --rev
563ea14c62d4 rebase: lock the repo during the full rebase operation Pierre-Yves David <pierre-yves.david@fb.com> parents: 25660 diff changeset	1240 # dropping it
563ea14c62d4 rebase: lock the repo during the full rebase operation Pierre-Yves David <pierre-yves.david@fb.com> parents: 25660 diff changeset	1241 if 'rev' in opts:
563ea14c62d4 rebase: lock the repo during the full rebase operation Pierre-Yves David <pierre-yves.david@fb.com> parents: 25660 diff changeset	1242 del opts['rev']
563ea14c62d4 rebase: lock the repo during the full rebase operation Pierre-Yves David <pierre-yves.david@fb.com> parents: 25660 diff changeset	1243 # positional argument from pull conflicts with rebase's own
563ea14c62d4 rebase: lock the repo during the full rebase operation Pierre-Yves David <pierre-yves.david@fb.com> parents: 25660 diff changeset	1244 # --source.
563ea14c62d4 rebase: lock the repo during the full rebase operation Pierre-Yves David <pierre-yves.david@fb.com> parents: 25660 diff changeset	1245 if 'source' in opts:
563ea14c62d4 rebase: lock the repo during the full rebase operation Pierre-Yves David <pierre-yves.david@fb.com> parents: 25660 diff changeset	1246 del opts['source']
28189 fac3a24be50e rebase: choose default destination the same way as 'hg merge' (BC) Pierre-Yves David <pierre-yves.david@fb.com> parents: 28188 diff changeset	1247 try:
fac3a24be50e rebase: choose default destination the same way as 'hg merge' (BC) Pierre-Yves David <pierre-yves.david@fb.com> parents: 28188 diff changeset	1248 rebase(ui, repo, **opts)
fac3a24be50e rebase: choose default destination the same way as 'hg merge' (BC) Pierre-Yves David <pierre-yves.david@fb.com> parents: 28188 diff changeset	1249 except error.NoMergeDestAbort:
fac3a24be50e rebase: choose default destination the same way as 'hg merge' (BC) Pierre-Yves David <pierre-yves.david@fb.com> parents: 28188 diff changeset	1250 # we can maybe update instead
28118 0e3835c7e1cf rebase: perform update through the 'update' command Pierre-Yves David <pierre-yves.david@fb.com> parents: 28117 diff changeset	1251 rev, _a, _b = destutil.destupdate(repo)
28189 fac3a24be50e rebase: choose default destination the same way as 'hg merge' (BC) Pierre-Yves David <pierre-yves.david@fb.com> parents: 28188 diff changeset	1252 if rev == repo['.'].rev():
fac3a24be50e rebase: choose default destination the same way as 'hg merge' (BC) Pierre-Yves David <pierre-yves.david@fb.com> parents: 28188 diff changeset	1253 ui.status(_('nothing to rebase\n'))
fac3a24be50e rebase: choose default destination the same way as 'hg merge' (BC) Pierre-Yves David <pierre-yves.david@fb.com> parents: 28188 diff changeset	1254 else:
fac3a24be50e rebase: choose default destination the same way as 'hg merge' (BC) Pierre-Yves David <pierre-yves.david@fb.com> parents: 28188 diff changeset	1255 ui.status(_('nothing to rebase - updating instead\n'))
28118 0e3835c7e1cf rebase: perform update through the 'update' command Pierre-Yves David <pierre-yves.david@fb.com> parents: 28117 diff changeset	1256 # not passing argument to get the bare update behavior
0e3835c7e1cf rebase: perform update through the 'update' command Pierre-Yves David <pierre-yves.david@fb.com> parents: 28117 diff changeset	1257 # with warning and trumpets
0e3835c7e1cf rebase: perform update through the 'update' command Pierre-Yves David <pierre-yves.david@fb.com> parents: 28117 diff changeset	1258 commands.update(ui, repo)
10628 6227c8d669d5 rebase: improve output of hg pull --rebase (issue2072) Sune Foldager <cryo@cyanite.org> parents: 10436 diff changeset	1259 finally:
26029 563ea14c62d4 rebase: lock the repo during the full rebase operation Pierre-Yves David <pierre-yves.david@fb.com> parents: 25660 diff changeset	1260 release(lock, wlock)
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	1261 else:
14444 1f997134a9d1 rebase: add option --tool/-t for 'pull --rebase' Adrian Buehlmann <adrian@cadifra.com> parents: 14306 diff changeset	1262 if opts.get('tool'):
26587 56b2bcea2529 error: get Abort from 'error' instead of 'util' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26496 diff changeset	1263 raise error.Abort(_('--tool can only be used with --rebase'))
26960 6979fe2a6d75 rebase: add returning value from pullrebase function liscju <piotr.listkiewicz@gmail.com> parents: 26811 diff changeset	1264 ret = orig(ui, repo, args, *opts)
6979fe2a6d75 rebase: add returning value from pullrebase function liscju <piotr.listkiewicz@gmail.com> parents: 26811 diff changeset	1265
6979fe2a6d75 rebase: add returning value from pullrebase function liscju <piotr.listkiewicz@gmail.com> parents: 26811 diff changeset	1266 return ret
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	1267
23970 8a544fb645bb rebase: ensure rebase revision remains visible (issue4504) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23917 diff changeset	1268 def _setrebasesetvisibility(repo, revs):
8a544fb645bb rebase: ensure rebase revision remains visible (issue4504) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23917 diff changeset	1269 """store the currently rebased set on the repo object
8a544fb645bb rebase: ensure rebase revision remains visible (issue4504) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23917 diff changeset	1270
8a544fb645bb rebase: ensure rebase revision remains visible (issue4504) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23917 diff changeset	1271 This is used by another function to prevent rebased revision to because
8a544fb645bb rebase: ensure rebase revision remains visible (issue4504) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23917 diff changeset	1272 hidden (see issue4505)"""
8a544fb645bb rebase: ensure rebase revision remains visible (issue4504) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23917 diff changeset	1273 repo = repo.unfiltered()
8a544fb645bb rebase: ensure rebase revision remains visible (issue4504) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23917 diff changeset	1274 revs = set(revs)
8a544fb645bb rebase: ensure rebase revision remains visible (issue4504) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23917 diff changeset	1275 repo._rebaseset = revs
8a544fb645bb rebase: ensure rebase revision remains visible (issue4504) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23917 diff changeset	1276 # invalidate cache if visibility changes
8a544fb645bb rebase: ensure rebase revision remains visible (issue4504) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23917 diff changeset	1277 hiddens = repo.filteredrevcache.get('visible', set())
8a544fb645bb rebase: ensure rebase revision remains visible (issue4504) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23917 diff changeset	1278 if revs & hiddens:
8a544fb645bb rebase: ensure rebase revision remains visible (issue4504) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23917 diff changeset	1279 repo.invalidatevolatilesets()
8a544fb645bb rebase: ensure rebase revision remains visible (issue4504) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23917 diff changeset	1280
8a544fb645bb rebase: ensure rebase revision remains visible (issue4504) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23917 diff changeset	1281 def _clearrebasesetvisibiliy(repo):
8a544fb645bb rebase: ensure rebase revision remains visible (issue4504) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23917 diff changeset	1282 """remove rebaseset data from the repo"""
8a544fb645bb rebase: ensure rebase revision remains visible (issue4504) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23917 diff changeset	1283 repo = repo.unfiltered()
8a544fb645bb rebase: ensure rebase revision remains visible (issue4504) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23917 diff changeset	1284 if '_rebaseset' in vars(repo):
8a544fb645bb rebase: ensure rebase revision remains visible (issue4504) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23917 diff changeset	1285 del repo._rebaseset
8a544fb645bb rebase: ensure rebase revision remains visible (issue4504) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23917 diff changeset	1286
8a544fb645bb rebase: ensure rebase revision remains visible (issue4504) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23917 diff changeset	1287 def _rebasedvisible(orig, repo):
8a544fb645bb rebase: ensure rebase revision remains visible (issue4504) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23917 diff changeset	1288 """ensure rebased revs stay visible (see issue4505)"""
8a544fb645bb rebase: ensure rebase revision remains visible (issue4504) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23917 diff changeset	1289 blockers = orig(repo)
8a544fb645bb rebase: ensure rebase revision remains visible (issue4504) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23917 diff changeset	1290 blockers.update(getattr(repo, '_rebaseset', ()))
8a544fb645bb rebase: ensure rebase revision remains visible (issue4504) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23917 diff changeset	1291 return blockers
8a544fb645bb rebase: ensure rebase revision remains visible (issue4504) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23917 diff changeset	1292
27790 2d294dada4f8 rebase: small refactoring to allow better extensibility from extensions Laurent Charignon <lcharignon@fb.com> parents: 27746 diff changeset	1293 def _filterobsoleterevs(repo, revs):
2d294dada4f8 rebase: small refactoring to allow better extensibility from extensions Laurent Charignon <lcharignon@fb.com> parents: 27746 diff changeset	1294 """returns a set of the obsolete revisions in revs"""
2d294dada4f8 rebase: small refactoring to allow better extensibility from extensions Laurent Charignon <lcharignon@fb.com> parents: 27746 diff changeset	1295 return set(r for r in revs if repo[r].obsolete())
2d294dada4f8 rebase: small refactoring to allow better extensibility from extensions Laurent Charignon <lcharignon@fb.com> parents: 27746 diff changeset	1296
27744 f2b8b4e2de20 rebase: minor refactoring of _computeobsoletenotrebased Laurent Charignon <lcharignon@fb.com> parents: 27626 diff changeset	1297 def _computeobsoletenotrebased(repo, rebaseobsrevs, dest):
26349 92409f8dff5d rebase: don't rebase obsolete commit whose successor is already rebased Laurent Charignon <lcharignon@fb.com> parents: 26301 diff changeset	1298 """return a mapping obsolete => successor for all obsolete nodes to be
27012 5eac7ab59b95 rebase: don't rebase obsolete commits with no successor Laurent Charignon <lcharignon@fb.com> parents: 27010 diff changeset	1299 rebased that have a successors in the destination
5eac7ab59b95 rebase: don't rebase obsolete commits with no successor Laurent Charignon <lcharignon@fb.com> parents: 27010 diff changeset	1300
5eac7ab59b95 rebase: don't rebase obsolete commits with no successor Laurent Charignon <lcharignon@fb.com> parents: 27010 diff changeset	1301 obsolete => None entries in the mapping indicate nodes with no succesor"""
26349 92409f8dff5d rebase: don't rebase obsolete commit whose successor is already rebased Laurent Charignon <lcharignon@fb.com> parents: 26301 diff changeset	1302 obsoletenotrebased = {}
92409f8dff5d rebase: don't rebase obsolete commit whose successor is already rebased Laurent Charignon <lcharignon@fb.com> parents: 26301 diff changeset	1303
26781 1aee2ab0f902 spelling: trivial spell checking Mads Kiilerich <madski@unity3d.com> parents: 26748 diff changeset	1304 # Build a mapping successor => obsolete nodes for the obsolete
26349 92409f8dff5d rebase: don't rebase obsolete commit whose successor is already rebased Laurent Charignon <lcharignon@fb.com> parents: 26301 diff changeset	1305 # nodes to be rebased
92409f8dff5d rebase: don't rebase obsolete commit whose successor is already rebased Laurent Charignon <lcharignon@fb.com> parents: 26301 diff changeset	1306 allsuccessors = {}
26674 fd4a38bd7e49 rebase: use a direct reference to repo.changelog Pierre-Yves David <pierre-yves.david@fb.com> parents: 26671 diff changeset	1307 cl = repo.changelog
27744 f2b8b4e2de20 rebase: minor refactoring of _computeobsoletenotrebased Laurent Charignon <lcharignon@fb.com> parents: 27626 diff changeset	1308 for r in rebaseobsrevs:
f2b8b4e2de20 rebase: minor refactoring of _computeobsoletenotrebased Laurent Charignon <lcharignon@fb.com> parents: 27626 diff changeset	1309 node = cl.node(r)
f2b8b4e2de20 rebase: minor refactoring of _computeobsoletenotrebased Laurent Charignon <lcharignon@fb.com> parents: 27626 diff changeset	1310 for s in obsolete.allsuccessors(repo.obsstore, [node]):
f2b8b4e2de20 rebase: minor refactoring of _computeobsoletenotrebased Laurent Charignon <lcharignon@fb.com> parents: 27626 diff changeset	1311 try:
f2b8b4e2de20 rebase: minor refactoring of _computeobsoletenotrebased Laurent Charignon <lcharignon@fb.com> parents: 27626 diff changeset	1312 allsuccessors[cl.rev(s)] = cl.rev(node)
f2b8b4e2de20 rebase: minor refactoring of _computeobsoletenotrebased Laurent Charignon <lcharignon@fb.com> parents: 27626 diff changeset	1313 except LookupError:
f2b8b4e2de20 rebase: minor refactoring of _computeobsoletenotrebased Laurent Charignon <lcharignon@fb.com> parents: 27626 diff changeset	1314 pass
26349 92409f8dff5d rebase: don't rebase obsolete commit whose successor is already rebased Laurent Charignon <lcharignon@fb.com> parents: 26301 diff changeset	1315
92409f8dff5d rebase: don't rebase obsolete commit whose successor is already rebased Laurent Charignon <lcharignon@fb.com> parents: 26301 diff changeset	1316 if allsuccessors:
92409f8dff5d rebase: don't rebase obsolete commit whose successor is already rebased Laurent Charignon <lcharignon@fb.com> parents: 26301 diff changeset	1317 # Look for successors of obsolete nodes to be rebased among
92409f8dff5d rebase: don't rebase obsolete commit whose successor is already rebased Laurent Charignon <lcharignon@fb.com> parents: 26301 diff changeset	1318 # the ancestors of dest
26674 fd4a38bd7e49 rebase: use a direct reference to repo.changelog Pierre-Yves David <pierre-yves.david@fb.com> parents: 26671 diff changeset	1319 ancs = cl.ancestors([repo[dest].rev()],
fd4a38bd7e49 rebase: use a direct reference to repo.changelog Pierre-Yves David <pierre-yves.david@fb.com> parents: 26671 diff changeset	1320 stoprev=min(allsuccessors),
fd4a38bd7e49 rebase: use a direct reference to repo.changelog Pierre-Yves David <pierre-yves.david@fb.com> parents: 26671 diff changeset	1321 inclusive=True)
26349 92409f8dff5d rebase: don't rebase obsolete commit whose successor is already rebased Laurent Charignon <lcharignon@fb.com> parents: 26301 diff changeset	1322 for s in allsuccessors:
92409f8dff5d rebase: don't rebase obsolete commit whose successor is already rebased Laurent Charignon <lcharignon@fb.com> parents: 26301 diff changeset	1323 if s in ancs:
92409f8dff5d rebase: don't rebase obsolete commit whose successor is already rebased Laurent Charignon <lcharignon@fb.com> parents: 26301 diff changeset	1324 obsoletenotrebased[allsuccessors[s]] = s
27012 5eac7ab59b95 rebase: don't rebase obsolete commits with no successor Laurent Charignon <lcharignon@fb.com> parents: 27010 diff changeset	1325 elif (s == allsuccessors[s] and
5eac7ab59b95 rebase: don't rebase obsolete commits with no successor Laurent Charignon <lcharignon@fb.com> parents: 27010 diff changeset	1326 allsuccessors.values().count(s) == 1):
5eac7ab59b95 rebase: don't rebase obsolete commits with no successor Laurent Charignon <lcharignon@fb.com> parents: 27010 diff changeset	1327 # plain prune
5eac7ab59b95 rebase: don't rebase obsolete commits with no successor Laurent Charignon <lcharignon@fb.com> parents: 27010 diff changeset	1328 obsoletenotrebased[s] = None
5eac7ab59b95 rebase: don't rebase obsolete commits with no successor Laurent Charignon <lcharignon@fb.com> parents: 27010 diff changeset	1329
26349 92409f8dff5d rebase: don't rebase obsolete commit whose successor is already rebased Laurent Charignon <lcharignon@fb.com> parents: 26301 diff changeset	1330 return obsoletenotrebased
92409f8dff5d rebase: don't rebase obsolete commit whose successor is already rebased Laurent Charignon <lcharignon@fb.com> parents: 26301 diff changeset	1331
19214 0250047a365e summary: indicate if a rebase is underway Bryan O'Sullivan <bryano@fb.com> parents: 19059 diff changeset	1332 def summaryhook(ui, repo):
0250047a365e summary: indicate if a rebase is underway Bryan O'Sullivan <bryano@fb.com> parents: 19059 diff changeset	1333 if not os.path.exists(repo.join('rebasestate')):
0250047a365e summary: indicate if a rebase is underway Bryan O'Sullivan <bryano@fb.com> parents: 19059 diff changeset	1334 return
19849 e7fa36d2ad3a rebase: catch RepoLookupError at restoring rebase state for summary FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 19848 diff changeset	1335 try:
e7fa36d2ad3a rebase: catch RepoLookupError at restoring rebase state for summary FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 19848 diff changeset	1336 state = restorestatus(repo)[2]
e7fa36d2ad3a rebase: catch RepoLookupError at restoring rebase state for summary FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 19848 diff changeset	1337 except error.RepoLookupError:
e7fa36d2ad3a rebase: catch RepoLookupError at restoring rebase state for summary FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 19848 diff changeset	1338 # i18n: column positioning for "hg summary"
e7fa36d2ad3a rebase: catch RepoLookupError at restoring rebase state for summary FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 19848 diff changeset	1339 msg = _('rebase: (use "hg rebase --abort" to clear broken state)\n')
e7fa36d2ad3a rebase: catch RepoLookupError at restoring rebase state for summary FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 19848 diff changeset	1340 ui.write(msg)
e7fa36d2ad3a rebase: catch RepoLookupError at restoring rebase state for summary FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 19848 diff changeset	1341 return
23489 fe4157d839ac rebase: use '>= 0' to know is a revision was rebased Pierre-Yves David <pierre-yves.david@fb.com> parents: 23484 diff changeset	1342 numrebased = len([i for i in state.itervalues() if i >= 0])
19214 0250047a365e summary: indicate if a rebase is underway Bryan O'Sullivan <bryano@fb.com> parents: 19059 diff changeset	1343 # i18n: column positioning for "hg summary"
0250047a365e summary: indicate if a rebase is underway Bryan O'Sullivan <bryano@fb.com> parents: 19059 diff changeset	1344 ui.write(_('rebase: %s, %s (rebase --continue)\n') %
0250047a365e summary: indicate if a rebase is underway Bryan O'Sullivan <bryano@fb.com> parents: 19059 diff changeset	1345 (ui.label(_('%d rebased'), 'rebase.rebased') % numrebased,
0250047a365e summary: indicate if a rebase is underway Bryan O'Sullivan <bryano@fb.com> parents: 19059 diff changeset	1346 ui.label(_('%d remaining'), 'rebase.remaining') %
0250047a365e summary: indicate if a rebase is underway Bryan O'Sullivan <bryano@fb.com> parents: 19059 diff changeset	1347 (len(state) - numrebased)))
0250047a365e summary: indicate if a rebase is underway Bryan O'Sullivan <bryano@fb.com> parents: 19059 diff changeset	1348
6906 808f03f61ebe Add rebase extension Stefano Tortarolo <stefano.tortarolo@gmail.com> parents: diff changeset	1349 def uisetup(ui):
23970 8a544fb645bb rebase: ensure rebase revision remains visible (issue4504) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23917 diff changeset	1350 #Replace pull with a decorator to provide --rebase option
7216 292fb2ad2846 extensions: use new wrapper functions Matt Mackall <mpm@selenic.com> parents: 7213 diff changeset	1351 entry = extensions.wrapcommand(commands.table, 'pull', pullrebase)
292fb2ad2846 extensions: use new wrapper functions Matt Mackall <mpm@selenic.com> parents: 7213 diff changeset	1352 entry[1].append(('', 'rebase', None,
14444 1f997134a9d1 rebase: add option --tool/-t for 'pull --rebase' Adrian Buehlmann <adrian@cadifra.com> parents: 14306 diff changeset	1353 _("rebase working directory to branch head")))
1f997134a9d1 rebase: add option --tool/-t for 'pull --rebase' Adrian Buehlmann <adrian@cadifra.com> parents: 14306 diff changeset	1354 entry[1].append(('t', 'tool', '',
1f997134a9d1 rebase: add option --tool/-t for 'pull --rebase' Adrian Buehlmann <adrian@cadifra.com> parents: 14306 diff changeset	1355 _("specify merge tool for rebase")))
19214 0250047a365e summary: indicate if a rebase is underway Bryan O'Sullivan <bryano@fb.com> parents: 19059 diff changeset	1356 cmdutil.summaryhooks.add('rebase', summaryhook)
19478 e5a5790a3185 rebase: add checkunfinished support (issue3955) Matt Mackall <mpm@selenic.com> parents: 19477 diff changeset	1357 cmdutil.unfinishedstates.append(
19496 607191a45f8c checkunfinished: accommodate histedit quirk Matt Mackall <mpm@selenic.com> parents: 19478 diff changeset	1358 ['rebasestate', False, False, _('rebase in progress'),
19478 e5a5790a3185 rebase: add checkunfinished support (issue3955) Matt Mackall <mpm@selenic.com> parents: 19477 diff changeset	1359 _("use 'hg rebase --continue' or 'hg rebase --abort'")])
27626 157675d0f600 rebase: hook afterresolvedstates timeless <timeless@mozdev.org> parents: 27586 diff changeset	1360 cmdutil.afterresolvedstates.append(
157675d0f600 rebase: hook afterresolvedstates timeless <timeless@mozdev.org> parents: 27586 diff changeset	1361 ['rebasestate', _('hg rebase --continue')])
23970 8a544fb645bb rebase: ensure rebase revision remains visible (issue4504) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23917 diff changeset	1362 # ensure rebased rev are not hidden
8a544fb645bb rebase: ensure rebase revision remains visible (issue4504) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23917 diff changeset	1363 extensions.wrapfunction(repoview, '_getdynamicblockers', _rebasedvisible)

Mercurial > public > mercurial-scm > hg-stable

annotate hgext/rebase.py @ 29043:cf7de4aeb86b stable