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
Lint Skipped
Unit
Unit Tests Skipped

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 15938

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 ..