This is an archive of the discontinued Mercurial Phabricator instance.

Differential D6646

continue: added support for rebase
ClosedPublic

Authored by taapas1128 on Jul 15 2019, 4:41 PM.

Details

Reviewers
durin42
martinvonz
Group Reviewers
hg-reviewers
Commits
rHG35ebdbb38efb: continue: added support for rebase
rHGdb963eda96ef: continue: added support for rebase
Summary

This adds support of rebase to hg continue plan.

An independent continue logic for rebase is created
under continuerebase() function. For this a seperate
rebaseruntime object is created under the function to
handle an interrupted rebasestate.

Results of tests are shown.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

taapas1128 created this revision.Jul 15 2019, 4:41 PM
taapas1128 added a commit: rHGdb963eda96ef: continue: added support for rebase.Jul 17 2019, 7:05 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHGdb963eda96ef: continue: added support for rebase (authored by taapas1128). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 15942

hgext/rebase.py

obsoleteextinctsuccessors, obsoleteextinctsuccessors,
) )
def abortrebase(ui, repo): def abortrebase(ui, repo):
with repo.wlock(), repo.lock(): with repo.wlock(), repo.lock():
rbsrt = rebaseruntime(repo, ui) rbsrt = rebaseruntime(repo, ui)
rbsrt._prepareabortorcontinue(isabort=True) rbsrt._prepareabortorcontinue(isabort=True)
def continuerebase(ui, repo):
with repo.wlock(), repo.lock():
rbsrt = rebaseruntime(repo, ui)
ms = mergemod.mergestate.read(repo)
mergeutil.checkunresolved(ms)
retcode = rbsrt._prepareabortorcontinue(isabort=False)
if retcode is not None:
return retcode
rbsrt._performrebase(None)
rbsrt._finishrebase()
def summaryhook(ui, repo): def summaryhook(ui, repo):
if not repo.vfs.exists('rebasestate'): if not repo.vfs.exists('rebasestate'):
return return
try: try:
rbsrt = rebaseruntime(repo, ui, {}) rbsrt = rebaseruntime(repo, ui, {})
rbsrt.restorestatus() rbsrt.restorestatus()
state = rbsrt.state state = rbsrt.state
except error.RepoLookupError: except error.RepoLookupError:
#Replace pull with a decorator to provide --rebase option #Replace pull with a decorator to provide --rebase option
entry = extensions.wrapcommand(commands.table, 'pull', pullrebase) entry = extensions.wrapcommand(commands.table, 'pull', pullrebase)
entry[1].append(('', 'rebase', None, entry[1].append(('', 'rebase', None,
_("rebase working directory to branch head"))) _("rebase working directory to branch head")))
entry[1].append(('t', 'tool', '', entry[1].append(('t', 'tool', '',
_("specify merge tool for rebase"))) _("specify merge tool for rebase")))
cmdutil.summaryhooks.add('rebase', summaryhook) cmdutil.summaryhooks.add('rebase', summaryhook)
statemod.addunfinished('rebase', fname='rebasestate', stopflag=True, statemod.addunfinished('rebase', fname='rebasestate', stopflag=True,
continueflag=True, abortfunc=abortrebase) continueflag=True, abortfunc=abortrebase,
continuefunc=continuerebase)

tests/test-narrow-rebase.t

#testcases continuecommand continueflag
#if continueflag
$ cat >> $HGRCPATH <<EOF
> [alias]
> continue = rebase --continue
> EOF
#endif
$ . "$TESTDIR/narrow-library.sh" $ . "$TESTDIR/narrow-library.sh"
create full repo create full repo
$ hg init master $ hg init master
$ cd master $ cd master
$ hg ci -qm 'conflicting inside/f1' $ hg ci -qm 'conflicting inside/f1'
$ hg rebase -d 'desc("modify inside/f1")' 2>&1 | egrep -v '(warning:|incomplete!)' $ hg rebase -d 'desc("modify inside/f1")' 2>&1 | egrep -v '(warning:|incomplete!)'
rebasing 6:cdce97fbf653 "conflicting inside/f1" (tip) rebasing 6:cdce97fbf653 "conflicting inside/f1" (tip)
merging inside/f1 merging inside/f1
unresolved conflicts (see hg resolve, then hg rebase --continue) unresolved conflicts (see hg resolve, then hg rebase --continue)
$ echo modified3 > inside/f1 $ echo modified3 > inside/f1
$ hg resolve -m 2>&1 | grep -v continue: $ hg resolve -m 2>&1 | grep -v continue:
(no more unresolved files) (no more unresolved files)
$ hg rebase --continue $ hg continue
rebasing 6:cdce97fbf653 "conflicting inside/f1" (tip) rebasing 6:cdce97fbf653 "conflicting inside/f1" (tip)
saved backup bundle to $TESTTMP/narrow/.hg/strip-backup/*-rebase.hg (glob) saved backup bundle to $TESTTMP/narrow/.hg/strip-backup/*-rebase.hg (glob)
Can rebase onto non-conflicting changes outside narrow spec Can rebase onto non-conflicting changes outside narrow spec
$ hg update -q 0 $ hg update -q 0
$ echo modified > inside/f2 $ echo modified > inside/f2
$ hg ci -qm 'modify inside/f2' $ hg ci -qm 'modify inside/f2'

tests/test-rebase-abort.t

#testcases abortcommand abortflag #testcases abortcommand abortflag
#testcases continuecommand continueflag
$ cat >> $HGRCPATH <<EOF $ cat >> $HGRCPATH <<EOF
> [extensions] > [extensions]
> rebase= > rebase=
> >
> [phases] > [phases]
> publish=False > publish=False
> >
> [alias] > [alias]
> tglog = log -G --template "{rev}:{phase} '{desc}' {branches}\n" > tglog = log -G --template "{rev}:{phase} '{desc}' {branches}\n"
> EOF > EOF
#if abortflag #if abortflag
$ cat >> $HGRCPATH <<EOF $ cat >> $HGRCPATH <<EOF
> [alias] > [alias]
> abort = rebase --abort > abort = rebase --abort
> EOF > EOF
#endif #endif
#if continueflag
$ cat >> $HGRCPATH <<EOF
> [alias]
> continue = rebase --continue
> EOF
#endif
$ hg init a $ hg init a
$ cd a $ cd a
$ touch .hg/rebasestate $ touch .hg/rebasestate
$ hg sum $ hg sum
parent: -1:000000000000 tip (empty repository) parent: -1:000000000000 tip (empty repository)
branch: default branch: default
commit: (clean) commit: (clean)
unresolved conflicts (see hg resolve, then hg rebase --continue) unresolved conflicts (see hg resolve, then hg rebase --continue)
[1] [1]
$ mv .hg/rebasestate .hg/rebasestate.back $ mv .hg/rebasestate .hg/rebasestate.back
$ hg update --quiet --clean 2 $ hg update --quiet --clean 2
$ hg --config extensions.mq= strip --quiet "destination()" $ hg --config extensions.mq= strip --quiet "destination()"
$ mv .hg/rebasestate.back .hg/rebasestate $ mv .hg/rebasestate.back .hg/rebasestate
$ hg rebase --continue $ hg continue
abort: cannot continue inconsistent rebase abort: cannot continue inconsistent rebase
(use "hg rebase --abort" to clear broken state) (use "hg rebase --abort" to clear broken state)
[255] [255]
$ hg summary | grep '^rebase: ' $ hg summary | grep '^rebase: '
rebase: (use "hg rebase --abort" to clear broken state) rebase: (use "hg rebase --abort" to clear broken state)
$ hg abort $ hg abort
rebase aborted (no revision is removed, only broken state is cleared) rebase aborted (no revision is removed, only broken state is cleared)

tests/test-rebase-legacy.t

#testcases continuecommand continueflag
Test rebase --continue with rebasestate written by legacy client Test rebase --continue with rebasestate written by legacy client
$ cat >> $HGRCPATH <<EOF $ cat >> $HGRCPATH <<EOF
> [extensions] > [extensions]
> rebase= > rebase=
> drawdag=$TESTDIR/drawdag.py > drawdag=$TESTDIR/drawdag.py
> EOF > EOF
#if continueflag
$ cat >> $HGRCPATH <<EOF
> [alias]
> continue = rebase --continue
> EOF
#endif
$ hg init $ hg init
$ hg debugdrawdag <<'EOF' $ hg debugdrawdag <<'EOF'
> D H > D H
> | | > | |
> C G > C G
> | | > | |
> B F > B F
> | | > | |
> c1e6b162678d07d0b204e5c8267d51b4e03b633c:0000000000000000000000000000000000000000 > c1e6b162678d07d0b204e5c8267d51b4e03b633c:0000000000000000000000000000000000000000
> aeba276fcb7df8e10153a07ee728d5540693f5aa:-3 > aeba276fcb7df8e10153a07ee728d5540693f5aa:-3
> bd5548558fcf354d37613005737a143871bf3723:-3 > bd5548558fcf354d37613005737a143871bf3723:-3
> d2fa1c02b2401b0e32867f26cce50818a4bd796a:0000000000000000000000000000000000000000 > d2fa1c02b2401b0e32867f26cce50818a4bd796a:0000000000000000000000000000000000000000
> 6f7a236de6852570cd54649ab62b1012bb78abc8:0000000000000000000000000000000000000000 > 6f7a236de6852570cd54649ab62b1012bb78abc8:0000000000000000000000000000000000000000
> 6582e6951a9c48c236f746f186378e36f59f4928:0000000000000000000000000000000000000000 > 6582e6951a9c48c236f746f186378e36f59f4928:0000000000000000000000000000000000000000
> EOF > EOF
$ hg rebase --continue #if continuecommand
$ hg continue --dry-run
rebase in progress, will be resumed
#endif
$ hg continue
rebasing 4:c1e6b162678d "B" (B) rebasing 4:c1e6b162678d "B" (B)
rebasing 8:6f7a236de685 "D" (D) rebasing 8:6f7a236de685 "D" (D)
rebasing 2:de008c61a447 "E" (E) rebasing 2:de008c61a447 "E" (E)
rebasing 7:d2fa1c02b240 "G" (G) rebasing 7:d2fa1c02b240 "G" (G)
rebasing 9:6582e6951a9c "H" (H tip) rebasing 9:6582e6951a9c "H" (H tip)
warning: orphaned descendants detected, not stripping c1e6b162678d, de008c61a447 warning: orphaned descendants detected, not stripping c1e6b162678d, de008c61a447
saved backup bundle to $TESTTMP/.hg/strip-backup/6f7a236de685-9880a3dc-rebase.hg saved backup bundle to $TESTTMP/.hg/strip-backup/6f7a236de685-9880a3dc-rebase.hg

tests/test-rebase-mq-skip.t

#testcases continuecommand continueflag
This emulates the effects of an hg pull --rebase in which the remote repo This emulates the effects of an hg pull --rebase in which the remote repo
already has one local mq patch already has one local mq patch
$ cat >> $HGRCPATH <<EOF $ cat >> $HGRCPATH <<EOF
> [extensions] > [extensions]
> rebase= > rebase=
> mq= > mq=
> >
> [phases] > [phases]
> publish=False > publish=False
> >
> [alias] > [alias]
> tglog = log -G --template "{rev}: {node|short} '{desc}' tags: {tags}\n" > tglog = log -G --template "{rev}: {node|short} '{desc}' tags: {tags}\n"
> EOF > EOF
#if continueflag
$ cat >> $HGRCPATH <<EOF
> [alias]
> continue = rebase --continue
> EOF
#endif
$ hg init a $ hg init a
$ cd a $ cd a
$ hg qinit -c $ hg qinit -c
$ echo c1 > c1 $ echo c1 > c1
$ hg add c1 $ hg add c1
$ hg ci -m C1 $ hg ci -m C1
rebasing 4:094320fec554 "r4" (r4) rebasing 4:094320fec554 "r4" (r4)
unresolved conflicts (see hg resolve, then hg rebase --continue) unresolved conflicts (see hg resolve, then hg rebase --continue)
[1] [1]
$ HGMERGE=internal:local hg resolve --all $ HGMERGE=internal:local hg resolve --all
(no more unresolved files) (no more unresolved files)
continue: hg rebase --continue continue: hg rebase --continue
$ hg rebase --continue $ hg continue
already rebased 1:b4bffa6e4776 "r1" (qbase r1) as 057f55ff8f44 already rebased 1:b4bffa6e4776 "r1" (qbase r1) as 057f55ff8f44
already rebased 2:c0fd129beb01 "r2" (r2) as 1660ab13ce9a already rebased 2:c0fd129beb01 "r2" (r2) as 1660ab13ce9a
already rebased 3:6ff5b8feed8e "r3" (r3) as 1660ab13ce9a already rebased 3:6ff5b8feed8e "r3" (r3) as 1660ab13ce9a
rebasing 4:094320fec554 "r4" (r4) rebasing 4:094320fec554 "r4" (r4)
note: not rebasing 4:094320fec554 "r4" (r4), its destination already has all its changes note: not rebasing 4:094320fec554 "r4" (r4), its destination already has all its changes
rebasing 5:681a378595ba "r5" (r5) rebasing 5:681a378595ba "r5" (r5)
rebasing 6:512a1f24768b "r6" (qtip r6) rebasing 6:512a1f24768b "r6" (qtip r6)
note: not rebasing 6:512a1f24768b "r6" (qtip r6), its destination already has all its changes note: not rebasing 6:512a1f24768b "r6" (qtip r6), its destination already has all its changes

tests/test-rebase-transaction.t

#testcases continuecommand continueflag
Rebasing using a single transaction Rebasing using a single transaction
$ cat >> $HGRCPATH <<EOF $ cat >> $HGRCPATH <<EOF
> [extensions] > [extensions]
> rebase= > rebase=
> drawdag=$TESTDIR/drawdag.py > drawdag=$TESTDIR/drawdag.py
> >
> [rebase] > [rebase]
> singletransaction=True > singletransaction=True
> >
> [phases] > [phases]
> publish=False > publish=False
> >
> [alias] > [alias]
> tglog = log -G --template "{rev}: {desc}" > tglog = log -G --template "{rev}: {desc}"
> EOF > EOF
#if continueflag
$ cat >> $HGRCPATH <<EOF
> [alias]
> continue = rebase --continue
> EOF
#endif
Check that a simple rebase works Check that a simple rebase works
$ hg init simple && cd simple $ hg init simple && cd simple
$ hg debugdrawdag <<'EOF' $ hg debugdrawdag <<'EOF'
> Z > Z
> | > |
> | D > | D
> | | > | |
M C M C
M conflict M conflict
A B A B
? conflict.orig ? conflict.orig
$ echo resolved > conflict $ echo resolved > conflict
$ hg resolve -m $ hg resolve -m
(no more unresolved files) (no more unresolved files)
continue: hg rebase --continue continue: hg rebase --continue
$ hg rebase --continue $ hg continue
already rebased 1:112478962961 "B" (B) as 79bc8f4973ce already rebased 1:112478962961 "B" (B) as 79bc8f4973ce
rebasing 3:c26739dbe603 "C" (C) rebasing 3:c26739dbe603 "C" (C)
rebasing 5:d24bb333861c "D" (D tip) rebasing 5:d24bb333861c "D" (D tip)
saved backup bundle to $TESTTMP/collapse-conflict/.hg/strip-backup/112478962961-b5b34645-rebase.hg saved backup bundle to $TESTTMP/collapse-conflict/.hg/strip-backup/112478962961-b5b34645-rebase.hg
$ hg tglog $ hg tglog
o 3: Collapsed revision o 3: Collapsed revision
| * B | * B
| * C | * C
o | 3: C o | 3: C
| | | |
| o 2: Y | o 2: Y
| | | |
o | 1: B o | 1: B
|/ |/
o 0: A o 0: A
$ hg rebase --continue $ hg continue
rebasing 1:112478962961 "B" (B) rebasing 1:112478962961 "B" (B)
rebasing 3:26805aba1e60 "C" (C) rebasing 3:26805aba1e60 "C" (C)
rebasing 5:f585351a92f8 "D" (D tip) rebasing 5:f585351a92f8 "D" (D tip)
saved backup bundle to $TESTTMP/collapse-cancel-editor/.hg/strip-backup/112478962961-cb2a9b47-rebase.hg saved backup bundle to $TESTTMP/collapse-cancel-editor/.hg/strip-backup/112478962961-cb2a9b47-rebase.hg
$ hg tglog $ hg tglog
o 3: Collapsed revision o 3: Collapsed revision
| * B | * B
| * C | * C
| * D | * D
o 2: Z o 2: Z
| |
o 1: Y o 1: Y
| |
o 0: A o 0: A
$ cd .. $ cd ..