facebook/sapling
1
1
Fork 0
mirror of https://github.com/facebook/sapling.git synced 2024-10-09 16:31:02 +03:00
Code Issues Projects Releases Wiki Activity
213feff513
sapling/tests/test-fb-hgext-undo.t

1318 lines
36 KiB
Perl
Raw Normal View History

undo: store op history Summary: Store basic operational history: bookmarks, commands, private heads, date and working copy parent Test Plan: Unit tests Reviewers: durham, #mercurial, mitrandir, quark Reviewed By: quark Subscribers: stash, mitrandir Differential Revision: https://phabricator.intern.facebook.com/D5293596 Tasks: 19261492, 19563903, 19450726 Tags: Hg Undo Signature: t1:5293596:1498245082:264e344054ee5061a439dec1c6071c2a60ffcf55
2017-06-23 22:19:09 +03:00
$ cat >> $HGRCPATH <<EOF
> [extensions]
fb-hgext: fix copied fb-hgext tests Summary: This is a big bulk of generally almost-obvious fixes to the moved tests. Mostly these fixes have to do with correct importing of the actual extensions. Depends on D6675329 Test Plan: - ./run-tests.py fails less after this commit - see further commits for more test fixes Reviewers: #sourcecontrol Differential Revision: https://phabricator.intern.facebook.com/D6675344
2018-01-09 14:06:09 +03:00
> undo=
> inhibit=
undo: improved performance and prep for hg undo Implements lighttransaction(repo) which improves performance of hg undo and prevents infinite loops caused by hooks that run true hg commands. Also adds _getrevlog and _invertindex commands, factoring out code that will be reused. Changes output for gaps when typing hg debugundohistory -l for slightly better ui and clearer testing. Lastly, changes lock from repo lock to new undolog lock and tests this. In the future, with some changes to undo.log, we may be able to take the lock later, bypassing the need to take it for read-only operations. Differential Revision: https://phab.mercurial-scm.org/D50
2017-07-17 23:18:54 +03:00
> [undo]
> _duringundologlock=1
undo: implements relative undo, hg redo and tests Implements, and makes default relative undos and adds redos. A relative undo behaves differently only if you haven't performend any repo changing operations since your previous undo or redo, in which case you operate relative to that undo/redo. This means that a second undo will not undo the previous undo but instead bring you furter back. Differential Revision: https://phab.mercurial-scm.org/D52
2017-07-20 03:49:21 +03:00
> [experimental]
> evolution=createmarkers
undo: meaningful obs markers for undos Makes obs markers for undos more meaningful. When an undo performs a strict one to one change, the written obs marker reflects that and the user even gets a helpful ui message in smartlog. One to many undos do not support such obs markers (currently) because we can't tell splits and divergence apart easily. Differential Revision: https://phab.mercurial-scm.org/D108
2017-07-20 03:49:21 +03:00
> [ui]
> interactive = true
undo: store op history Summary: Store basic operational history: bookmarks, commands, private heads, date and working copy parent Test Plan: Unit tests Reviewers: durham, #mercurial, mitrandir, quark Reviewed By: quark Subscribers: stash, mitrandir Differential Revision: https://phabricator.intern.facebook.com/D5293596 Tasks: 19261492, 19563903, 19450726 Tags: Hg Undo Signature: t1:5293596:1498245082:264e344054ee5061a439dec1c6071c2a60ffcf55
2017-06-23 22:19:09 +03:00
> EOF
Build up a repo
$ hg init repo
$ cd repo
undo: allow user to list or see details about undoable commands run Summary: add hg debugundohistory -l to view recent undoable transactions Test Plan: unit test Reviewers: #mercurial, stash, quark Reviewed By: quark Subscribers: quark, mitrandir, durham, stash, medson, mjpieters Differential Revision: https://phabricator.intern.facebook.com/D5325772 Tasks: 19646287 Signature: t1:5325772:1499122626:48dd25cee8ed8912c07a6c1dabb3d4286483a8b7
2017-07-04 05:01:09 +03:00
Test data store
undo: store op history Summary: Store basic operational history: bookmarks, commands, private heads, date and working copy parent Test Plan: Unit tests Reviewers: durham, #mercurial, mitrandir, quark Reviewed By: quark Subscribers: stash, mitrandir Differential Revision: https://phabricator.intern.facebook.com/D5293596 Tasks: 19261492, 19563903, 19450726 Tags: Hg Undo Signature: t1:5293596:1498245082:264e344054ee5061a439dec1c6071c2a60ffcf55
2017-06-23 22:19:09 +03:00
$ hg book master
$ touch a1 && hg add a1 && hg ci -ma1
$ touch a2 && hg add a2 && hg ci -ma2
$ hg book feature1
$ touch b && hg add b && hg ci -mb
$ hg up -q master
$ touch c1 && hg add c1 && hg ci -mc1
$ touch c2 && hg add c2 && hg ci -mc2
$ hg book feature2
$ touch d && hg add d && hg ci -md
undo: move undolog to vfs and mark as lock-safe The upstream has added some warning around repo.svfs/vfs write operations without taking locks. For undo, we don't want to take the repo lock (since that means read-only operations like `hg log` will be blocked by another `hg commit`). So undo has its own locking and own transaction (for lower overhead). Therefore move all files we may write (including lock and transaction files) to `.hg/undolog` and whitelist the directory at `localrepository._wlockfreeprefix` to bypass the checks. Differential Revision: https://phab.mercurial-scm.org/D112
2017-07-18 21:30:05 +03:00
$ hg debugindex .hg/undolog/command.i
undo: replace delta with base in test output Summary: I haven't tracked down where this change came from, but it looks fairly benign and straightforward to fix. Test Plan: The test now passes Reviewers: #fbhgext, stash Reviewed By: #fbhgext, stash Differential Revision: https://phab.mercurial-scm.org/D147
2017-07-19 17:08:21 +03:00
rev offset length base linkrev nodeid p1 p2
0 0 0 0 1 b80de5d13875 000000000000 000000000000
undo: don't break when undo isn't first argument Undo commands where undo wasn't first, for example `hg --pager=off undo` break multiple things, including hg redo. This change fixes this. Differential Revision: https://phab.mercurial-scm.org/D396
2017-08-16 02:56:25 +03:00
1 0 22 1 1 bae41a9d0ae9 000000000000 000000000000
2 22 15 2 1 6086ecd42962 000000000000 000000000000
3 37 15 3 1 5cc3b22d9c65 000000000000 000000000000
4 52 24 4 1 efaf8be657bb 000000000000 000000000000
5 76 14 5 1 fe69d6bf5432 000000000000 000000000000
6 90 20 6 1 720b2d7eb02b 000000000000 000000000000
7 110 15 7 1 0595892db30f 000000000000 000000000000
8 125 15 8 1 c8265ade52fa 000000000000 000000000000
9 140 24 9 1 0d8f98a931b9 000000000000 000000000000
10 164 14 10 1 fded10d93e92 000000000000 000000000000
undo: move undolog to vfs and mark as lock-safe The upstream has added some warning around repo.svfs/vfs write operations without taking locks. For undo, we don't want to take the repo lock (since that means read-only operations like `hg log` will be blocked by another `hg commit`). So undo has its own locking and own transaction (for lower overhead). Therefore move all files we may write (including lock and transaction files) to `.hg/undolog` and whitelist the directory at `localrepository._wlockfreeprefix` to bypass the checks. Differential Revision: https://phab.mercurial-scm.org/D112
2017-07-18 21:30:05 +03:00
$ hg debugdata .hg/undolog/command.i 0
$ hg debugdata .hg/undolog/command.i 1
undo: don't break when undo isn't first argument Undo commands where undo wasn't first, for example `hg --pager=off undo` break multiple things, including hg redo. This change fixes this. Differential Revision: https://phab.mercurial-scm.org/D396
2017-08-16 02:56:25 +03:00
bookmarks\x00book\x00master (no-eol) (esc)
undo: move undolog to vfs and mark as lock-safe The upstream has added some warning around repo.svfs/vfs write operations without taking locks. For undo, we don't want to take the repo lock (since that means read-only operations like `hg log` will be blocked by another `hg commit`). So undo has its own locking and own transaction (for lower overhead). Therefore move all files we may write (including lock and transaction files) to `.hg/undolog` and whitelist the directory at `localrepository._wlockfreeprefix` to bypass the checks. Differential Revision: https://phab.mercurial-scm.org/D112
2017-07-18 21:30:05 +03:00
$ hg debugdata .hg/undolog/command.i 2
undo: don't break when undo isn't first argument Undo commands where undo wasn't first, for example `hg --pager=off undo` break multiple things, including hg redo. This change fixes this. Differential Revision: https://phab.mercurial-scm.org/D396
2017-08-16 02:56:25 +03:00
commit\x00ci\x00-ma1 (no-eol) (esc)
undo: move undolog to vfs and mark as lock-safe The upstream has added some warning around repo.svfs/vfs write operations without taking locks. For undo, we don't want to take the repo lock (since that means read-only operations like `hg log` will be blocked by another `hg commit`). So undo has its own locking and own transaction (for lower overhead). Therefore move all files we may write (including lock and transaction files) to `.hg/undolog` and whitelist the directory at `localrepository._wlockfreeprefix` to bypass the checks. Differential Revision: https://phab.mercurial-scm.org/D112
2017-07-18 21:30:05 +03:00
$ hg debugdata .hg/undolog/command.i 3
undo: don't break when undo isn't first argument Undo commands where undo wasn't first, for example `hg --pager=off undo` break multiple things, including hg redo. This change fixes this. Differential Revision: https://phab.mercurial-scm.org/D396
2017-08-16 02:56:25 +03:00
commit\x00ci\x00-ma2 (no-eol) (esc)
undo: move undolog to vfs and mark as lock-safe The upstream has added some warning around repo.svfs/vfs write operations without taking locks. For undo, we don't want to take the repo lock (since that means read-only operations like `hg log` will be blocked by another `hg commit`). So undo has its own locking and own transaction (for lower overhead). Therefore move all files we may write (including lock and transaction files) to `.hg/undolog` and whitelist the directory at `localrepository._wlockfreeprefix` to bypass the checks. Differential Revision: https://phab.mercurial-scm.org/D112
2017-07-18 21:30:05 +03:00
$ hg debugdata .hg/undolog/bookmarks.i 0
$ hg debugdata .hg/undolog/bookmarks.i 1
undo: amend transacts twice Summary: amend performs two transactions, second without command which breaks our assertion, but possibly isn't an issue. This fixes the assertion. Test Plan: unit tests Reviewers: #mercurial, stash, quark Reviewed By: quark Subscribers: quark, stash, medson, mjpieters Differential Revision: https://phabricator.intern.facebook.com/D5326358 Tasks: 19261492 Signature: t1:5326358:1498684945:0fde1df243cdbac67ceb092d30599ebd56a731a5
2017-06-29 01:28:40 +03:00
master 0000000000000000000000000000000000000000 (no-eol)
undo: move undolog to vfs and mark as lock-safe The upstream has added some warning around repo.svfs/vfs write operations without taking locks. For undo, we don't want to take the repo lock (since that means read-only operations like `hg log` will be blocked by another `hg commit`). So undo has its own locking and own transaction (for lower overhead). Therefore move all files we may write (including lock and transaction files) to `.hg/undolog` and whitelist the directory at `localrepository._wlockfreeprefix` to bypass the checks. Differential Revision: https://phab.mercurial-scm.org/D112
2017-07-18 21:30:05 +03:00
$ hg debugdata .hg/undolog/bookmarks.i 2
undo: amend transacts twice Summary: amend performs two transactions, second without command which breaks our assertion, but possibly isn't an issue. This fixes the assertion. Test Plan: unit tests Reviewers: #mercurial, stash, quark Reviewed By: quark Subscribers: quark, stash, medson, mjpieters Differential Revision: https://phabricator.intern.facebook.com/D5326358 Tasks: 19261492 Signature: t1:5326358:1498684945:0fde1df243cdbac67ceb092d30599ebd56a731a5
2017-06-29 01:28:40 +03:00
master df4fd610a3d6ca792281e7576587fa18f940d37a (no-eol)
undo: move undolog to vfs and mark as lock-safe The upstream has added some warning around repo.svfs/vfs write operations without taking locks. For undo, we don't want to take the repo lock (since that means read-only operations like `hg log` will be blocked by another `hg commit`). So undo has its own locking and own transaction (for lower overhead). Therefore move all files we may write (including lock and transaction files) to `.hg/undolog` and whitelist the directory at `localrepository._wlockfreeprefix` to bypass the checks. Differential Revision: https://phab.mercurial-scm.org/D112
2017-07-18 21:30:05 +03:00
$ hg debugdata .hg/undolog/workingparent.i 0
undo: store op history Summary: Store basic operational history: bookmarks, commands, private heads, date and working copy parent Test Plan: Unit tests Reviewers: durham, #mercurial, mitrandir, quark Reviewed By: quark Subscribers: stash, mitrandir Differential Revision: https://phabricator.intern.facebook.com/D5293596 Tasks: 19261492, 19563903, 19450726 Tags: Hg Undo Signature: t1:5293596:1498245082:264e344054ee5061a439dec1c6071c2a60ffcf55
2017-06-23 22:19:09 +03:00
0000000000000000000000000000000000000000 (no-eol)
undo: move undolog to vfs and mark as lock-safe The upstream has added some warning around repo.svfs/vfs write operations without taking locks. For undo, we don't want to take the repo lock (since that means read-only operations like `hg log` will be blocked by another `hg commit`). So undo has its own locking and own transaction (for lower overhead). Therefore move all files we may write (including lock and transaction files) to `.hg/undolog` and whitelist the directory at `localrepository._wlockfreeprefix` to bypass the checks. Differential Revision: https://phab.mercurial-scm.org/D112
2017-07-18 21:30:05 +03:00
$ hg debugdata .hg/undolog/workingparent.i 1
undo: store op history Summary: Store basic operational history: bookmarks, commands, private heads, date and working copy parent Test Plan: Unit tests Reviewers: durham, #mercurial, mitrandir, quark Reviewed By: quark Subscribers: stash, mitrandir Differential Revision: https://phabricator.intern.facebook.com/D5293596 Tasks: 19261492, 19563903, 19450726 Tags: Hg Undo Signature: t1:5293596:1498245082:264e344054ee5061a439dec1c6071c2a60ffcf55
2017-06-23 22:19:09 +03:00
df4fd610a3d6ca792281e7576587fa18f940d37a (no-eol)
undo: move undolog to vfs and mark as lock-safe The upstream has added some warning around repo.svfs/vfs write operations without taking locks. For undo, we don't want to take the repo lock (since that means read-only operations like `hg log` will be blocked by another `hg commit`). So undo has its own locking and own transaction (for lower overhead). Therefore move all files we may write (including lock and transaction files) to `.hg/undolog` and whitelist the directory at `localrepository._wlockfreeprefix` to bypass the checks. Differential Revision: https://phab.mercurial-scm.org/D112
2017-07-18 21:30:05 +03:00
$ hg debugdata .hg/undolog/draftheads.i 1
undo: store op history Summary: Store basic operational history: bookmarks, commands, private heads, date and working copy parent Test Plan: Unit tests Reviewers: durham, #mercurial, mitrandir, quark Reviewed By: quark Subscribers: stash, mitrandir Differential Revision: https://phabricator.intern.facebook.com/D5293596 Tasks: 19261492, 19563903, 19450726 Tags: Hg Undo Signature: t1:5293596:1498245082:264e344054ee5061a439dec1c6071c2a60ffcf55
2017-06-23 22:19:09 +03:00
df4fd610a3d6ca792281e7576587fa18f940d37a (no-eol)
undo: move undolog to vfs and mark as lock-safe The upstream has added some warning around repo.svfs/vfs write operations without taking locks. For undo, we don't want to take the repo lock (since that means read-only operations like `hg log` will be blocked by another `hg commit`). So undo has its own locking and own transaction (for lower overhead). Therefore move all files we may write (including lock and transaction files) to `.hg/undolog` and whitelist the directory at `localrepository._wlockfreeprefix` to bypass the checks. Differential Revision: https://phab.mercurial-scm.org/D112
2017-07-18 21:30:05 +03:00
$ hg debugdata .hg/undolog/draftheads.i 2
undo: store op history Summary: Store basic operational history: bookmarks, commands, private heads, date and working copy parent Test Plan: Unit tests Reviewers: durham, #mercurial, mitrandir, quark Reviewed By: quark Subscribers: stash, mitrandir Differential Revision: https://phabricator.intern.facebook.com/D5293596 Tasks: 19261492, 19563903, 19450726 Tags: Hg Undo Signature: t1:5293596:1498245082:264e344054ee5061a439dec1c6071c2a60ffcf55
2017-06-23 22:19:09 +03:00
b68836a6e2cac33ba33a20249b85a486eec78186 (no-eol)
undo: move undolog to vfs and mark as lock-safe The upstream has added some warning around repo.svfs/vfs write operations without taking locks. For undo, we don't want to take the repo lock (since that means read-only operations like `hg log` will be blocked by another `hg commit`). So undo has its own locking and own transaction (for lower overhead). Therefore move all files we may write (including lock and transaction files) to `.hg/undolog` and whitelist the directory at `localrepository._wlockfreeprefix` to bypass the checks. Differential Revision: https://phab.mercurial-scm.org/D112
2017-07-18 21:30:05 +03:00
$ hg debugdata .hg/undolog/index.i 1
undo: amend transacts twice Summary: amend performs two transactions, second without command which breaks our assertion, but possibly isn't an issue. This fixes the assertion. Test Plan: unit tests Reviewers: #mercurial, stash, quark Reviewed By: quark Subscribers: quark, stash, medson, mjpieters Differential Revision: https://phabricator.intern.facebook.com/D5326358 Tasks: 19261492 Signature: t1:5326358:1498684945:0fde1df243cdbac67ceb092d30599ebd56a731a5
2017-06-29 01:28:40 +03:00
bookmarks 8153d44860d076e9c328951c8f36cf8daebe695a
undo: don't break when undo isn't first argument Undo commands where undo wasn't first, for example `hg --pager=off undo` break multiple things, including hg redo. This change fixes this. Differential Revision: https://phab.mercurial-scm.org/D396
2017-08-16 02:56:25 +03:00
command bae41a9d0ae9614fc3aa843a0f5cbdf47bc98c43
undo: store op history Summary: Store basic operational history: bookmarks, commands, private heads, date and working copy parent Test Plan: Unit tests Reviewers: durham, #mercurial, mitrandir, quark Reviewed By: quark Subscribers: stash, mitrandir Differential Revision: https://phabricator.intern.facebook.com/D5293596 Tasks: 19261492, 19563903, 19450726 Tags: Hg Undo Signature: t1:5293596:1498245082:264e344054ee5061a439dec1c6071c2a60ffcf55
2017-06-23 22:19:09 +03:00
date * (glob)
undo: amend transacts twice Summary: amend performs two transactions, second without command which breaks our assertion, but possibly isn't an issue. This fixes the assertion. Test Plan: unit tests Reviewers: #mercurial, stash, quark Reviewed By: quark Subscribers: quark, stash, medson, mjpieters Differential Revision: https://phabricator.intern.facebook.com/D5326358 Tasks: 19261492 Signature: t1:5326358:1498684945:0fde1df243cdbac67ceb092d30599ebd56a731a5
2017-06-29 01:28:40 +03:00
draftheads b80de5d138758541c5f05265ad144ab9fa86d1db
undo: draft obsolete handling Obsoleted commits may be visible. To make sure that they are un-obsoleted after undo when appropriate, we add "draft() & obsolete()" recording. The most common case where this matters is undoing a mid stack amend. Differential Revision: https://phab.mercurial-scm.org/D438
2017-08-18 21:40:18 +03:00
draftobsolete b80de5d138758541c5f05265ad144ab9fa86d1db
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
unfinished False
undo: amend transacts twice Summary: amend performs two transactions, second without command which breaks our assertion, but possibly isn't an issue. This fixes the assertion. Test Plan: unit tests Reviewers: #mercurial, stash, quark Reviewed By: quark Subscribers: quark, stash, medson, mjpieters Differential Revision: https://phabricator.intern.facebook.com/D5326358 Tasks: 19261492 Signature: t1:5326358:1498684945:0fde1df243cdbac67ceb092d30599ebd56a731a5
2017-06-29 01:28:40 +03:00
workingparent fcb754f6a51eaf982f66d0637b39f3d2e6b520d5 (no-eol)
$ touch a3 && hg add a3
$ hg commit --amend
undo: move undolog to vfs and mark as lock-safe The upstream has added some warning around repo.svfs/vfs write operations without taking locks. For undo, we don't want to take the repo lock (since that means read-only operations like `hg log` will be blocked by another `hg commit`). So undo has its own locking and own transaction (for lower overhead). Therefore move all files we may write (including lock and transaction files) to `.hg/undolog` and whitelist the directory at `localrepository._wlockfreeprefix` to bypass the checks. Differential Revision: https://phab.mercurial-scm.org/D112
2017-07-18 21:30:05 +03:00
$ hg debugdata .hg/undolog/command.i 11
undo: don't break when undo isn't first argument Undo commands where undo wasn't first, for example `hg --pager=off undo` break multiple things, including hg redo. This change fixes this. Differential Revision: https://phab.mercurial-scm.org/D396
2017-08-16 02:56:25 +03:00
commit\x00commit\x00--amend (no-eol) (esc)
undo: allow user to list or see details about undoable commands run Summary: add hg debugundohistory -l to view recent undoable transactions Test Plan: unit test Reviewers: #mercurial, stash, quark Reviewed By: quark Subscribers: quark, mitrandir, durham, stash, medson, mjpieters Differential Revision: https://phabricator.intern.facebook.com/D5325772 Tasks: 19646287 Signature: t1:5325772:1499122626:48dd25cee8ed8912c07a6c1dabb3d4286483a8b7
2017-07-04 05:01:09 +03:00
Test debugundohistory
$ hg debugundohistory -l
0: commit --amend
1: ci -md
2: book feature2
3: ci -mc2
4: ci -mc1
$ hg update master
0 files updated, 0 files merged, 2 files removed, 0 files unresolved
(activating bookmark master)
$ echo "test" >> a1
$ hg commit -m "words"
$ hg debugundohistory -l
0: commit -m words
1: update master
2: commit --amend
3: ci -md
4: book feature2
$ hg debugundohistory -n 0
command:
commit -m words
bookmarks:
feature1 49cdb4091aca3c09f402ff001cd20cf086873683
feature2 296fda51a303650465d07a1cd054075cbe6d3cbd
master 0a3dd3e15e65b90836f492112d816f3ee073d897
date:
* (glob)
draftheads:
ADDED:
0a3dd3e15e65b90836f492112d816f3ee073d897
REMOVED:
undo: draft obsolete handling Obsoleted commits may be visible. To make sure that they are un-obsoleted after undo when appropriate, we add "draft() & obsolete()" recording. The most common case where this matters is undoing a mid stack amend. Differential Revision: https://phab.mercurial-scm.org/D438
2017-08-18 21:40:18 +03:00
draftobsolete:
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
unfinished: False
undo: allow user to list or see details about undoable commands run Summary: add hg debugundohistory -l to view recent undoable transactions Test Plan: unit test Reviewers: #mercurial, stash, quark Reviewed By: quark Subscribers: quark, mitrandir, durham, stash, medson, mjpieters Differential Revision: https://phabricator.intern.facebook.com/D5325772 Tasks: 19646287 Signature: t1:5325772:1499122626:48dd25cee8ed8912c07a6c1dabb3d4286483a8b7
2017-07-04 05:01:09 +03:00
Test gap in data (extension dis and enabled)
$ hg debugundohistory -l
0: commit -m words
1: update master
2: commit --amend
3: ci -md
4: book feature2
$ cat >> $HGRCPATH <<EOF
> [extensions]
> undo =!
> EOF
$ touch cmiss && hg add cmiss && hg ci -mcmiss
$ cat >>$HGRCPATH <<EOF
> [extensions]
fb-hgext: fix copied fb-hgext tests Summary: This is a big bulk of generally almost-obvious fixes to the moved tests. Mostly these fixes have to do with correct importing of the actual extensions. Depends on D6675329 Test Plan: - ./run-tests.py fails less after this commit - see further commits for more test fixes Reviewers: #sourcecontrol Differential Revision: https://phabricator.intern.facebook.com/D6675344
2018-01-09 14:06:09 +03:00
> undo=
undo: allow user to list or see details about undoable commands run Summary: add hg debugundohistory -l to view recent undoable transactions Test Plan: unit test Reviewers: #mercurial, stash, quark Reviewed By: quark Subscribers: quark, mitrandir, durham, stash, medson, mjpieters Differential Revision: https://phabricator.intern.facebook.com/D5325772 Tasks: 19646287 Signature: t1:5325772:1499122626:48dd25cee8ed8912c07a6c1dabb3d4286483a8b7
2017-07-04 05:01:09 +03:00
> EOF
$ touch a5 && hg add a5 && hg ci -ma5
$ hg debugundohistory -l
0: ci -ma5
undo: improved performance and prep for hg undo Implements lighttransaction(repo) which improves performance of hg undo and prevents infinite loops caused by hooks that run true hg commands. Also adds _getrevlog and _invertindex commands, factoring out code that will be reused. Changes output for gaps when typing hg debugundohistory -l for slightly better ui and clearer testing. Lastly, changes lock from repo lock to new undolog lock and tests this. In the future, with some changes to undo.log, we may be able to take the lock later, bypassing the need to take it for read-only operations. Differential Revision: https://phab.mercurial-scm.org/D50
2017-07-17 23:18:54 +03:00
1: -- gap in log --
undo: allow user to list or see details about undoable commands run Summary: add hg debugundohistory -l to view recent undoable transactions Test Plan: unit test Reviewers: #mercurial, stash, quark Reviewed By: quark Subscribers: quark, mitrandir, durham, stash, medson, mjpieters Differential Revision: https://phabricator.intern.facebook.com/D5325772 Tasks: 19646287 Signature: t1:5325772:1499122626:48dd25cee8ed8912c07a6c1dabb3d4286483a8b7
2017-07-04 05:01:09 +03:00
2: commit -m words
3: update master
4: commit --amend
$ hg debugundohistory 1
command:
unkown command(s) run, gap in log
bookmarks:
feature1 49cdb4091aca3c09f402ff001cd20cf086873683
feature2 296fda51a303650465d07a1cd054075cbe6d3cbd
master 1dafc0b436123cab96f82a8e9e8d1d42c0301aaa
date:
* (glob)
draftheads:
ADDED:
1dafc0b436123cab96f82a8e9e8d1d42c0301aaa
REMOVED:
0a3dd3e15e65b90836f492112d816f3ee073d897
undo: draft obsolete handling Obsoleted commits may be visible. To make sure that they are un-obsoleted after undo when appropriate, we add "draft() & obsolete()" recording. The most common case where this matters is undoing a mid stack amend. Differential Revision: https://phab.mercurial-scm.org/D438
2017-08-18 21:40:18 +03:00
draftobsolete:
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
unfinished: False
undo: allow user to list or see details about undoable commands run Summary: add hg debugundohistory -l to view recent undoable transactions Test Plan: unit test Reviewers: #mercurial, stash, quark Reviewed By: quark Subscribers: quark, mitrandir, durham, stash, medson, mjpieters Differential Revision: https://phabricator.intern.facebook.com/D5325772 Tasks: 19646287 Signature: t1:5325772:1499122626:48dd25cee8ed8912c07a6c1dabb3d4286483a8b7
2017-07-04 05:01:09 +03:00
Index out of bound error
$ hg debugundohistory -n 50
abort: index out of bounds
[255]
undo: deal with --hidden flag edge case Summary: Makes sure repo is filtered by the "visible" filter which hides hidden commits. Otherwise --hidden flag can mass up "draftheads" storage. Test Plan: Added a new test case. Reviewers: #mercurial, quark Reviewed By: quark Subscribers: quark, medson, mjpieters Differential Revision: https://phabricator.intern.facebook.com/D5357222 Tasks: 19822306 Signature: t1:5357222:1499102417:ce78065d36841601fe0dfb1d615d7b3be28c5870
2017-07-04 05:01:09 +03:00
Revset tests
undo: improved performance and prep for hg undo Implements lighttransaction(repo) which improves performance of hg undo and prevents infinite loops caused by hooks that run true hg commands. Also adds _getrevlog and _invertindex commands, factoring out code that will be reused. Changes output for gaps when typing hg debugundohistory -l for slightly better ui and clearer testing. Lastly, changes lock from repo lock to new undolog lock and tests this. In the future, with some changes to undo.log, we may be able to take the lock later, bypassing the need to take it for read-only operations. Differential Revision: https://phab.mercurial-scm.org/D50
2017-07-17 23:18:54 +03:00
$ hg log -G -r 'draft()' --hidden > /dev/null
undo: deal with --hidden flag edge case Summary: Makes sure repo is filtered by the "visible" filter which hides hidden commits. Otherwise --hidden flag can mass up "draftheads" storage. Test Plan: Added a new test case. Reviewers: #mercurial, quark Reviewed By: quark Subscribers: quark, medson, mjpieters Differential Revision: https://phabricator.intern.facebook.com/D5357222 Tasks: 19822306 Signature: t1:5357222:1499102417:ce78065d36841601fe0dfb1d615d7b3be28c5870
2017-07-04 05:01:09 +03:00
$ hg debugundohistory -n 0
command:
undo: add olddraft revset to return previous drafts Summary: Register `olddraft([index])` revset returning draft changesets using undo data. Test Plan: unit tests Reviewers: stash, #mercurial, quark Reviewed By: quark Subscribers: mitrandir, quark, medson, mjpieters Differential Revision: https://phabricator.intern.facebook.com/D5359322 Tasks: 19646287, 19261492 Signature: t1:5359322:1499122771:0a1e952a9bb4cd6b31d95a229ccb398cd6aafd1f
2017-07-04 05:01:09 +03:00
ci -ma5
undo: deal with --hidden flag edge case Summary: Makes sure repo is filtered by the "visible" filter which hides hidden commits. Otherwise --hidden flag can mass up "draftheads" storage. Test Plan: Added a new test case. Reviewers: #mercurial, quark Reviewed By: quark Subscribers: quark, medson, mjpieters Differential Revision: https://phabricator.intern.facebook.com/D5357222 Tasks: 19822306 Signature: t1:5357222:1499102417:ce78065d36841601fe0dfb1d615d7b3be28c5870
2017-07-04 05:01:09 +03:00
bookmarks:
feature1 49cdb4091aca3c09f402ff001cd20cf086873683
feature2 296fda51a303650465d07a1cd054075cbe6d3cbd
undo: add olddraft revset to return previous drafts Summary: Register `olddraft([index])` revset returning draft changesets using undo data. Test Plan: unit tests Reviewers: stash, #mercurial, quark Reviewed By: quark Subscribers: mitrandir, quark, medson, mjpieters Differential Revision: https://phabricator.intern.facebook.com/D5359322 Tasks: 19646287, 19261492 Signature: t1:5359322:1499122771:0a1e952a9bb4cd6b31d95a229ccb398cd6aafd1f
2017-07-04 05:01:09 +03:00
master aa430c8afedf9b2ec3f0655d39eef6b6b0a2ddb6
undo: deal with --hidden flag edge case Summary: Makes sure repo is filtered by the "visible" filter which hides hidden commits. Otherwise --hidden flag can mass up "draftheads" storage. Test Plan: Added a new test case. Reviewers: #mercurial, quark Reviewed By: quark Subscribers: quark, medson, mjpieters Differential Revision: https://phabricator.intern.facebook.com/D5357222 Tasks: 19822306 Signature: t1:5357222:1499102417:ce78065d36841601fe0dfb1d615d7b3be28c5870
2017-07-04 05:01:09 +03:00
date:
* (glob)
draftheads:
ADDED:
undo: add olddraft revset to return previous drafts Summary: Register `olddraft([index])` revset returning draft changesets using undo data. Test Plan: unit tests Reviewers: stash, #mercurial, quark Reviewed By: quark Subscribers: mitrandir, quark, medson, mjpieters Differential Revision: https://phabricator.intern.facebook.com/D5359322 Tasks: 19646287, 19261492 Signature: t1:5359322:1499122771:0a1e952a9bb4cd6b31d95a229ccb398cd6aafd1f
2017-07-04 05:01:09 +03:00
aa430c8afedf9b2ec3f0655d39eef6b6b0a2ddb6
undo: deal with --hidden flag edge case Summary: Makes sure repo is filtered by the "visible" filter which hides hidden commits. Otherwise --hidden flag can mass up "draftheads" storage. Test Plan: Added a new test case. Reviewers: #mercurial, quark Reviewed By: quark Subscribers: quark, medson, mjpieters Differential Revision: https://phabricator.intern.facebook.com/D5357222 Tasks: 19822306 Signature: t1:5357222:1499102417:ce78065d36841601fe0dfb1d615d7b3be28c5870
2017-07-04 05:01:09 +03:00
REMOVED:
undo: add olddraft revset to return previous drafts Summary: Register `olddraft([index])` revset returning draft changesets using undo data. Test Plan: unit tests Reviewers: stash, #mercurial, quark Reviewed By: quark Subscribers: mitrandir, quark, medson, mjpieters Differential Revision: https://phabricator.intern.facebook.com/D5359322 Tasks: 19646287, 19261492 Signature: t1:5359322:1499122771:0a1e952a9bb4cd6b31d95a229ccb398cd6aafd1f
2017-07-04 05:01:09 +03:00
1dafc0b436123cab96f82a8e9e8d1d42c0301aaa
undo: draft obsolete handling Obsoleted commits may be visible. To make sure that they are un-obsoleted after undo when appropriate, we add "draft() & obsolete()" recording. The most common case where this matters is undoing a mid stack amend. Differential Revision: https://phab.mercurial-scm.org/D438
2017-08-18 21:40:18 +03:00
draftobsolete:
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
unfinished: False
undo: add olddraft revset to return previous drafts Summary: Register `olddraft([index])` revset returning draft changesets using undo data. Test Plan: unit tests Reviewers: stash, #mercurial, quark Reviewed By: quark Subscribers: mitrandir, quark, medson, mjpieters Differential Revision: https://phabricator.intern.facebook.com/D5359322 Tasks: 19646287, 19261492 Signature: t1:5359322:1499122771:0a1e952a9bb4cd6b31d95a229ccb398cd6aafd1f
2017-07-04 05:01:09 +03:00
Test 'olddraft([NUM])' revset
$ hg log -G -r 'olddraft(0) - olddraft(1)' --hidden -T compact
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
@ 9[tip][master] aa430c8afedf 1970-01-01 00:00 +0000 test
undo: add olddraft revset to return previous drafts Summary: Register `olddraft([index])` revset returning draft changesets using undo data. Test Plan: unit tests Reviewers: stash, #mercurial, quark Reviewed By: quark Subscribers: mitrandir, quark, medson, mjpieters Differential Revision: https://phabricator.intern.facebook.com/D5359322 Tasks: 19646287, 19261492 Signature: t1:5359322:1499122771:0a1e952a9bb4cd6b31d95a229ccb398cd6aafd1f
2017-07-04 05:01:09 +03:00
| a5
~
undo: localbranch revset Adds localbranch revset to be used for localbranch undos. A localbranch is a set of draft commits that are connected via draft commits. Any draft commit within a branch, or a public commit at the base of the branch, can be passed as an argument to localbranch(). This will be necessary for selecting the scope for a localbranch undo. Also fixes oldraft() output when used with other revsets. Previously olddraft() would ignore operators such as and because of a missing the necessary handling. Differential Revision: https://phab.mercurial-scm.org/D159
2017-08-04 01:17:21 +03:00
$ hg log -G -r 'olddraft(1) and draft()' -T compact
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 8 1dafc0b43612 1970-01-01 00:00 +0000 test
undo: localbranch revset Adds localbranch revset to be used for localbranch undos. A localbranch is a set of draft commits that are connected via draft commits. Any draft commit within a branch, or a public commit at the base of the branch, can be passed as an argument to localbranch(). This will be necessary for selecting the scope for a localbranch undo. Also fixes oldraft() output when used with other revsets. Previously olddraft() would ignore operators such as and because of a missing the necessary handling. Differential Revision: https://phab.mercurial-scm.org/D159
2017-08-04 01:17:21 +03:00
| cmiss
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 7:4 0a3dd3e15e65 1970-01-01 00:00 +0000 test
undo: localbranch revset Adds localbranch revset to be used for localbranch undos. A localbranch is a set of draft commits that are connected via draft commits. Any draft commit within a branch, or a public commit at the base of the branch, can be passed as an argument to localbranch(). This will be necessary for selecting the scope for a localbranch undo. Also fixes oldraft() output when used with other revsets. Previously olddraft() would ignore operators such as and because of a missing the necessary handling. Differential Revision: https://phab.mercurial-scm.org/D159
2017-08-04 01:17:21 +03:00
| words
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
| o 6[feature2]:4 296fda51a303 1970-01-01 00:00 +0000 test
undo: localbranch revset Adds localbranch revset to be used for localbranch undos. A localbranch is a set of draft commits that are connected via draft commits. Any draft commit within a branch, or a public commit at the base of the branch, can be passed as an argument to localbranch(). This will be necessary for selecting the scope for a localbranch undo. Also fixes oldraft() output when used with other revsets. Previously olddraft() would ignore operators such as and because of a missing the necessary handling. Differential Revision: https://phab.mercurial-scm.org/D159
2017-08-04 01:17:21 +03:00
|/ d
|
o 4 38d85b506754 1970-01-01 00:00 +0000 test
| c2
|
o 3:1 ec7553f7b382 1970-01-01 00:00 +0000 test
| c1
|
| o 2[feature1] 49cdb4091aca 1970-01-01 00:00 +0000 test
|/ b
|
o 1 b68836a6e2ca 1970-01-01 00:00 +0000 test
| a2
|
o 0 df4fd610a3d6 1970-01-01 00:00 +0000 test
a1
$ hg log -G -r 'olddraft(1) and public()' -T compact
undo: improved performance and prep for hg undo Implements lighttransaction(repo) which improves performance of hg undo and prevents infinite loops caused by hooks that run true hg commands. Also adds _getrevlog and _invertindex commands, factoring out code that will be reused. Changes output for gaps when typing hg debugundohistory -l for slightly better ui and clearer testing. Lastly, changes lock from repo lock to new undolog lock and tests this. In the future, with some changes to undo.log, we may be able to take the lock later, bypassing the need to take it for read-only operations. Differential Revision: https://phab.mercurial-scm.org/D50
2017-07-17 23:18:54 +03:00
Test undolog lock
undo: do not run undolog for every command Previously, undolog runs for every command, which sometimes adds unwanted noticeable overhead like `hg status` with a large obsstore. This patch makes undo smarter to only log commands that actually write things. This is done by making undolog only run for transactions, updates (legacy code that does not require a transaction). Tests are changed to reflect `hg status` does not trigger undolog, and the new code seems to work better with chg. Differential Revision: https://phab.mercurial-scm.org/D739
2017-09-22 00:38:43 +03:00
$ cat > $TESTTMP/noopupdate.py <<EOF
> from __future__ import absolute_import
perftweaks: move commit head detection removal logic to core Summary: Also change the internal API so it no longer accepts the "heads" argument. Reviewed By: ryanmce Differential Revision: D6745865 fbshipit-source-id: 368742be49b192f7630421003552d0a10eb0b76d
2018-01-23 23:08:19 +03:00
> from mercurial import encoding, merge, registrar
undo: do not run undolog for every command Previously, undolog runs for every command, which sometimes adds unwanted noticeable overhead like `hg status` with a large obsstore. This patch makes undo smarter to only log commands that actually write things. This is done by making undolog only run for transactions, updates (legacy code that does not require a transaction). Tests are changed to reflect `hg status` does not trigger undolog, and the new code seems to work better with chg. Differential Revision: https://phab.mercurial-scm.org/D739
2017-09-22 00:38:43 +03:00
> cmdtable = {}
> command = registrar.command(cmdtable)
> def uisetup(ui):
> merge.update = lambda *args, **kwargs: None
> @command('noopupdate')
> def noopupdate(ui, repo):
> """do nothing, but triggers an undolog write"""
> merge.update(repo, repo['.'], False, False)
> EOF
$ hg noopupdate --config extensions.noopupdate=$TESTTMP/noopupdate.py --config hooks.duringundologlock="sleep 2" > /dev/null &
give "hg noop" some time to reach the code obtaining the undolog lock
$ sleep 0.2
"hg status" does not trigger undolog writing
$ hg status --time
time: real 0* (glob)
"hg noopupdate" trigger undolog writing and it needs to wait
$ hg noopupdate --config extensions.noopupdate=$TESTTMP/noopupdate.py --time
time: real [1-9]\..* (re)
undo: implements relative undo, hg redo and tests Implements, and makes default relative undos and adds redos. A relative undo behaves differently only if you haven't performend any repo changing operations since your previous undo or redo, in which case you operate relative to that undo/redo. This means that a second undo will not undo the previous undo but instead bring you furter back. Differential Revision: https://phab.mercurial-scm.org/D52
2017-07-20 03:49:21 +03:00
hg undo command tests
$ hg undo
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before ci -ma5 (glob)
undo: implements relative undo, hg redo and tests Implements, and makes default relative undos and adds redos. A relative undo behaves differently only if you haven't performend any repo changing operations since your previous undo or redo, in which case you operate relative to that undo/redo. This means that a second undo will not undo the previous undo but instead bring you furter back. Differential Revision: https://phab.mercurial-scm.org/D52
2017-07-20 03:49:21 +03:00
$ hg log -G -T compact -l2
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
@ 8[tip][master] 1dafc0b43612 1970-01-01 00:00 +0000 test
undo: implements relative undo, hg redo and tests Implements, and makes default relative undos and adds redos. A relative undo behaves differently only if you haven't performend any repo changing operations since your previous undo or redo, in which case you operate relative to that undo/redo. This means that a second undo will not undo the previous undo but instead bring you furter back. Differential Revision: https://phab.mercurial-scm.org/D52
2017-07-20 03:49:21 +03:00
| cmiss
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 7:4 0a3dd3e15e65 1970-01-01 00:00 +0000 test
undo: implements relative undo, hg redo and tests Implements, and makes default relative undos and adds redos. A relative undo behaves differently only if you haven't performend any repo changing operations since your previous undo or redo, in which case you operate relative to that undo/redo. This means that a second undo will not undo the previous undo but instead bring you furter back. Differential Revision: https://phab.mercurial-scm.org/D52
2017-07-20 03:49:21 +03:00
| words
~
$ hg update 0a3dd3e15e65
0 files updated, 0 files merged, 1 files removed, 0 files unresolved
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
(leaving bookmark master)
undo: implements relative undo, hg redo and tests Implements, and makes default relative undos and adds redos. A relative undo behaves differently only if you haven't performend any repo changing operations since your previous undo or redo, in which case you operate relative to that undo/redo. This means that a second undo will not undo the previous undo but instead bring you furter back. Differential Revision: https://phab.mercurial-scm.org/D52
2017-07-20 03:49:21 +03:00
$ hg undo
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before update 0a3dd3e15e65 (glob)
undo: implements relative undo, hg redo and tests Implements, and makes default relative undos and adds redos. A relative undo behaves differently only if you haven't performend any repo changing operations since your previous undo or redo, in which case you operate relative to that undo/redo. This means that a second undo will not undo the previous undo but instead bring you furter back. Differential Revision: https://phab.mercurial-scm.org/D52
2017-07-20 03:49:21 +03:00
$ hg log -G -T compact -l1
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
@ 8[tip][master] 1dafc0b43612 1970-01-01 00:00 +0000 test
undo: implements relative undo, hg redo and tests Implements, and makes default relative undos and adds redos. A relative undo behaves differently only if you haven't performend any repo changing operations since your previous undo or redo, in which case you operate relative to that undo/redo. This means that a second undo will not undo the previous undo but instead bring you furter back. Differential Revision: https://phab.mercurial-scm.org/D52
2017-07-20 03:49:21 +03:00
| cmiss
~
$ touch c11 && hg add c11
$ hg commit --amend
$ hg log -G -T compact -l1
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
@ 10[tip][master]:7 2dca609174c2 1970-01-01 00:00 +0000 test
undo: implements relative undo, hg redo and tests Implements, and makes default relative undos and adds redos. A relative undo behaves differently only if you haven't performend any repo changing operations since your previous undo or redo, in which case you operate relative to that undo/redo. This means that a second undo will not undo the previous undo but instead bring you furter back. Differential Revision: https://phab.mercurial-scm.org/D52
2017-07-20 03:49:21 +03:00
| cmiss
~
$ hg undo
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before commit --amend (glob)
undo: implements relative undo, hg redo and tests Implements, and makes default relative undos and adds redos. A relative undo behaves differently only if you haven't performend any repo changing operations since your previous undo or redo, in which case you operate relative to that undo/redo. This means that a second undo will not undo the previous undo but instead bring you furter back. Differential Revision: https://phab.mercurial-scm.org/D52
2017-07-20 03:49:21 +03:00
$ hg log -G -T compact -l4
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
@ 8[tip][master] 1dafc0b43612 1970-01-01 00:00 +0000 test
undo: implements relative undo, hg redo and tests Implements, and makes default relative undos and adds redos. A relative undo behaves differently only if you haven't performend any repo changing operations since your previous undo or redo, in which case you operate relative to that undo/redo. This means that a second undo will not undo the previous undo but instead bring you furter back. Differential Revision: https://phab.mercurial-scm.org/D52
2017-07-20 03:49:21 +03:00
| cmiss
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 7:4 0a3dd3e15e65 1970-01-01 00:00 +0000 test
undo: implements relative undo, hg redo and tests Implements, and makes default relative undos and adds redos. A relative undo behaves differently only if you haven't performend any repo changing operations since your previous undo or redo, in which case you operate relative to that undo/redo. This means that a second undo will not undo the previous undo but instead bring you furter back. Differential Revision: https://phab.mercurial-scm.org/D52
2017-07-20 03:49:21 +03:00
| words
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
| o 6[feature2]:4 296fda51a303 1970-01-01 00:00 +0000 test
undo: implements relative undo, hg redo and tests Implements, and makes default relative undos and adds redos. A relative undo behaves differently only if you haven't performend any repo changing operations since your previous undo or redo, in which case you operate relative to that undo/redo. This means that a second undo will not undo the previous undo but instead bring you furter back. Differential Revision: https://phab.mercurial-scm.org/D52
2017-07-20 03:49:21 +03:00
|/ d
|
o 4 38d85b506754 1970-01-01 00:00 +0000 test
| c2
~
$ hg graft 296fda51a303
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
grafting 6:296fda51a303 "d" (feature2)
undo: implements relative undo, hg redo and tests Implements, and makes default relative undos and adds redos. A relative undo behaves differently only if you haven't performend any repo changing operations since your previous undo or redo, in which case you operate relative to that undo/redo. This means that a second undo will not undo the previous undo but instead bring you furter back. Differential Revision: https://phab.mercurial-scm.org/D52
2017-07-20 03:49:21 +03:00
$ hg log -G -T compact -l2
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
@ 11[tip]:8 f007a7cf4c3d 1970-01-01 00:00 +0000 test
undo: implements relative undo, hg redo and tests Implements, and makes default relative undos and adds redos. A relative undo behaves differently only if you haven't performend any repo changing operations since your previous undo or redo, in which case you operate relative to that undo/redo. This means that a second undo will not undo the previous undo but instead bring you furter back. Differential Revision: https://phab.mercurial-scm.org/D52
2017-07-20 03:49:21 +03:00
| d
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 8[master] 1dafc0b43612 1970-01-01 00:00 +0000 test
undo: implements relative undo, hg redo and tests Implements, and makes default relative undos and adds redos. A relative undo behaves differently only if you haven't performend any repo changing operations since your previous undo or redo, in which case you operate relative to that undo/redo. This means that a second undo will not undo the previous undo but instead bring you furter back. Differential Revision: https://phab.mercurial-scm.org/D52
2017-07-20 03:49:21 +03:00
| cmiss
~
$ hg undo
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before graft 296fda51a303 (glob)
undo: implements relative undo, hg redo and tests Implements, and makes default relative undos and adds redos. A relative undo behaves differently only if you haven't performend any repo changing operations since your previous undo or redo, in which case you operate relative to that undo/redo. This means that a second undo will not undo the previous undo but instead bring you furter back. Differential Revision: https://phab.mercurial-scm.org/D52
2017-07-20 03:49:21 +03:00
$ hg log -G -T compact -l1
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
@ 8[tip][master] 1dafc0b43612 1970-01-01 00:00 +0000 test
undo: implements relative undo, hg redo and tests Implements, and makes default relative undos and adds redos. A relative undo behaves differently only if you haven't performend any repo changing operations since your previous undo or redo, in which case you operate relative to that undo/redo. This means that a second undo will not undo the previous undo but instead bring you furter back. Differential Revision: https://phab.mercurial-scm.org/D52
2017-07-20 03:49:21 +03:00
| cmiss
~
$ hg book test
$ hg undo
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before book test (glob)
undo: implements relative undo, hg redo and tests Implements, and makes default relative undos and adds redos. A relative undo behaves differently only if you haven't performend any repo changing operations since your previous undo or redo, in which case you operate relative to that undo/redo. This means that a second undo will not undo the previous undo but instead bring you furter back. Differential Revision: https://phab.mercurial-scm.org/D52
2017-07-20 03:49:21 +03:00
$ hg bookmarks
feature1 2:49cdb4091aca
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
feature2 6:296fda51a303
master 8:1dafc0b43612
undo: implements relative undo, hg redo and tests Implements, and makes default relative undos and adds redos. A relative undo behaves differently only if you haven't performend any repo changing operations since your previous undo or redo, in which case you operate relative to that undo/redo. This means that a second undo will not undo the previous undo but instead bring you furter back. Differential Revision: https://phab.mercurial-scm.org/D52
2017-07-20 03:49:21 +03:00
undo: better docs Strips docs of unnescerary info and sticks complex things behind --verbose flag. In most cases hg undo and redo or hg undo --preview should be enough for the user. Also changes --index to --step, which seems clearer. Differential Revision: https://phab.mercurial-scm.org/D287
2017-08-12 04:05:03 +03:00
hg undo with negative step
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
$ hg undo -n -1
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before undo (glob)
undo: implements relative undo, hg redo and tests Implements, and makes default relative undos and adds redos. A relative undo behaves differently only if you haven't performend any repo changing operations since your previous undo or redo, in which case you operate relative to that undo/redo. This means that a second undo will not undo the previous undo but instead bring you furter back. Differential Revision: https://phab.mercurial-scm.org/D52
2017-07-20 03:49:21 +03:00
$ hg log -G -T compact -l1
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
@ 8[tip][master,test] 1dafc0b43612 1970-01-01 00:00 +0000 test
undo: implements relative undo, hg redo and tests Implements, and makes default relative undos and adds redos. A relative undo behaves differently only if you haven't performend any repo changing operations since your previous undo or redo, in which case you operate relative to that undo/redo. This means that a second undo will not undo the previous undo but instead bring you furter back. Differential Revision: https://phab.mercurial-scm.org/D52
2017-07-20 03:49:21 +03:00
| cmiss
~
$ hg undo
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before book test (glob)
undo: implements relative undo, hg redo and tests Implements, and makes default relative undos and adds redos. A relative undo behaves differently only if you haven't performend any repo changing operations since your previous undo or redo, in which case you operate relative to that undo/redo. This means that a second undo will not undo the previous undo but instead bring you furter back. Differential Revision: https://phab.mercurial-scm.org/D52
2017-07-20 03:49:21 +03:00
$ hg log -G -T compact -l1
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
@ 8[tip][master] 1dafc0b43612 1970-01-01 00:00 +0000 test
undo: implements relative undo, hg redo and tests Implements, and makes default relative undos and adds redos. A relative undo behaves differently only if you haven't performend any repo changing operations since your previous undo or redo, in which case you operate relative to that undo/redo. This means that a second undo will not undo the previous undo but instead bring you furter back. Differential Revision: https://phab.mercurial-scm.org/D52
2017-07-20 03:49:21 +03:00
| cmiss
~
$ hg undo -n 5
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before undo (glob)
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
$ hg undo -n -5
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before book test (glob)
undo: implements relative undo, hg redo and tests Implements, and makes default relative undos and adds redos. A relative undo behaves differently only if you haven't performend any repo changing operations since your previous undo or redo, in which case you operate relative to that undo/redo. This means that a second undo will not undo the previous undo but instead bring you furter back. Differential Revision: https://phab.mercurial-scm.org/D52
2017-07-20 03:49:21 +03:00
$ hg log -G -T compact -l1
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
@ 8[tip][master] 1dafc0b43612 1970-01-01 00:00 +0000 test
undo: implements relative undo, hg redo and tests Implements, and makes default relative undos and adds redos. A relative undo behaves differently only if you haven't performend any repo changing operations since your previous undo or redo, in which case you operate relative to that undo/redo. This means that a second undo will not undo the previous undo but instead bring you furter back. Differential Revision: https://phab.mercurial-scm.org/D52
2017-07-20 03:49:21 +03:00
| cmiss
~
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
$ hg undo -n -100
undo: better error messaging and hiding hg serve commands In interactive mode, disables out of bounds <-,-> notifying the user with text and a '\a' sound. Friendlier ui messages for when the user selects the current state with the arrow keys or when trying to undo to a state before we recorded anything. Hg serve commands generally aren't user executed and simply should be skipped across when undoing (like unfinished states). The user can always use --absolute to see them in preview and to undo to them. Differential Revision: https://phab.mercurial-scm.org/D502
2017-08-24 22:29:40 +03:00
abort: cannot undo this far - undo extension was not enabled
undo: implements relative undo, hg redo and tests Implements, and makes default relative undos and adds redos. A relative undo behaves differently only if you haven't performend any repo changing operations since your previous undo or redo, in which case you operate relative to that undo/redo. This means that a second undo will not undo the previous undo but instead bring you furter back. Differential Revision: https://phab.mercurial-scm.org/D52
2017-07-20 03:49:21 +03:00
[255]
hg undo --absolute tests
$ hg undo -a
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before undo -n -5 (glob)
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
$ hg undo -n -1
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before undo -a (glob)
undo: implements relative undo, hg redo and tests Implements, and makes default relative undos and adds redos. A relative undo behaves differently only if you haven't performend any repo changing operations since your previous undo or redo, in which case you operate relative to that undo/redo. This means that a second undo will not undo the previous undo but instead bring you furter back. Differential Revision: https://phab.mercurial-scm.org/D52
2017-07-20 03:49:21 +03:00
$ hg undo -a
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before undo -n -1 (glob)
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
$ hg undo -n -1
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before undo -a (glob)
undo: implements relative undo, hg redo and tests Implements, and makes default relative undos and adds redos. A relative undo behaves differently only if you haven't performend any repo changing operations since your previous undo or redo, in which case you operate relative to that undo/redo. This means that a second undo will not undo the previous undo but instead bring you furter back. Differential Revision: https://phab.mercurial-scm.org/D52
2017-07-20 03:49:21 +03:00
$ hg undo -n 5
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before undo (glob)
undo: implements relative undo, hg redo and tests Implements, and makes default relative undos and adds redos. A relative undo behaves differently only if you haven't performend any repo changing operations since your previous undo or redo, in which case you operate relative to that undo/redo. This means that a second undo will not undo the previous undo but instead bring you furter back. Differential Revision: https://phab.mercurial-scm.org/D52
2017-07-20 03:49:21 +03:00
$ hg log -G -T compact -l1
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
@ 8[tip][master,test] 1dafc0b43612 1970-01-01 00:00 +0000 test
undo: implements relative undo, hg redo and tests Implements, and makes default relative undos and adds redos. A relative undo behaves differently only if you haven't performend any repo changing operations since your previous undo or redo, in which case you operate relative to that undo/redo. This means that a second undo will not undo the previous undo but instead bring you furter back. Differential Revision: https://phab.mercurial-scm.org/D52
2017-07-20 03:49:21 +03:00
| cmiss
~
$ hg undo -a
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before undo -n 5 (glob)
undo: implements relative undo, hg redo and tests Implements, and makes default relative undos and adds redos. A relative undo behaves differently only if you haven't performend any repo changing operations since your previous undo or redo, in which case you operate relative to that undo/redo. This means that a second undo will not undo the previous undo but instead bring you furter back. Differential Revision: https://phab.mercurial-scm.org/D52
2017-07-20 03:49:21 +03:00
$ hg log -G -T compact -l1
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
@ 8[tip][master] 1dafc0b43612 1970-01-01 00:00 +0000 test
undo: implements relative undo, hg redo and tests Implements, and makes default relative undos and adds redos. A relative undo behaves differently only if you haven't performend any repo changing operations since your previous undo or redo, in which case you operate relative to that undo/redo. This means that a second undo will not undo the previous undo but instead bring you furter back. Differential Revision: https://phab.mercurial-scm.org/D52
2017-07-20 03:49:21 +03:00
| cmiss
~
undo: adds -f flag and gap edge case handling Prevents users from accidentally crossing gaps in their history and adds an overwride. In most cases undoing across a gap isn't desired as the connection between the pre and post states is unkown. While undoing across a gap is not destructive or inherently risky, it is inherently confusing to the user since we don't know how many and what commands where run. Furthermore, there is no guarantee that the pre and post states of a gap are actually connected in any sane way. Differential Revision: https://phab.mercurial-scm.org/D53
2017-07-20 03:49:21 +03:00
hg undo --force tests
$ hg debugundohistory -l 18
18: undo
19: ci -ma5
20: -- gap in log --
21: commit -m words
22: update master
$ hg undo -a -n 25
abort: attempted risky undo across missing history
[255]
$ hg undo -a -n 25 -f
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before ci -md (glob)
undo: adds -f flag and gap edge case handling Prevents users from accidentally crossing gaps in their history and adds an overwride. In most cases undoing across a gap isn't desired as the connection between the pre and post states is unkown. While undoing across a gap is not destructive or inherently risky, it is inherently confusing to the user since we don't know how many and what commands where run. Furthermore, there is no guarantee that the pre and post states of a gap are actually connected in any sane way. Differential Revision: https://phab.mercurial-scm.org/D53
2017-07-20 03:49:21 +03:00
$ hg undo -a
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before undo -a -n 25 -f (glob)
undo: add --keep to maintian working copy changes Allow user to keep working copy changes after undo, mimicking unamend and uncommit behavior. As discussed at the team lunch, this allows undo to remain ignorant of what command the user has run while conforming to user expectations. In the future this could be done in a smarter way where we properly restore hg status dynamically. Differential Revision: https://phab.mercurial-scm.org/D55
2017-07-20 03:49:21 +03:00
hg undo --keep tests
$ touch kfl1 && hg add kfl1
$ hg st
A kfl1
$ hg commit --amend
$ hg st
$ hg undo --keep
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before commit --amend (glob)
undo: add --keep to maintian working copy changes Allow user to keep working copy changes after undo, mimicking unamend and uncommit behavior. As discussed at the team lunch, this allows undo to remain ignorant of what command the user has run while conforming to user expectations. In the future this could be done in a smarter way where we properly restore hg status dynamically. Differential Revision: https://phab.mercurial-scm.org/D55
2017-07-20 03:49:21 +03:00
$ hg st
A kfl1
undo: meaningful obs markers for undos Makes obs markers for undos more meaningful. When an undo performs a strict one to one change, the written obs marker reflects that and the user even gets a helpful ui message in smartlog. One to many undos do not support such obs markers (currently) because we can't tell splits and divergence apart easily. Differential Revision: https://phab.mercurial-scm.org/D108
2017-07-20 03:49:21 +03:00
$ hg commit --amend
hg undo informative obsmarkers
check 1 to 1 undos have informative obsmarker
check 1 to many undos (generally a redo of split or divergence) do not connect
the changesets with obsmarkers as we do not differentiate between split and
divergence cases in undo. The original split/divergence obsmarkers suffice for
checking split/divergence.
$ cat >> $HGRCPATH <<EOF
> [extensions]
fb-hgext: fix copied fb-hgext tests Summary: This is a big bulk of generally almost-obvious fixes to the moved tests. Mostly these fixes have to do with correct importing of the actual extensions. Depends on D6675329 Test Plan: - ./run-tests.py fails less after this commit - see further commits for more test fixes Reviewers: #sourcecontrol Differential Revision: https://phabricator.intern.facebook.com/D6675344
2018-01-09 14:06:09 +03:00
> smartlog=
> tweakdefaults=
> fbamend=
undo: meaningful obs markers for undos Makes obs markers for undos more meaningful. When an undo performs a strict one to one change, the written obs marker reflects that and the user even gets a helpful ui message in smartlog. One to many undos do not support such obs markers (currently) because we can't tell splits and divergence apart easily. Differential Revision: https://phab.mercurial-scm.org/D108
2017-07-20 03:49:21 +03:00
> EOF
$ hg undo
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before commit --amend (glob)
undo: meaningful obs markers for undos Makes obs markers for undos more meaningful. When an undo performs a strict one to one change, the written obs marker reflects that and the user even gets a helpful ui message in smartlog. One to many undos do not support such obs markers (currently) because we can't tell splits and divergence apart easily. Differential Revision: https://phab.mercurial-scm.org/D108
2017-07-20 03:49:21 +03:00
$ hg sl --all --hidden -T "{node|short} {if(undosuccessors, label('sl.undo', '(Undone as {join(undosuccessors% \'{shortest(undosuccessor, 6)}\', ', ')})'))}"
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
x f007a7cf4c3d
undo: meaningful obs markers for undos Makes obs markers for undos more meaningful. When an undo performs a strict one to one change, the written obs marker reflects that and the user even gets a helpful ui message in smartlog. One to many undos do not support such obs markers (currently) because we can't tell splits and divergence apart easily. Differential Revision: https://phab.mercurial-scm.org/D108
2017-07-20 03:49:21 +03:00
|
| x aa430c8afedf
|/
@ 1dafc0b43612
smartlog: always show latest public ancestor of draft commits Summary: Smartlog is supposed to show the latest public ancestor of all draft commits, however this doesn't always happen. The reason is a boundary error in the test for finding public commits. If the latest public ancestor is also the common ancestor (fairly normal), then it will be excluded. Reviewed By: quark-zju Differential Revision: D7140139 fbshipit-source-id: 6999f7ad14f86653ebe4d4f6543b9c7533871cf2
2018-03-05 16:20:44 +03:00
|
| x c9476255bc2a (Undone as 1dafc0, 1dafc0)
|/
| x 2dca609174c2 (Undone as 1dafc0)
|/
o 0a3dd3e15e65
|
| o 296fda51a303
|/
| x db92053d5c83
|/
o 38d85b506754
undo: meaningful obs markers for undos Makes obs markers for undos more meaningful. When an undo performs a strict one to one change, the written obs marker reflects that and the user even gets a helpful ui message in smartlog. One to many undos do not support such obs markers (currently) because we can't tell splits and divergence apart easily. Differential Revision: https://phab.mercurial-scm.org/D108
2017-07-20 03:49:21 +03:00
:
: o 49cdb4091aca
:/
o b68836a6e2ca
|
~
$ echo "a" >> newa && echo "b" >> newb && hg add newa newb && hg ci -m "newfiles"
$ hg split --quiet << EOF
> y
> y
> n
> y
> EOF
diff --git a/newa b/newa
new file mode 100644
examine changes to 'newa'? [Ynesfdaq?] y
@@ -0,0 +1,1 @@
+a
record change 1/2 to 'newa'? [Ynesfdaq?] y
diff --git a/newb b/newb
new file mode 100644
examine changes to 'newb'? [Ynesfdaq?] n
Done splitting? [yN] y
$ hg debugobsolete | tail -5
perftweaks: move effectflag removal logic to core Summary: This removes the effectflag logic from both core and perftweaks. Reviewed By: ryanmce Differential Revision: D6745769 fbshipit-source-id: 55ed1676e7117bca358471c256805ded7bc83f3c
2018-01-23 23:08:12 +03:00
1dafc0b436123cab96f82a8e9e8d1d42c0301aaa c9476255bc2a68672c844021397838ff4eeefcda 0 (Thu Jan 01 00:00:03 1970 +0000) {'operation': 'amend', 'user': 'test'}
c9476255bc2a68672c844021397838ff4eeefcda 1dafc0b436123cab96f82a8e9e8d1d42c0301aaa 0 (Thu Jan 01 00:00:04 1970 +0000) {'operation': 'undo', 'user': 'test'}
1dafc0b436123cab96f82a8e9e8d1d42c0301aaa c9476255bc2a68672c844021397838ff4eeefcda 0 (Thu Jan 01 00:00:05 1970 +0000) {'operation': 'amend', 'user': 'test'}
c9476255bc2a68672c844021397838ff4eeefcda 1dafc0b436123cab96f82a8e9e8d1d42c0301aaa 0 (Thu Jan 01 00:00:06 1970 +0000) {'operation': 'undo', 'user': 'test'}
f86734247df6db66a810e549cc938a72cd5c6d1a d0fdb9510dbf78c1a7e62c3e6628ff1f978f87ea 75f63379f12bf02d40fe7444587ad67be9ae81b8 0 (Thu Jan 01 00:00:00 1970 +0000) {'operation': 'split', 'user': 'test'}
undo: meaningful obs markers for undos Makes obs markers for undos more meaningful. When an undo performs a strict one to one change, the written obs marker reflects that and the user even gets a helpful ui message in smartlog. One to many undos do not support such obs markers (currently) because we can't tell splits and divergence apart easily. Differential Revision: https://phab.mercurial-scm.org/D108
2017-07-20 03:49:21 +03:00
$ hg undo
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before split --quiet (glob)
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
$ hg undo -n -1
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before undo (glob)
undo: meaningful obs markers for undos Makes obs markers for undos more meaningful. When an undo performs a strict one to one change, the written obs marker reflects that and the user even gets a helpful ui message in smartlog. One to many undos do not support such obs markers (currently) because we can't tell splits and divergence apart easily. Differential Revision: https://phab.mercurial-scm.org/D108
2017-07-20 03:49:21 +03:00
$ hg debugobsolete | tail -5
perftweaks: move effectflag removal logic to core Summary: This removes the effectflag logic from both core and perftweaks. Reviewed By: ryanmce Differential Revision: D6745769 fbshipit-source-id: 55ed1676e7117bca358471c256805ded7bc83f3c
2018-01-23 23:08:12 +03:00
d0fdb9510dbf78c1a7e62c3e6628ff1f978f87ea f86734247df6db66a810e549cc938a72cd5c6d1a 0 (Thu Jan 01 00:00:01 1970 +0000) {'operation': 'undo', 'user': 'test'}
75f63379f12bf02d40fe7444587ad67be9ae81b8 0 {d0fdb9510dbf78c1a7e62c3e6628ff1f978f87ea} (Thu Jan 01 00:00:01 1970 +0000) {'operation': 'undo', 'user': 'test'}
f86734247df6db66a810e549cc938a72cd5c6d1a 0 {1dafc0b436123cab96f82a8e9e8d1d42c0301aaa} (Thu Jan 01 00:00:02 1970 +0000) {'operation': 'undo', 'user': 'test'}
undo: meaningful obs markers for undos Makes obs markers for undos more meaningful. When an undo performs a strict one to one change, the written obs marker reflects that and the user even gets a helpful ui message in smartlog. One to many undos do not support such obs markers (currently) because we can't tell splits and divergence apart easily. Differential Revision: https://phab.mercurial-scm.org/D108
2017-07-20 03:49:21 +03:00
d0fdb9510dbf78c1a7e62c3e6628ff1f978f87ea d0fdb9510dbf78c1a7e62c3e6628ff1f978f87ea 0 (Thu Jan 01 00:00:01 1970 +0000) {'operation': 'revive', 'user': 'test'}
75f63379f12bf02d40fe7444587ad67be9ae81b8 75f63379f12bf02d40fe7444587ad67be9ae81b8 0 (Thu Jan 01 00:00:01 1970 +0000) {'operation': 'revive', 'user': 'test'}
$ cat >> $HGRCPATH <<EOF
> [extensions]
> smartlog =!
> tweakdefaults =!
> fbamend =!
> EOF
undo: file corruption handling Basic file corruption handling: if file is corrupted, we nuke our history. Downside is that we won't be able to undo furter back in case of a corruption, but considering corruption this is expected. Differential Revision: https://phab.mercurial-scm.org/D111
2017-07-20 03:49:21 +03:00
File corruption handling
$ echo 111corruptedrevlog > .hg/undolog/index.i
undo: do not run undolog for every command Previously, undolog runs for every command, which sometimes adds unwanted noticeable overhead like `hg status` with a large obsstore. This patch makes undo smarter to only log commands that actually write things. This is done by making undolog only run for transactions, updates (legacy code that does not require a transaction). Tests are changed to reflect `hg status` does not trigger undolog, and the new code seems to work better with chg. Differential Revision: https://phab.mercurial-scm.org/D739
2017-09-22 00:38:43 +03:00
$ hg noopupdate --config extensions.noopupdate=$TESTTMP/noopupdate.py --debug
undo: file corruption handling Basic file corruption handling: if file is corrupted, we nuke our history. Downside is that we won't be able to undo furter back in case of a corruption, but considering corruption this is expected. Differential Revision: https://phab.mercurial-scm.org/D111
2017-07-20 03:49:21 +03:00
caught revlog error. undolog/index.i was probably corrupted
$ hg debugundohistory -l
0: -- gap in log --
undo: localbranch revset Adds localbranch revset to be used for localbranch undos. A localbranch is a set of draft commits that are connected via draft commits. Any draft commit within a branch, or a public commit at the base of the branch, can be passed as an argument to localbranch(). This will be necessary for selecting the scope for a localbranch undo. Also fixes oldraft() output when used with other revsets. Previously olddraft() would ignore operators such as and because of a missing the necessary handling. Differential Revision: https://phab.mercurial-scm.org/D159
2017-08-04 01:17:21 +03:00
_localbranch revset tests
$ hg log -r '_localbranch(75f63379f12b)'
changeset: 0:df4fd610a3d6
user: test
date: Thu Jan 01 00:00:00 1970 +0000
summary: a1
changeset: 1:b68836a6e2ca
user: test
date: Thu Jan 01 00:00:00 1970 +0000
summary: a2
changeset: 2:49cdb4091aca
bookmark: feature1
user: test
date: Thu Jan 01 00:00:00 1970 +0000
summary: b
changeset: 3:ec7553f7b382
parent: 1:b68836a6e2ca
user: test
date: Thu Jan 01 00:00:00 1970 +0000
summary: c1
changeset: 4:38d85b506754
user: test
date: Thu Jan 01 00:00:00 1970 +0000
summary: c2
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
changeset: 6:296fda51a303
undo: localbranch revset Adds localbranch revset to be used for localbranch undos. A localbranch is a set of draft commits that are connected via draft commits. Any draft commit within a branch, or a public commit at the base of the branch, can be passed as an argument to localbranch(). This will be necessary for selecting the scope for a localbranch undo. Also fixes oldraft() output when used with other revsets. Previously olddraft() would ignore operators such as and because of a missing the necessary handling. Differential Revision: https://phab.mercurial-scm.org/D159
2017-08-04 01:17:21 +03:00
bookmark: feature2
parent: 4:38d85b506754
user: test
date: Thu Jan 01 00:00:00 1970 +0000
summary: d
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
changeset: 7:0a3dd3e15e65
undo: localbranch revset Adds localbranch revset to be used for localbranch undos. A localbranch is a set of draft commits that are connected via draft commits. Any draft commit within a branch, or a public commit at the base of the branch, can be passed as an argument to localbranch(). This will be necessary for selecting the scope for a localbranch undo. Also fixes oldraft() output when used with other revsets. Previously olddraft() would ignore operators such as and because of a missing the necessary handling. Differential Revision: https://phab.mercurial-scm.org/D159
2017-08-04 01:17:21 +03:00
parent: 4:38d85b506754
user: test
date: Thu Jan 01 00:00:00 1970 +0000
summary: words
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
changeset: 8:1dafc0b43612
undo: localbranch revset Adds localbranch revset to be used for localbranch undos. A localbranch is a set of draft commits that are connected via draft commits. Any draft commit within a branch, or a public commit at the base of the branch, can be passed as an argument to localbranch(). This will be necessary for selecting the scope for a localbranch undo. Also fixes oldraft() output when used with other revsets. Previously olddraft() would ignore operators such as and because of a missing the necessary handling. Differential Revision: https://phab.mercurial-scm.org/D159
2017-08-04 01:17:21 +03:00
bookmark: master
user: test
date: Thu Jan 01 00:00:00 1970 +0000
summary: cmiss
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
changeset: 14:d0fdb9510dbf
parent: 8:1dafc0b43612
undo: localbranch revset Adds localbranch revset to be used for localbranch undos. A localbranch is a set of draft commits that are connected via draft commits. Any draft commit within a branch, or a public commit at the base of the branch, can be passed as an argument to localbranch(). This will be necessary for selecting the scope for a localbranch undo. Also fixes oldraft() output when used with other revsets. Previously olddraft() would ignore operators such as and because of a missing the necessary handling. Differential Revision: https://phab.mercurial-scm.org/D159
2017-08-04 01:17:21 +03:00
user: test
date: Thu Jan 01 00:00:00 1970 +0000
summary: newfiles
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
changeset: 15:75f63379f12b
undo: localbranch revset Adds localbranch revset to be used for localbranch undos. A localbranch is a set of draft commits that are connected via draft commits. Any draft commit within a branch, or a public commit at the base of the branch, can be passed as an argument to localbranch(). This will be necessary for selecting the scope for a localbranch undo. Also fixes oldraft() output when used with other revsets. Previously olddraft() would ignore operators such as and because of a missing the necessary handling. Differential Revision: https://phab.mercurial-scm.org/D159
2017-08-04 01:17:21 +03:00
tag: tip
user: test
date: Thu Jan 01 00:00:00 1970 +0000
summary: newfiles
Test with public commit
$ hg phase -r 0a3dd3e15e65 -p
$ hg log -r '_localbranch(75f63379f12b)'
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
changeset: 8:1dafc0b43612
undo: localbranch revset Adds localbranch revset to be used for localbranch undos. A localbranch is a set of draft commits that are connected via draft commits. Any draft commit within a branch, or a public commit at the base of the branch, can be passed as an argument to localbranch(). This will be necessary for selecting the scope for a localbranch undo. Also fixes oldraft() output when used with other revsets. Previously olddraft() would ignore operators such as and because of a missing the necessary handling. Differential Revision: https://phab.mercurial-scm.org/D159
2017-08-04 01:17:21 +03:00
bookmark: master
user: test
date: Thu Jan 01 00:00:00 1970 +0000
summary: cmiss
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
changeset: 14:d0fdb9510dbf
parent: 8:1dafc0b43612
undo: localbranch revset Adds localbranch revset to be used for localbranch undos. A localbranch is a set of draft commits that are connected via draft commits. Any draft commit within a branch, or a public commit at the base of the branch, can be passed as an argument to localbranch(). This will be necessary for selecting the scope for a localbranch undo. Also fixes oldraft() output when used with other revsets. Previously olddraft() would ignore operators such as and because of a missing the necessary handling. Differential Revision: https://phab.mercurial-scm.org/D159
2017-08-04 01:17:21 +03:00
user: test
date: Thu Jan 01 00:00:00 1970 +0000
summary: newfiles
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
changeset: 15:75f63379f12b
undo: localbranch revset Adds localbranch revset to be used for localbranch undos. A localbranch is a set of draft commits that are connected via draft commits. Any draft commit within a branch, or a public commit at the base of the branch, can be passed as an argument to localbranch(). This will be necessary for selecting the scope for a localbranch undo. Also fixes oldraft() output when used with other revsets. Previously olddraft() would ignore operators such as and because of a missing the necessary handling. Differential Revision: https://phab.mercurial-scm.org/D159
2017-08-04 01:17:21 +03:00
tag: tip
user: test
date: Thu Jan 01 00:00:00 1970 +0000
summary: newfiles
$ hg log -r '_localbranch(0a3dd3e15e65)'
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
changeset: 8:1dafc0b43612
undo: localbranch revset Adds localbranch revset to be used for localbranch undos. A localbranch is a set of draft commits that are connected via draft commits. Any draft commit within a branch, or a public commit at the base of the branch, can be passed as an argument to localbranch(). This will be necessary for selecting the scope for a localbranch undo. Also fixes oldraft() output when used with other revsets. Previously olddraft() would ignore operators such as and because of a missing the necessary handling. Differential Revision: https://phab.mercurial-scm.org/D159
2017-08-04 01:17:21 +03:00
bookmark: master
user: test
date: Thu Jan 01 00:00:00 1970 +0000
summary: cmiss
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
changeset: 14:d0fdb9510dbf
parent: 8:1dafc0b43612
undo: localbranch revset Adds localbranch revset to be used for localbranch undos. A localbranch is a set of draft commits that are connected via draft commits. Any draft commit within a branch, or a public commit at the base of the branch, can be passed as an argument to localbranch(). This will be necessary for selecting the scope for a localbranch undo. Also fixes oldraft() output when used with other revsets. Previously olddraft() would ignore operators such as and because of a missing the necessary handling. Differential Revision: https://phab.mercurial-scm.org/D159
2017-08-04 01:17:21 +03:00
user: test
date: Thu Jan 01 00:00:00 1970 +0000
summary: newfiles
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
changeset: 15:75f63379f12b
undo: localbranch revset Adds localbranch revset to be used for localbranch undos. A localbranch is a set of draft commits that are connected via draft commits. Any draft commit within a branch, or a public commit at the base of the branch, can be passed as an argument to localbranch(). This will be necessary for selecting the scope for a localbranch undo. Also fixes oldraft() output when used with other revsets. Previously olddraft() would ignore operators such as and because of a missing the necessary handling. Differential Revision: https://phab.mercurial-scm.org/D159
2017-08-04 01:17:21 +03:00
tag: tip
user: test
date: Thu Jan 01 00:00:00 1970 +0000
summary: newfiles
undo: basic single repo undo Add the ability to undo changes within one 'localbranch'. In the future, this will probably become default behavior. Undo -b changecontext will undo changes belonging to the local branch identified by the changecontext (see revset localbranch). Based on obs markers we can identify connected commits that we in turn reveal or hide outside of this localbranch. This undo allows users to work on multiple branches independantly. Currently, indexing for undoes is still on the repo level. This isn't good from a ux experience. Next up would be localbranch level indexing logic and redo logic. Differential Revision: https://phab.mercurial-scm.org/D160
2017-08-04 01:17:21 +03:00
localbranch undos
Make changes on two branches (old and new)
Undo only changes in one branch (old)
Includes commit and book changes
$ hg book "oldbook"
$ touch oldbranch
$ hg add oldbranch && hg ci -moldbranch
$ hg update null
0 files updated, 0 files merged, 8 files removed, 0 files unresolved
(leaving bookmark oldbook)
$ touch newbranch
$ hg add newbranch && hg ci -mnewbranch
$ hg book "newbook"
$ hg log -l 2
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
changeset: 17:805791ba4bcd
undo: basic single repo undo Add the ability to undo changes within one 'localbranch'. In the future, this will probably become default behavior. Undo -b changecontext will undo changes belonging to the local branch identified by the changecontext (see revset localbranch). Based on obs markers we can identify connected commits that we in turn reveal or hide outside of this localbranch. This undo allows users to work on multiple branches independantly. Currently, indexing for undoes is still on the repo level. This isn't good from a ux experience. Next up would be localbranch level indexing logic and redo logic. Differential Revision: https://phab.mercurial-scm.org/D160
2017-08-04 01:17:21 +03:00
bookmark: newbook
tag: tip
parent: -1:000000000000
user: test
date: Thu Jan 01 00:00:00 1970 +0000
summary: newbranch
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
changeset: 16:7b0ef4f2a1ae
undo: basic single repo undo Add the ability to undo changes within one 'localbranch'. In the future, this will probably become default behavior. Undo -b changecontext will undo changes belonging to the local branch identified by the changecontext (see revset localbranch). Based on obs markers we can identify connected commits that we in turn reveal or hide outside of this localbranch. This undo allows users to work on multiple branches independantly. Currently, indexing for undoes is still on the repo level. This isn't good from a ux experience. Next up would be localbranch level indexing logic and redo logic. Differential Revision: https://phab.mercurial-scm.org/D160
2017-08-04 01:17:21 +03:00
bookmark: oldbook
user: test
date: Thu Jan 01 00:00:00 1970 +0000
summary: oldbranch
$ hg up 75f63379f12b
7 files updated, 0 files merged, 1 files removed, 0 files unresolved
(leaving bookmark newbook)
undo: localbrach fancy indexes Adds smart indexing to localbranch undoes. This eliminates the mental burden of the user of keeping track in what order and when changes where made. Drawback is that it raises the computational complexity from the number of draft commits to draft commits times how many repo states you are undoing. Common use case should be to undo a small number of changes, so this is acceptable. hg undo -b changectx finds the closest pertinent change and undoes that. -b with -n is not supported. The reason it is not supported is that local branch level undoes are delta specific and not state specific, which in essence means that running hg undo -b # twice is not guaranteed to give you the same resault as running hg undo -b # -n 2. We could run -b multiple times for a -n, but the cost of a -b increases with a larger -n (which isn't the case for a standard undo), and abort handling would be more complicated (I'm not sure how well we can roll back a tree of obs markers?). In essence -n with -b is not that usefull a feature (bc perf limits) and would potentially require a decently large amount of time to implement correctly. Also adds redo -b since this command now makes a lot more sense when we use the smarter indexing. Adds logic to seperate undoes and redoes in different branches. You can perform relative undoes and redoes within the latest scope, while undoes and redoes within a new scope will start at the present (absolute) state. Differential Revision: https://phab.mercurial-scm.org/D186
2017-08-04 01:17:21 +03:00
3 changes within local scope: commit, book, update
$ hg undo -b 75f63379f12b
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before update null (glob)
undo: localbrach fancy indexes Adds smart indexing to localbranch undoes. This eliminates the mental burden of the user of keeping track in what order and when changes where made. Drawback is that it raises the computational complexity from the number of draft commits to draft commits times how many repo states you are undoing. Common use case should be to undo a small number of changes, so this is acceptable. hg undo -b changectx finds the closest pertinent change and undoes that. -b with -n is not supported. The reason it is not supported is that local branch level undoes are delta specific and not state specific, which in essence means that running hg undo -b # twice is not guaranteed to give you the same resault as running hg undo -b # -n 2. We could run -b multiple times for a -n, but the cost of a -b increases with a larger -n (which isn't the case for a standard undo), and abort handling would be more complicated (I'm not sure how well we can roll back a tree of obs markers?). In essence -n with -b is not that usefull a feature (bc perf limits) and would potentially require a decently large amount of time to implement correctly. Also adds redo -b since this command now makes a lot more sense when we use the smarter indexing. Adds logic to seperate undoes and redoes in different branches. You can perform relative undoes and redoes within the latest scope, while undoes and redoes within a new scope will start at the present (absolute) state. Differential Revision: https://phab.mercurial-scm.org/D186
2017-08-04 01:17:21 +03:00
$ hg undo -b 75f63379f12b
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before ci -moldbranch (glob)
undo: localbrach fancy indexes Adds smart indexing to localbranch undoes. This eliminates the mental burden of the user of keeping track in what order and when changes where made. Drawback is that it raises the computational complexity from the number of draft commits to draft commits times how many repo states you are undoing. Common use case should be to undo a small number of changes, so this is acceptable. hg undo -b changectx finds the closest pertinent change and undoes that. -b with -n is not supported. The reason it is not supported is that local branch level undoes are delta specific and not state specific, which in essence means that running hg undo -b # twice is not guaranteed to give you the same resault as running hg undo -b # -n 2. We could run -b multiple times for a -n, but the cost of a -b increases with a larger -n (which isn't the case for a standard undo), and abort handling would be more complicated (I'm not sure how well we can roll back a tree of obs markers?). In essence -n with -b is not that usefull a feature (bc perf limits) and would potentially require a decently large amount of time to implement correctly. Also adds redo -b since this command now makes a lot more sense when we use the smarter indexing. Adds logic to seperate undoes and redoes in different branches. You can perform relative undoes and redoes within the latest scope, while undoes and redoes within a new scope will start at the present (absolute) state. Differential Revision: https://phab.mercurial-scm.org/D186
2017-08-04 01:17:21 +03:00
$ hg undo -b 75f63379f12b
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before book oldbook (glob)
undo: basic single repo undo Add the ability to undo changes within one 'localbranch'. In the future, this will probably become default behavior. Undo -b changecontext will undo changes belonging to the local branch identified by the changecontext (see revset localbranch). Based on obs markers we can identify connected commits that we in turn reveal or hide outside of this localbranch. This undo allows users to work on multiple branches independantly. Currently, indexing for undoes is still on the repo level. This isn't good from a ux experience. Next up would be localbranch level indexing logic and redo logic. Differential Revision: https://phab.mercurial-scm.org/D160
2017-08-04 01:17:21 +03:00
$ hg log -l 2
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
changeset: 17:805791ba4bcd
undo: basic single repo undo Add the ability to undo changes within one 'localbranch'. In the future, this will probably become default behavior. Undo -b changecontext will undo changes belonging to the local branch identified by the changecontext (see revset localbranch). Based on obs markers we can identify connected commits that we in turn reveal or hide outside of this localbranch. This undo allows users to work on multiple branches independantly. Currently, indexing for undoes is still on the repo level. This isn't good from a ux experience. Next up would be localbranch level indexing logic and redo logic. Differential Revision: https://phab.mercurial-scm.org/D160
2017-08-04 01:17:21 +03:00
bookmark: newbook
tag: tip
parent: -1:000000000000
user: test
date: Thu Jan 01 00:00:00 1970 +0000
summary: newbranch
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
changeset: 15:75f63379f12b
undo: basic single repo undo Add the ability to undo changes within one 'localbranch'. In the future, this will probably become default behavior. Undo -b changecontext will undo changes belonging to the local branch identified by the changecontext (see revset localbranch). Based on obs markers we can identify connected commits that we in turn reveal or hide outside of this localbranch. This undo allows users to work on multiple branches independantly. Currently, indexing for undoes is still on the repo level. This isn't good from a ux experience. Next up would be localbranch level indexing logic and redo logic. Differential Revision: https://phab.mercurial-scm.org/D160
2017-08-04 01:17:21 +03:00
user: test
date: Thu Jan 01 00:00:00 1970 +0000
summary: newfiles
Check rebase local undos of rebases
Make sure bookmarks and commits are not lost
and commits are not duplicated
$ cat >> $HGRCPATH <<EOF
> [extensions]
> rebase =
> EOF
$ hg rebase -s 8057 -d 75f6
tests: tip moved to after other names Summary: Namespace order in rebase was changed in https://phab.mercurial-scm.org/D741 Reviewers: #fbhgext, mjpieters Reviewed By: mjpieters Differential Revision: https://phab.mercurial-scm.org/D824
2017-09-27 16:43:51 +03:00
rebasing 17:805791ba4bcd "newbranch" (newbook tip)
undo: basic single repo undo Add the ability to undo changes within one 'localbranch'. In the future, this will probably become default behavior. Undo -b changecontext will undo changes belonging to the local branch identified by the changecontext (see revset localbranch). Based on obs markers we can identify connected commits that we in turn reveal or hide outside of this localbranch. This undo allows users to work on multiple branches independantly. Currently, indexing for undoes is still on the repo level. This isn't good from a ux experience. Next up would be localbranch level indexing logic and redo logic. Differential Revision: https://phab.mercurial-scm.org/D160
2017-08-04 01:17:21 +03:00
$ hg log -l 2
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
changeset: 18:35324a911c0d
undo: basic single repo undo Add the ability to undo changes within one 'localbranch'. In the future, this will probably become default behavior. Undo -b changecontext will undo changes belonging to the local branch identified by the changecontext (see revset localbranch). Based on obs markers we can identify connected commits that we in turn reveal or hide outside of this localbranch. This undo allows users to work on multiple branches independantly. Currently, indexing for undoes is still on the repo level. This isn't good from a ux experience. Next up would be localbranch level indexing logic and redo logic. Differential Revision: https://phab.mercurial-scm.org/D160
2017-08-04 01:17:21 +03:00
bookmark: newbook
tag: tip
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
parent: 15:75f63379f12b
undo: basic single repo undo Add the ability to undo changes within one 'localbranch'. In the future, this will probably become default behavior. Undo -b changecontext will undo changes belonging to the local branch identified by the changecontext (see revset localbranch). Based on obs markers we can identify connected commits that we in turn reveal or hide outside of this localbranch. This undo allows users to work on multiple branches independantly. Currently, indexing for undoes is still on the repo level. This isn't good from a ux experience. Next up would be localbranch level indexing logic and redo logic. Differential Revision: https://phab.mercurial-scm.org/D160
2017-08-04 01:17:21 +03:00
user: test
date: Thu Jan 01 00:00:00 1970 +0000
summary: newbranch
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
changeset: 15:75f63379f12b
undo: basic single repo undo Add the ability to undo changes within one 'localbranch'. In the future, this will probably become default behavior. Undo -b changecontext will undo changes belonging to the local branch identified by the changecontext (see revset localbranch). Based on obs markers we can identify connected commits that we in turn reveal or hide outside of this localbranch. This undo allows users to work on multiple branches independantly. Currently, indexing for undoes is still on the repo level. This isn't good from a ux experience. Next up would be localbranch level indexing logic and redo logic. Differential Revision: https://phab.mercurial-scm.org/D160
2017-08-04 01:17:21 +03:00
user: test
date: Thu Jan 01 00:00:00 1970 +0000
summary: newfiles
$ hg undo -b 3532
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before rebase -s 8057 -d 75f6 (glob)
undo: basic single repo undo Add the ability to undo changes within one 'localbranch'. In the future, this will probably become default behavior. Undo -b changecontext will undo changes belonging to the local branch identified by the changecontext (see revset localbranch). Based on obs markers we can identify connected commits that we in turn reveal or hide outside of this localbranch. This undo allows users to work on multiple branches independantly. Currently, indexing for undoes is still on the repo level. This isn't good from a ux experience. Next up would be localbranch level indexing logic and redo logic. Differential Revision: https://phab.mercurial-scm.org/D160
2017-08-04 01:17:21 +03:00
$ hg log -l 2
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
changeset: 17:805791ba4bcd
undo: basic single repo undo Add the ability to undo changes within one 'localbranch'. In the future, this will probably become default behavior. Undo -b changecontext will undo changes belonging to the local branch identified by the changecontext (see revset localbranch). Based on obs markers we can identify connected commits that we in turn reveal or hide outside of this localbranch. This undo allows users to work on multiple branches independantly. Currently, indexing for undoes is still on the repo level. This isn't good from a ux experience. Next up would be localbranch level indexing logic and redo logic. Differential Revision: https://phab.mercurial-scm.org/D160
2017-08-04 01:17:21 +03:00
bookmark: newbook
tag: tip
parent: -1:000000000000
user: test
date: Thu Jan 01 00:00:00 1970 +0000
summary: newbranch
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
changeset: 15:75f63379f12b
undo: basic single repo undo Add the ability to undo changes within one 'localbranch'. In the future, this will probably become default behavior. Undo -b changecontext will undo changes belonging to the local branch identified by the changecontext (see revset localbranch). Based on obs markers we can identify connected commits that we in turn reveal or hide outside of this localbranch. This undo allows users to work on multiple branches independantly. Currently, indexing for undoes is still on the repo level. This isn't good from a ux experience. Next up would be localbranch level indexing logic and redo logic. Differential Revision: https://phab.mercurial-scm.org/D160
2017-08-04 01:17:21 +03:00
user: test
date: Thu Jan 01 00:00:00 1970 +0000
summary: newfiles
$ cat >> $HGRCPATH <<EOF
> [extensions]
> rebase = !
> EOF
undo: localbrach fancy indexes Adds smart indexing to localbranch undoes. This eliminates the mental burden of the user of keeping track in what order and when changes where made. Drawback is that it raises the computational complexity from the number of draft commits to draft commits times how many repo states you are undoing. Common use case should be to undo a small number of changes, so this is acceptable. hg undo -b changectx finds the closest pertinent change and undoes that. -b with -n is not supported. The reason it is not supported is that local branch level undoes are delta specific and not state specific, which in essence means that running hg undo -b # twice is not guaranteed to give you the same resault as running hg undo -b # -n 2. We could run -b multiple times for a -n, but the cost of a -b increases with a larger -n (which isn't the case for a standard undo), and abort handling would be more complicated (I'm not sure how well we can roll back a tree of obs markers?). In essence -n with -b is not that usefull a feature (bc perf limits) and would potentially require a decently large amount of time to implement correctly. Also adds redo -b since this command now makes a lot more sense when we use the smarter indexing. Adds logic to seperate undoes and redoes in different branches. You can perform relative undoes and redoes within the latest scope, while undoes and redoes within a new scope will start at the present (absolute) state. Differential Revision: https://phab.mercurial-scm.org/D186
2017-08-04 01:17:21 +03:00
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
Check local undo works forward
$ hg undo -n -1 -b 3532
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before undo -b 3532 (glob)
undo: localbrach fancy indexes Adds smart indexing to localbranch undoes. This eliminates the mental burden of the user of keeping track in what order and when changes where made. Drawback is that it raises the computational complexity from the number of draft commits to draft commits times how many repo states you are undoing. Common use case should be to undo a small number of changes, so this is acceptable. hg undo -b changectx finds the closest pertinent change and undoes that. -b with -n is not supported. The reason it is not supported is that local branch level undoes are delta specific and not state specific, which in essence means that running hg undo -b # twice is not guaranteed to give you the same resault as running hg undo -b # -n 2. We could run -b multiple times for a -n, but the cost of a -b increases with a larger -n (which isn't the case for a standard undo), and abort handling would be more complicated (I'm not sure how well we can roll back a tree of obs markers?). In essence -n with -b is not that usefull a feature (bc perf limits) and would potentially require a decently large amount of time to implement correctly. Also adds redo -b since this command now makes a lot more sense when we use the smarter indexing. Adds logic to seperate undoes and redoes in different branches. You can perform relative undoes and redoes within the latest scope, while undoes and redoes within a new scope will start at the present (absolute) state. Differential Revision: https://phab.mercurial-scm.org/D186
2017-08-04 01:17:21 +03:00
$ hg log -l 2
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
changeset: 18:35324a911c0d
undo: localbrach fancy indexes Adds smart indexing to localbranch undoes. This eliminates the mental burden of the user of keeping track in what order and when changes where made. Drawback is that it raises the computational complexity from the number of draft commits to draft commits times how many repo states you are undoing. Common use case should be to undo a small number of changes, so this is acceptable. hg undo -b changectx finds the closest pertinent change and undoes that. -b with -n is not supported. The reason it is not supported is that local branch level undoes are delta specific and not state specific, which in essence means that running hg undo -b # twice is not guaranteed to give you the same resault as running hg undo -b # -n 2. We could run -b multiple times for a -n, but the cost of a -b increases with a larger -n (which isn't the case for a standard undo), and abort handling would be more complicated (I'm not sure how well we can roll back a tree of obs markers?). In essence -n with -b is not that usefull a feature (bc perf limits) and would potentially require a decently large amount of time to implement correctly. Also adds redo -b since this command now makes a lot more sense when we use the smarter indexing. Adds logic to seperate undoes and redoes in different branches. You can perform relative undoes and redoes within the latest scope, while undoes and redoes within a new scope will start at the present (absolute) state. Differential Revision: https://phab.mercurial-scm.org/D186
2017-08-04 01:17:21 +03:00
bookmark: newbook
tag: tip
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
parent: 15:75f63379f12b
undo: localbrach fancy indexes Adds smart indexing to localbranch undoes. This eliminates the mental burden of the user of keeping track in what order and when changes where made. Drawback is that it raises the computational complexity from the number of draft commits to draft commits times how many repo states you are undoing. Common use case should be to undo a small number of changes, so this is acceptable. hg undo -b changectx finds the closest pertinent change and undoes that. -b with -n is not supported. The reason it is not supported is that local branch level undoes are delta specific and not state specific, which in essence means that running hg undo -b # twice is not guaranteed to give you the same resault as running hg undo -b # -n 2. We could run -b multiple times for a -n, but the cost of a -b increases with a larger -n (which isn't the case for a standard undo), and abort handling would be more complicated (I'm not sure how well we can roll back a tree of obs markers?). In essence -n with -b is not that usefull a feature (bc perf limits) and would potentially require a decently large amount of time to implement correctly. Also adds redo -b since this command now makes a lot more sense when we use the smarter indexing. Adds logic to seperate undoes and redoes in different branches. You can perform relative undoes and redoes within the latest scope, while undoes and redoes within a new scope will start at the present (absolute) state. Differential Revision: https://phab.mercurial-scm.org/D186
2017-08-04 01:17:21 +03:00
user: test
date: Thu Jan 01 00:00:00 1970 +0000
summary: newbranch
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
changeset: 15:75f63379f12b
undo: localbrach fancy indexes Adds smart indexing to localbranch undoes. This eliminates the mental burden of the user of keeping track in what order and when changes where made. Drawback is that it raises the computational complexity from the number of draft commits to draft commits times how many repo states you are undoing. Common use case should be to undo a small number of changes, so this is acceptable. hg undo -b changectx finds the closest pertinent change and undoes that. -b with -n is not supported. The reason it is not supported is that local branch level undoes are delta specific and not state specific, which in essence means that running hg undo -b # twice is not guaranteed to give you the same resault as running hg undo -b # -n 2. We could run -b multiple times for a -n, but the cost of a -b increases with a larger -n (which isn't the case for a standard undo), and abort handling would be more complicated (I'm not sure how well we can roll back a tree of obs markers?). In essence -n with -b is not that usefull a feature (bc perf limits) and would potentially require a decently large amount of time to implement correctly. Also adds redo -b since this command now makes a lot more sense when we use the smarter indexing. Adds logic to seperate undoes and redoes in different branches. You can perform relative undoes and redoes within the latest scope, while undoes and redoes within a new scope will start at the present (absolute) state. Differential Revision: https://phab.mercurial-scm.org/D186
2017-08-04 01:17:21 +03:00
user: test
date: Thu Jan 01 00:00:00 1970 +0000
summary: newfiles
$ touch a9 && hg add a9 && hg ci -m a9
$ hg log -r . -T {node}
3ee6a6880888df9e48cdc568b5e835bd3087f8cb (no-eol)
$ hg undo -b 3532
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before ci -m a9 (glob)
undo: localbrach fancy indexes Adds smart indexing to localbranch undoes. This eliminates the mental burden of the user of keeping track in what order and when changes where made. Drawback is that it raises the computational complexity from the number of draft commits to draft commits times how many repo states you are undoing. Common use case should be to undo a small number of changes, so this is acceptable. hg undo -b changectx finds the closest pertinent change and undoes that. -b with -n is not supported. The reason it is not supported is that local branch level undoes are delta specific and not state specific, which in essence means that running hg undo -b # twice is not guaranteed to give you the same resault as running hg undo -b # -n 2. We could run -b multiple times for a -n, but the cost of a -b increases with a larger -n (which isn't the case for a standard undo), and abort handling would be more complicated (I'm not sure how well we can roll back a tree of obs markers?). In essence -n with -b is not that usefull a feature (bc perf limits) and would potentially require a decently large amount of time to implement correctly. Also adds redo -b since this command now makes a lot more sense when we use the smarter indexing. Adds logic to seperate undoes and redoes in different branches. You can perform relative undoes and redoes within the latest scope, while undoes and redoes within a new scope will start at the present (absolute) state. Differential Revision: https://phab.mercurial-scm.org/D186
2017-08-04 01:17:21 +03:00
$ hg undo -b 3532
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before undo -n -1 -b 3532 (glob)
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
$ hg undo -n -1 -b 75f6
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before ci -m a9 (glob)
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
$ hg undo -n -1 -b 75f6
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before undo -b 3532 (glob)
undo: localbrach fancy indexes Adds smart indexing to localbranch undoes. This eliminates the mental burden of the user of keeping track in what order and when changes where made. Drawback is that it raises the computational complexity from the number of draft commits to draft commits times how many repo states you are undoing. Common use case should be to undo a small number of changes, so this is acceptable. hg undo -b changectx finds the closest pertinent change and undoes that. -b with -n is not supported. The reason it is not supported is that local branch level undoes are delta specific and not state specific, which in essence means that running hg undo -b # twice is not guaranteed to give you the same resault as running hg undo -b # -n 2. We could run -b multiple times for a -n, but the cost of a -b increases with a larger -n (which isn't the case for a standard undo), and abort handling would be more complicated (I'm not sure how well we can roll back a tree of obs markers?). In essence -n with -b is not that usefull a feature (bc perf limits) and would potentially require a decently large amount of time to implement correctly. Also adds redo -b since this command now makes a lot more sense when we use the smarter indexing. Adds logic to seperate undoes and redoes in different branches. You can perform relative undoes and redoes within the latest scope, while undoes and redoes within a new scope will start at the present (absolute) state. Differential Revision: https://phab.mercurial-scm.org/D186
2017-08-04 01:17:21 +03:00
$ hg log -l 2
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
changeset: 19:3ee6a6880888
undo: localbrach fancy indexes Adds smart indexing to localbranch undoes. This eliminates the mental burden of the user of keeping track in what order and when changes where made. Drawback is that it raises the computational complexity from the number of draft commits to draft commits times how many repo states you are undoing. Common use case should be to undo a small number of changes, so this is acceptable. hg undo -b changectx finds the closest pertinent change and undoes that. -b with -n is not supported. The reason it is not supported is that local branch level undoes are delta specific and not state specific, which in essence means that running hg undo -b # twice is not guaranteed to give you the same resault as running hg undo -b # -n 2. We could run -b multiple times for a -n, but the cost of a -b increases with a larger -n (which isn't the case for a standard undo), and abort handling would be more complicated (I'm not sure how well we can roll back a tree of obs markers?). In essence -n with -b is not that usefull a feature (bc perf limits) and would potentially require a decently large amount of time to implement correctly. Also adds redo -b since this command now makes a lot more sense when we use the smarter indexing. Adds logic to seperate undoes and redoes in different branches. You can perform relative undoes and redoes within the latest scope, while undoes and redoes within a new scope will start at the present (absolute) state. Differential Revision: https://phab.mercurial-scm.org/D186
2017-08-04 01:17:21 +03:00
tag: tip
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
parent: 15:75f63379f12b
undo: localbrach fancy indexes Adds smart indexing to localbranch undoes. This eliminates the mental burden of the user of keeping track in what order and when changes where made. Drawback is that it raises the computational complexity from the number of draft commits to draft commits times how many repo states you are undoing. Common use case should be to undo a small number of changes, so this is acceptable. hg undo -b changectx finds the closest pertinent change and undoes that. -b with -n is not supported. The reason it is not supported is that local branch level undoes are delta specific and not state specific, which in essence means that running hg undo -b # twice is not guaranteed to give you the same resault as running hg undo -b # -n 2. We could run -b multiple times for a -n, but the cost of a -b increases with a larger -n (which isn't the case for a standard undo), and abort handling would be more complicated (I'm not sure how well we can roll back a tree of obs markers?). In essence -n with -b is not that usefull a feature (bc perf limits) and would potentially require a decently large amount of time to implement correctly. Also adds redo -b since this command now makes a lot more sense when we use the smarter indexing. Adds logic to seperate undoes and redoes in different branches. You can perform relative undoes and redoes within the latest scope, while undoes and redoes within a new scope will start at the present (absolute) state. Differential Revision: https://phab.mercurial-scm.org/D186
2017-08-04 01:17:21 +03:00
user: test
date: Thu Jan 01 00:00:00 1970 +0000
summary: a9
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
changeset: 18:35324a911c0d
undo: localbrach fancy indexes Adds smart indexing to localbranch undoes. This eliminates the mental burden of the user of keeping track in what order and when changes where made. Drawback is that it raises the computational complexity from the number of draft commits to draft commits times how many repo states you are undoing. Common use case should be to undo a small number of changes, so this is acceptable. hg undo -b changectx finds the closest pertinent change and undoes that. -b with -n is not supported. The reason it is not supported is that local branch level undoes are delta specific and not state specific, which in essence means that running hg undo -b # twice is not guaranteed to give you the same resault as running hg undo -b # -n 2. We could run -b multiple times for a -n, but the cost of a -b increases with a larger -n (which isn't the case for a standard undo), and abort handling would be more complicated (I'm not sure how well we can roll back a tree of obs markers?). In essence -n with -b is not that usefull a feature (bc perf limits) and would potentially require a decently large amount of time to implement correctly. Also adds redo -b since this command now makes a lot more sense when we use the smarter indexing. Adds logic to seperate undoes and redoes in different branches. You can perform relative undoes and redoes within the latest scope, while undoes and redoes within a new scope will start at the present (absolute) state. Differential Revision: https://phab.mercurial-scm.org/D186
2017-08-04 01:17:21 +03:00
bookmark: newbook
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
parent: 15:75f63379f12b
undo: localbrach fancy indexes Adds smart indexing to localbranch undoes. This eliminates the mental burden of the user of keeping track in what order and when changes where made. Drawback is that it raises the computational complexity from the number of draft commits to draft commits times how many repo states you are undoing. Common use case should be to undo a small number of changes, so this is acceptable. hg undo -b changectx finds the closest pertinent change and undoes that. -b with -n is not supported. The reason it is not supported is that local branch level undoes are delta specific and not state specific, which in essence means that running hg undo -b # twice is not guaranteed to give you the same resault as running hg undo -b # -n 2. We could run -b multiple times for a -n, but the cost of a -b increases with a larger -n (which isn't the case for a standard undo), and abort handling would be more complicated (I'm not sure how well we can roll back a tree of obs markers?). In essence -n with -b is not that usefull a feature (bc perf limits) and would potentially require a decently large amount of time to implement correctly. Also adds redo -b since this command now makes a lot more sense when we use the smarter indexing. Adds logic to seperate undoes and redoes in different branches. You can perform relative undoes and redoes within the latest scope, while undoes and redoes within a new scope will start at the present (absolute) state. Differential Revision: https://phab.mercurial-scm.org/D186
2017-08-04 01:17:21 +03:00
user: test
date: Thu Jan 01 00:00:00 1970 +0000
summary: newbranch
Check local undo with facebook style strip
$ cat >> $HGRCPATH <<EOF
> [extensions]
> strip =
fb-hgext: fix copied fb-hgext tests Summary: This is a big bulk of generally almost-obvious fixes to the moved tests. Mostly these fixes have to do with correct importing of the actual extensions. Depends on D6675329 Test Plan: - ./run-tests.py fails less after this commit - see further commits for more test fixes Reviewers: #sourcecontrol Differential Revision: https://phabricator.intern.facebook.com/D6675344
2018-01-09 14:06:09 +03:00
> fbamend=
undo: localbrach fancy indexes Adds smart indexing to localbranch undoes. This eliminates the mental burden of the user of keeping track in what order and when changes where made. Drawback is that it raises the computational complexity from the number of draft commits to draft commits times how many repo states you are undoing. Common use case should be to undo a small number of changes, so this is acceptable. hg undo -b changectx finds the closest pertinent change and undoes that. -b with -n is not supported. The reason it is not supported is that local branch level undoes are delta specific and not state specific, which in essence means that running hg undo -b # twice is not guaranteed to give you the same resault as running hg undo -b # -n 2. We could run -b multiple times for a -n, but the cost of a -b increases with a larger -n (which isn't the case for a standard undo), and abort handling would be more complicated (I'm not sure how well we can roll back a tree of obs markers?). In essence -n with -b is not that usefull a feature (bc perf limits) and would potentially require a decently large amount of time to implement correctly. Also adds redo -b since this command now makes a lot more sense when we use the smarter indexing. Adds logic to seperate undoes and redoes in different branches. You can perform relative undoes and redoes within the latest scope, while undoes and redoes within a new scope will start at the present (absolute) state. Differential Revision: https://phab.mercurial-scm.org/D186
2017-08-04 01:17:21 +03:00
> EOF
$ hg strip 3ee6
0 files updated, 0 files merged, 1 files removed, 0 files unresolved
working directory now at 75f63379f12b
1 changesets pruned
prune: use hint framework Summary: This allows users to silence the "hide" advice. In the future, we might want to change "hide/unhide" to only affect visibility without changing obsolesce. So "strip" is not fully deprecated yet. Reviewed By: markbt Differential Revision: D7392131 fbshipit-source-id: 2448d4c91dffce31d29e2dd99078cb555c9a8f8c
2018-04-07 10:36:49 +03:00
hint[strip-hide]: 'hg strip' may be deprecated in the future - use 'hg hide' instead
hint[hint-ack]: use 'hg hint --ack strip-hide' to silence these hints
undo: localbrach fancy indexes Adds smart indexing to localbranch undoes. This eliminates the mental burden of the user of keeping track in what order and when changes where made. Drawback is that it raises the computational complexity from the number of draft commits to draft commits times how many repo states you are undoing. Common use case should be to undo a small number of changes, so this is acceptable. hg undo -b changectx finds the closest pertinent change and undoes that. -b with -n is not supported. The reason it is not supported is that local branch level undoes are delta specific and not state specific, which in essence means that running hg undo -b # twice is not guaranteed to give you the same resault as running hg undo -b # -n 2. We could run -b multiple times for a -n, but the cost of a -b increases with a larger -n (which isn't the case for a standard undo), and abort handling would be more complicated (I'm not sure how well we can roll back a tree of obs markers?). In essence -n with -b is not that usefull a feature (bc perf limits) and would potentially require a decently large amount of time to implement correctly. Also adds redo -b since this command now makes a lot more sense when we use the smarter indexing. Adds logic to seperate undoes and redoes in different branches. You can perform relative undoes and redoes within the latest scope, while undoes and redoes within a new scope will start at the present (absolute) state. Differential Revision: https://phab.mercurial-scm.org/D186
2017-08-04 01:17:21 +03:00
$ hg undo -b 3532
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before strip 3ee6 (glob)
undo: localbrach fancy indexes Adds smart indexing to localbranch undoes. This eliminates the mental burden of the user of keeping track in what order and when changes where made. Drawback is that it raises the computational complexity from the number of draft commits to draft commits times how many repo states you are undoing. Common use case should be to undo a small number of changes, so this is acceptable. hg undo -b changectx finds the closest pertinent change and undoes that. -b with -n is not supported. The reason it is not supported is that local branch level undoes are delta specific and not state specific, which in essence means that running hg undo -b # twice is not guaranteed to give you the same resault as running hg undo -b # -n 2. We could run -b multiple times for a -n, but the cost of a -b increases with a larger -n (which isn't the case for a standard undo), and abort handling would be more complicated (I'm not sure how well we can roll back a tree of obs markers?). In essence -n with -b is not that usefull a feature (bc perf limits) and would potentially require a decently large amount of time to implement correctly. Also adds redo -b since this command now makes a lot more sense when we use the smarter indexing. Adds logic to seperate undoes and redoes in different branches. You can perform relative undoes and redoes within the latest scope, while undoes and redoes within a new scope will start at the present (absolute) state. Differential Revision: https://phab.mercurial-scm.org/D186
2017-08-04 01:17:21 +03:00
$ hg log -r . -T {node}
3ee6a6880888df9e48cdc568b5e835bd3087f8cb (no-eol)
$ cat >> $HGRCPATH <<EOF
> [extensions]
> strip =!
> fbamend =!
> EOF
undo: basic --preview Allows for hg undo --preview to see smartlog like preview of what undo will do. This will be neccesery before a general roll-out so users can see what undo will do. This first iteration only shows what "hg undo" will do, not redo and not --index. Differential Revision: https://phab.mercurial-scm.org/D206
2017-08-12 04:05:03 +03:00
hg undo --preview test
$ touch prev1 && hg add prev1 && hg ci -m prev1
$ cat >> $HGRCPATH <<EOF
> [templatealias]
undo: add --index and redo support to preview Adds --index handling for --preview. With the added handling, preview also works for redo. In order to bypass template logic, we simply change the "undoredo.i" file and reset it afterwards. Differential Revision: https://phab.mercurial-scm.org/D207
2017-08-12 04:05:03 +03:00
> undopreview = '{if(undonecommits(UNDOINDEX), "Undone")}'
undo: basic --preview Allows for hg undo --preview to see smartlog like preview of what undo will do. This will be neccesery before a general roll-out so users can see what undo will do. This first iteration only shows what "hg undo" will do, not redo and not --index. Differential Revision: https://phab.mercurial-scm.org/D206
2017-08-12 04:05:03 +03:00
> EOF
$ hg undo -p
@ Undone
|
o
|
o
|
o
|
o
undo: fix test broken by previous commit
2017-08-24 09:59:34 +03:00
:
o
undo: basic --preview Allows for hg undo --preview to see smartlog like preview of what undo will do. This will be neccesery before a general roll-out so users can see what undo will do. This first iteration only shows what "hg undo" will do, not redo and not --index. Differential Revision: https://phab.mercurial-scm.org/D206
2017-08-12 04:05:03 +03:00
|
~
undo: preview shows command and time output Makes hg undo -i and hg undo -p output show an "undo to time, before command" message and adds directions (left, right, return, q). Also adds pager check as pager break interactiveui. Testing: run hg undo -p and hg undo -i and see output Differential Revision: https://phab.mercurial-scm.org/D448
2017-08-21 21:25:36 +03:00
undo to *, before ci -m prev1 (glob)
undo: add --index and redo support to preview Adds --index handling for --preview. With the added handling, preview also works for redo. In order to bypass template logic, we simply change the "undoredo.i" file and reset it afterwards. Differential Revision: https://phab.mercurial-scm.org/D207
2017-08-12 04:05:03 +03:00
$ hg undo -p -n 2
@ Undone
|
o Undone
|
o
|
o
|
o
undo: fix test broken by previous commit
2017-08-24 09:59:34 +03:00
:
o
undo: add --index and redo support to preview Adds --index handling for --preview. With the added handling, preview also works for redo. In order to bypass template logic, we simply change the "undoredo.i" file and reset it afterwards. Differential Revision: https://phab.mercurial-scm.org/D207
2017-08-12 04:05:03 +03:00
|
~
undo: preview shows command and time output Makes hg undo -i and hg undo -p output show an "undo to time, before command" message and adds directions (left, right, return, q). Also adds pager check as pager break interactiveui. Testing: run hg undo -p and hg undo -i and see output Differential Revision: https://phab.mercurial-scm.org/D448
2017-08-21 21:25:36 +03:00
undo to *, before undo -b 3532 (glob)
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
hg redo tests
$ hg log -G -T compact
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
@ 20[tip] a0b72b3048d6 1970-01-01 00:00 +0000 test
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
| prev1
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 19:15 3ee6a6880888 1970-01-01 00:00 +0000 test
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
| a9
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
| o 18[newbook]:15 35324a911c0d 1970-01-01 00:00 +0000 test
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
|/ newbranch
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 15 75f63379f12b 1970-01-01 00:00 +0000 test
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
| newfiles
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 14:8 d0fdb9510dbf 1970-01-01 00:00 +0000 test
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
| newfiles
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 8[master] 1dafc0b43612 1970-01-01 00:00 +0000 test
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
| cmiss
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 7:4 0a3dd3e15e65 1970-01-01 00:00 +0000 test
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
| words
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
| o 6[feature2]:4 296fda51a303 1970-01-01 00:00 +0000 test
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
|/ d
|
o 4 38d85b506754 1970-01-01 00:00 +0000 test
| c2
|
o 3:1 ec7553f7b382 1970-01-01 00:00 +0000 test
| c1
|
| o 2[feature1] 49cdb4091aca 1970-01-01 00:00 +0000 test
|/ b
|
o 1 b68836a6e2ca 1970-01-01 00:00 +0000 test
| a2
|
o 0 df4fd610a3d6 1970-01-01 00:00 +0000 test
a1
$ hg log -r . -T {node}
a0b72b3048d6d07b35b1d79c8e5c46b159d21cc9 (no-eol)
$ hg undo -n 2
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before undo -b 3532 (glob)
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
$ hg redo
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before undo -n 2 (glob)
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
$ hg log -r . -T {node}
a0b72b3048d6d07b35b1d79c8e5c46b159d21cc9 (no-eol)
$ hg undo
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before ci -m prev1 (glob)
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
$ hg undo
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before undo -b 3532 (glob)
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
$ hg log -r . -T {node}
75f63379f12bf02d40fe7444587ad67be9ae81b8 (no-eol)
$ hg undo -n 1
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before strip 3ee6 (glob)
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
$ hg redo
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before undo -n 1 (glob)
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
$ hg log -r . -T {node}
75f63379f12bf02d40fe7444587ad67be9ae81b8 (no-eol)
$ hg undo -n 1
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before strip 3ee6 (glob)
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
$ hg redo
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before undo -n 1 (glob)
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
$ hg redo
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before undo (glob)
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
$ hg redo
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before undo (glob)
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
$ hg log -r . -T {node}
a0b72b3048d6d07b35b1d79c8e5c46b159d21cc9 (no-eol)
$ hg undo -fn 3
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before strip 3ee6 (glob)
undo: better docs Strips docs of unnescerary info and sticks complex things behind --verbose flag. In most cases hg undo and redo or hg undo --preview should be enough for the user. Also changes --index to --step, which seems clearer. Differential Revision: https://phab.mercurial-scm.org/D287
2017-08-12 04:05:03 +03:00
$ hg undo --force --step -1
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before undo -b 3532 (glob)
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
$ hg debugundohistory -l
undo: better docs Strips docs of unnescerary info and sticks complex things behind --verbose flag. In most cases hg undo and redo or hg undo --preview should be enough for the user. Also changes --index to --step, which seems clearer. Differential Revision: https://phab.mercurial-scm.org/D287
2017-08-12 04:05:03 +03:00
0: undo --force --step -1
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
1: undo -fn 3
2: redo
3: redo
4: redo
$ hg redo
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before undo --force --step -1 (glob)
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
$ hg undo
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before undo -n -1 -b 75f6 (glob)
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
$ hg log -r . -T {node}
75f63379f12bf02d40fe7444587ad67be9ae81b8 (no-eol)
$ hg redo
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before undo (glob)
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
$ hg redo
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before undo -fn 3 (glob)
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
$ hg log -r . -T {node}
a0b72b3048d6d07b35b1d79c8e5c46b159d21cc9 (no-eol)
$ hg undo --traceback
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before ci -m prev1 (glob)
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
$ hg undo -an1
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before undo --traceback (glob)
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
$ hg redo
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before undo -an1 (glob)
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
$ hg redo
abort: can't redo past absolute undo
[255]
$ hg undo -n -1
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before redo (glob)
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
$ hg log -G -T compact
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
@ 20[tip] a0b72b3048d6 1970-01-01 00:00 +0000 test
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
| prev1
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 19:15 3ee6a6880888 1970-01-01 00:00 +0000 test
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
| a9
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
| o 18[newbook]:15 35324a911c0d 1970-01-01 00:00 +0000 test
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
|/ newbranch
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 15 75f63379f12b 1970-01-01 00:00 +0000 test
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
| newfiles
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 14:8 d0fdb9510dbf 1970-01-01 00:00 +0000 test
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
| newfiles
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 8[master] 1dafc0b43612 1970-01-01 00:00 +0000 test
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
| cmiss
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 7:4 0a3dd3e15e65 1970-01-01 00:00 +0000 test
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
| words
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
| o 6[feature2]:4 296fda51a303 1970-01-01 00:00 +0000 test
undo: no argument redo Changes redo to straight up undo the previous undo. This is a bit trickier than it may seem. The previous redo capabilities are still covered in hg undo as --index accepts negative numbers allowing you to step both forward and backwards one step at a time. The new redo reads the linear undo log to find out where to undo to while updating the undo/redo index allowing you to continue from where you left off. Differential Revision: https://phab.mercurial-scm.org/D286
2017-08-12 04:05:03 +03:00
|/ d
|
o 4 38d85b506754 1970-01-01 00:00 +0000 test
| c2
|
o 3:1 ec7553f7b382 1970-01-01 00:00 +0000 test
| c1
|
| o 2[feature1] 49cdb4091aca 1970-01-01 00:00 +0000 test
|/ b
|
o 1 b68836a6e2ca 1970-01-01 00:00 +0000 test
| a2
|
o 0 df4fd610a3d6 1970-01-01 00:00 +0000 test
a1
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
'Refined branch testing
Specific edge case testing
$ hg up null
0 files updated, 0 files merged, 9 files removed, 0 files unresolved
$ touch b1 && hg add b1 && hg ci -m b1
$ touch b2 && hg add b2 && hg ci -m b2
$ touch b3 && hg add b3 && hg ci -m b3
$ hg up null
0 files updated, 0 files merged, 3 files removed, 0 files unresolved
$ touch c1 && hg add c1 && hg ci -m c1
$ touch c2 && hg add c2 && hg ci -m c2
$ touch c3 && hg add c3 && hg ci -m c3
$ hg log -G -T compact
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
@ 26[tip] 0963b9e31e70 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
| c3
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 25 4e0ac6fa4ca0 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
| c2
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 24:-1 c54b1b73bb58 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
c1
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 23 f57edd138754 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
| b3
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 22 0cb4447a10a7 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
| b2
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 21:-1 90af9088326b 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
b1
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 20 a0b72b3048d6 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
| prev1
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 19:15 3ee6a6880888 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
| a9
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
| o 18[newbook]:15 35324a911c0d 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
|/ newbranch
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 15 75f63379f12b 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
| newfiles
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 14:8 d0fdb9510dbf 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
| newfiles
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 8[master] 1dafc0b43612 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
| cmiss
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 7:4 0a3dd3e15e65 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
| words
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
| o 6[feature2]:4 296fda51a303 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
|/ d
|
o 4 38d85b506754 1970-01-01 00:00 +0000 test
| c2
|
o 3:1 ec7553f7b382 1970-01-01 00:00 +0000 test
| c1
|
| o 2[feature1] 49cdb4091aca 1970-01-01 00:00 +0000 test
|/ b
|
o 1 b68836a6e2ca 1970-01-01 00:00 +0000 test
| a2
|
o 0 df4fd610a3d6 1970-01-01 00:00 +0000 test
a1
$ hg undo -b f57e
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before ci -m b3 (glob)
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
$ hg undo -b f57e
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before ci -m b2 (glob)
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
$ hg log -G -T compact -l5
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 26[tip] 0963b9e31e70 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
| c3
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 25 4e0ac6fa4ca0 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
| c2
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 24:-1 c54b1b73bb58 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
c1
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
@ 21:-1 90af9088326b 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
b1
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 20 a0b72b3048d6 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
| prev1
~
$ hg redo
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before undo -b f57e (glob)
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
$ hg log -G -T compact -l6
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 26[tip] 0963b9e31e70 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
| c3
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 25 4e0ac6fa4ca0 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
| c2
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 24:-1 c54b1b73bb58 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
c1
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
@ 22 0cb4447a10a7 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
| b2
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 21:-1 90af9088326b 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
b1
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 20 a0b72b3048d6 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
| prev1
~
$ hg undo -b 0963
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before ci -m c3 (glob)
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
$ hg log -G -T compact -l5
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
@ 25[tip] 4e0ac6fa4ca0 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
| c2
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 24:-1 c54b1b73bb58 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
c1
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 22 0cb4447a10a7 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
| b2
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 21:-1 90af9088326b 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
b1
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 20 a0b72b3048d6 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
| prev1
~
$ hg undo
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before undo -b 0963 (glob)
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
$ hg log -G -T compact -l6
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 26[tip] 0963b9e31e70 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
| c3
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 25 4e0ac6fa4ca0 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
| c2
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 24:-1 c54b1b73bb58 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
c1
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
@ 22 0cb4447a10a7 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
| b2
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 21:-1 90af9088326b 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
b1
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 20 a0b72b3048d6 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
| prev1
~
$ hg redo
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before undo (glob)
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
$ hg redo
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before undo -b 0963 (glob)
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
$ hg log -G -T compact -l6
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 26[tip] 0963b9e31e70 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
| c3
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 25 4e0ac6fa4ca0 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
| c2
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 24:-1 c54b1b73bb58 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
c1
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
@ 22 0cb4447a10a7 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
| b2
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 21:-1 90af9088326b 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
b1
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 20 a0b72b3048d6 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
| prev1
~
$ hg undo -b f57e
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before redo (glob)
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
$ hg log -G -T compact -l5
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 26[tip] 0963b9e31e70 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
| c3
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 25 4e0ac6fa4ca0 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
| c2
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 24:-1 c54b1b73bb58 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
c1
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
@ 21:-1 90af9088326b 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
b1
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 20 a0b72b3048d6 1970-01-01 00:00 +0000 test
undo: improved --branch handling Adds --branch handling to the no argument redo. Also adds better branch testing and takes a more sensible approach to an undo after an undo --branch. Redo now restores undoredo.i's --branch field. Undo after a undo --branch is now an absolute undo. See test cases. Test Plan: unit Differential Revision: https://phab.mercurial-scm.org/D324
2017-08-12 04:05:03 +03:00
| prev1
~
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
Interupted commands
Commands like hg rebase, unshelve and histedit may interupt in order for the
user to solve merge conflicts etc. Since for example hg rebase --abort may
permanently delete a commit, we do not want to undo to this state.
$ touch afile
$ echo "afile" > afile
$ hg add afile && hg ci -m afile
$ hg up 0963b9e31e70
3 files updated, 0 files merged, 2 files removed, 0 files unresolved
$ touch afile
$ echo "bfile" > afile
$ hg add afile && hg ci -m bfile
$ hg log -G -T compact -l6
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
@ 28[tip]:26 00617a57f780 1970-01-01 00:00 +0000 test
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
| bfile
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
| o 27:21 28dfc398cab7 1970-01-01 00:00 +0000 test
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
| | afile
| |
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o | 26 0963b9e31e70 1970-01-01 00:00 +0000 test
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
| | c3
| |
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o | 25 4e0ac6fa4ca0 1970-01-01 00:00 +0000 test
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
| | c2
| |
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o | 24:-1 c54b1b73bb58 1970-01-01 00:00 +0000 test
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
/ c1
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 21:-1 90af9088326b 1970-01-01 00:00 +0000 test
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
b1
$ cat >> $HGRCPATH <<EOF
> [extensions]
> rebase =
> EOF
$ hg rebase -r 00617 -d 28dfc
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
rebasing 28:00617a57f780 "bfile" (tip)
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
merging afile
warning: conflicts while merging afile! (edit, then use 'hg resolve --mark')
unresolved conflicts (see hg resolve, then hg rebase --continue)
[1]
$ hg log -G -T compact -l6
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
@ 28[tip]:26 00617a57f780 1970-01-01 00:00 +0000 test
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
| bfile
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
| @ 27:21 28dfc398cab7 1970-01-01 00:00 +0000 test
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
| | afile
| |
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o | 26 0963b9e31e70 1970-01-01 00:00 +0000 test
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
| | c3
| |
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o | 25 4e0ac6fa4ca0 1970-01-01 00:00 +0000 test
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
| | c2
| |
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o | 24:-1 c54b1b73bb58 1970-01-01 00:00 +0000 test
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
/ c1
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 21:-1 90af9088326b 1970-01-01 00:00 +0000 test
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
b1
$ hg resolve -m afile
(no more unresolved files)
continue: hg rebase --continue
$ hg rebase --continue
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
rebasing 28:00617a57f780 "bfile" (tip)
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
$ hg log -G -T compact -l6
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
@ 29[tip]:27 e642892c5cb0 1970-01-01 00:00 +0000 test
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
| bfile
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 27:21 28dfc398cab7 1970-01-01 00:00 +0000 test
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
| afile
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
| o 26 0963b9e31e70 1970-01-01 00:00 +0000 test
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
| | c3
| |
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
| o 25 4e0ac6fa4ca0 1970-01-01 00:00 +0000 test
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
| | c2
| |
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
| o 24:-1 c54b1b73bb58 1970-01-01 00:00 +0000 test
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
| c1
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 21:-1 90af9088326b 1970-01-01 00:00 +0000 test
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
b1
$ hg undo
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before rebase -r 00617 -d 28dfc (glob)
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
$ hg log -G -T compact -l6
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
@ 28[tip]:26 00617a57f780 1970-01-01 00:00 +0000 test
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
| bfile
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
| o 27:21 28dfc398cab7 1970-01-01 00:00 +0000 test
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
| | afile
| |
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o | 26 0963b9e31e70 1970-01-01 00:00 +0000 test
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
| | c3
| |
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o | 25 4e0ac6fa4ca0 1970-01-01 00:00 +0000 test
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
| | c2
| |
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o | 24:-1 c54b1b73bb58 1970-01-01 00:00 +0000 test
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
/ c1
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 21:-1 90af9088326b 1970-01-01 00:00 +0000 test
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
b1
$ hg redo
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before undo (glob)
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
$ hg log -G -T compact -l6
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
@ 29[tip]:27 e642892c5cb0 1970-01-01 00:00 +0000 test
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
| bfile
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 27:21 28dfc398cab7 1970-01-01 00:00 +0000 test
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
| afile
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
| o 26 0963b9e31e70 1970-01-01 00:00 +0000 test
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
| | c3
| |
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
| o 25 4e0ac6fa4ca0 1970-01-01 00:00 +0000 test
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
| | c2
| |
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
| o 24:-1 c54b1b73bb58 1970-01-01 00:00 +0000 test
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
| c1
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 21:-1 90af9088326b 1970-01-01 00:00 +0000 test
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
b1
$ hg undo
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before rebase -r 00617 -d 28dfc (glob)
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
$ hg rebase -r 00617 -d 28dfc
tests: update tests for upstream changes 5d45a997d11 in upstream changed rebase to use unfiltered repositories, which changes the definition of tip in these two tests. Let's update the test output.
2017-09-12 20:10:06 +03:00
rebasing 28:00617a57f780 "bfile"
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
merging afile
warning: conflicts while merging afile! (edit, then use 'hg resolve --mark')
unresolved conflicts (see hg resolve, then hg rebase --continue)
[1]
$ hg rebase --abort
rebase aborted
$ hg undo
undo: informative output Instead of the _showstats output from hg.py, we now output the args and time of the mercurial command we are undoing. Differential Revision: https://phab.mercurial-scm.org/D412
2017-08-18 21:37:45 +03:00
undone to *, before rebase -r 00617 -d 28dfc (glob)
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
$ hg log -G -T compact -l6
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
@ 28[tip]:26 00617a57f780 1970-01-01 00:00 +0000 test
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
| bfile
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
| o 27:21 28dfc398cab7 1970-01-01 00:00 +0000 test
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
| | afile
| |
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o | 26 0963b9e31e70 1970-01-01 00:00 +0000 test
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
| | c3
| |
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o | 25 4e0ac6fa4ca0 1970-01-01 00:00 +0000 test
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
| | c2
| |
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o | 24:-1 c54b1b73bb58 1970-01-01 00:00 +0000 test
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
/ c1
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 21:-1 90af9088326b 1970-01-01 00:00 +0000 test
undo: unfinished command handling hg rebase, histedit, unshelve and other commands may stop in an unfinished state because of merge conflicts or other reasons. The user then has the ability to continue or abort. Undoing in this case is slightly tricky as for example aborting a rebase will perform real strips and so undo will fail with an error. This change still records these states, but flags them as unfinished and skips over them when undoing and redoing. Hg undo --absolute does not ignore these states in the really unlikely situation you want to go to one of them. Differential Revision: https://phab.mercurial-scm.org/D410
2017-08-18 21:37:45 +03:00
b1
$ cat >> $HGRCPATH <<EOF
> [extensions]
> rebase =!
> EOF
undo: draft obsolete handling Obsoleted commits may be visible. To make sure that they are un-obsoleted after undo when appropriate, we add "draft() & obsolete()" recording. The most common case where this matters is undoing a mid stack amend. Differential Revision: https://phab.mercurial-scm.org/D438
2017-08-18 21:40:18 +03:00
Obsmarkers for instack amend
$ cat >> $HGRCPATH <<EOF
> [extensions]
fb-hgext: fix copied fb-hgext tests Summary: This is a big bulk of generally almost-obvious fixes to the moved tests. Mostly these fixes have to do with correct importing of the actual extensions. Depends on D6675329 Test Plan: - ./run-tests.py fails less after this commit - see further commits for more test fixes Reviewers: #sourcecontrol Differential Revision: https://phabricator.intern.facebook.com/D6675344
2018-01-09 14:06:09 +03:00
> fbamend=
undo: draft obsolete handling Obsoleted commits may be visible. To make sure that they are un-obsoleted after undo when appropriate, we add "draft() & obsolete()" recording. The most common case where this matters is undoing a mid stack amend. Differential Revision: https://phab.mercurial-scm.org/D438
2017-08-18 21:40:18 +03:00
> EOF
$ hg update 0963
0 files updated, 0 files merged, 1 files removed, 0 files unresolved
$ touch c5 && hg add c5 && hg amend c5
amend: use hint framework for restack Summary: This allows people to silence the hint. Reviewed By: markbt Differential Revision: D7392127 fbshipit-source-id: ac16f952a178d567ce13e22946127456972ebe85
2018-04-07 10:36:52 +03:00
hint[amend-restack]: descendants of 0963b9e31e70 are left behind - use 'hg restack' to rebase them
hint[hint-ack]: use 'hg hint --ack amend-restack' to silence these hints
undo: draft obsolete handling Obsoleted commits may be visible. To make sure that they are un-obsoleted after undo when appropriate, we add "draft() & obsolete()" recording. The most common case where this matters is undoing a mid stack amend. Differential Revision: https://phab.mercurial-scm.org/D438
2017-08-18 21:40:18 +03:00
$ hg log -G -T compact -l7
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
@ 30[tip]:25 e1c5a2a441f5 1970-01-01 00:00 +0000 test
undo: draft obsolete handling Obsoleted commits may be visible. To make sure that they are un-obsoleted after undo when appropriate, we add "draft() & obsolete()" recording. The most common case where this matters is undoing a mid stack amend. Differential Revision: https://phab.mercurial-scm.org/D438
2017-08-18 21:40:18 +03:00
| c3
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
| o 28:26 00617a57f780 1970-01-01 00:00 +0000 test
undo: draft obsolete handling Obsoleted commits may be visible. To make sure that they are un-obsoleted after undo when appropriate, we add "draft() & obsolete()" recording. The most common case where this matters is undoing a mid stack amend. Differential Revision: https://phab.mercurial-scm.org/D438
2017-08-18 21:40:18 +03:00
| | bfile
| |
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
| | o 27:21 28dfc398cab7 1970-01-01 00:00 +0000 test
undo: draft obsolete handling Obsoleted commits may be visible. To make sure that they are un-obsoleted after undo when appropriate, we add "draft() & obsolete()" recording. The most common case where this matters is undoing a mid stack amend. Differential Revision: https://phab.mercurial-scm.org/D438
2017-08-18 21:40:18 +03:00
| | | afile
| | |
restack: remove old pre-obsolesence fixup Summary: Per discussion with @[100000771202578:kulshrax] [1], the new behavior is enabled everywhere, and is also vastly preferable. Let's nuke the old code, as well as the config declaration and all places that manually enabled it. [1] > also, it looks like the pre-restack logic is still in that function, and the modern restack code path is still gated by a config option > we should probably remove that Reviewed By: kulshrax Differential Revision: D7031365 fbshipit-source-id: dcc620c292bac03fdc0aa144546d4628bb673046
2018-02-20 23:27:34 +03:00
| x | 26 0963b9e31e70 1970-01-01 00:00 +0000 test
undo: draft obsolete handling Obsoleted commits may be visible. To make sure that they are un-obsoleted after undo when appropriate, we add "draft() & obsolete()" recording. The most common case where this matters is undoing a mid stack amend. Differential Revision: https://phab.mercurial-scm.org/D438
2017-08-18 21:40:18 +03:00
|/ / c3
| |
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o | 25 4e0ac6fa4ca0 1970-01-01 00:00 +0000 test
undo: draft obsolete handling Obsoleted commits may be visible. To make sure that they are un-obsoleted after undo when appropriate, we add "draft() & obsolete()" recording. The most common case where this matters is undoing a mid stack amend. Differential Revision: https://phab.mercurial-scm.org/D438
2017-08-18 21:40:18 +03:00
| | c2
| |
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o | 24:-1 c54b1b73bb58 1970-01-01 00:00 +0000 test
undo: draft obsolete handling Obsoleted commits may be visible. To make sure that they are un-obsoleted after undo when appropriate, we add "draft() & obsolete()" recording. The most common case where this matters is undoing a mid stack amend. Differential Revision: https://phab.mercurial-scm.org/D438
2017-08-18 21:40:18 +03:00
/ c1
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 21:-1 90af9088326b 1970-01-01 00:00 +0000 test
undo: draft obsolete handling Obsoleted commits may be visible. To make sure that they are un-obsoleted after undo when appropriate, we add "draft() & obsolete()" recording. The most common case where this matters is undoing a mid stack amend. Differential Revision: https://phab.mercurial-scm.org/D438
2017-08-18 21:40:18 +03:00
b1
$ hg undo && hg update 00617a
undone to *, before amend c5 (glob)
1 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ hg log -G -T compact -l7
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
@ 28[tip]:26 00617a57f780 1970-01-01 00:00 +0000 test
undo: draft obsolete handling Obsoleted commits may be visible. To make sure that they are un-obsoleted after undo when appropriate, we add "draft() & obsolete()" recording. The most common case where this matters is undoing a mid stack amend. Differential Revision: https://phab.mercurial-scm.org/D438
2017-08-18 21:40:18 +03:00
| bfile
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
| o 27:21 28dfc398cab7 1970-01-01 00:00 +0000 test
undo: draft obsolete handling Obsoleted commits may be visible. To make sure that they are un-obsoleted after undo when appropriate, we add "draft() & obsolete()" recording. The most common case where this matters is undoing a mid stack amend. Differential Revision: https://phab.mercurial-scm.org/D438
2017-08-18 21:40:18 +03:00
| | afile
| |
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o | 26 0963b9e31e70 1970-01-01 00:00 +0000 test
undo: draft obsolete handling Obsoleted commits may be visible. To make sure that they are un-obsoleted after undo when appropriate, we add "draft() & obsolete()" recording. The most common case where this matters is undoing a mid stack amend. Differential Revision: https://phab.mercurial-scm.org/D438
2017-08-18 21:40:18 +03:00
| | c3
| |
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o | 25 4e0ac6fa4ca0 1970-01-01 00:00 +0000 test
undo: draft obsolete handling Obsoleted commits may be visible. To make sure that they are un-obsoleted after undo when appropriate, we add "draft() & obsolete()" recording. The most common case where this matters is undoing a mid stack amend. Differential Revision: https://phab.mercurial-scm.org/D438
2017-08-18 21:40:18 +03:00
| | c2
| |
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o | 24:-1 c54b1b73bb58 1970-01-01 00:00 +0000 test
undo: draft obsolete handling Obsoleted commits may be visible. To make sure that they are un-obsoleted after undo when appropriate, we add "draft() & obsolete()" recording. The most common case where this matters is undoing a mid stack amend. Differential Revision: https://phab.mercurial-scm.org/D438
2017-08-18 21:40:18 +03:00
/ c1
|
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 21:-1 90af9088326b 1970-01-01 00:00 +0000 test
undo: draft obsolete handling Obsoleted commits may be visible. To make sure that they are un-obsoleted after undo when appropriate, we add "draft() & obsolete()" recording. The most common case where this matters is undoing a mid stack amend. Differential Revision: https://phab.mercurial-scm.org/D438
2017-08-18 21:40:18 +03:00
b1
amend: fixing tests following the removal of redundant commit in amend Summary: cmdutil.amend was changed recently to get rid of the redundant commit during the amend operation. As a result, we need to update the tests which were aware of the redundant commit. This commit achieves the same. Note that as a result of the amend behavior change, the dirsync and copytrace extensions were broken. They will be be fixed in subsequent commits on top of this commit. For now, the broken tests for these extensions were removed from the commit. Eventually, I will fold all the fixes together so that revision history of the tests is not messed up. This is primarily done only to aid the review. Test Plan: Ran the test suite after updating the tests.
2017-09-08 19:58:14 +03:00
o 20 a0b72b3048d6 1970-01-01 00:00 +0000 test
undo: draft obsolete handling Obsoleted commits may be visible. To make sure that they are un-obsoleted after undo when appropriate, we add "draft() & obsolete()" recording. The most common case where this matters is undoing a mid stack amend. Differential Revision: https://phab.mercurial-scm.org/D438
2017-08-18 21:40:18 +03:00
| prev1
~
$ cat >> $HGRCPATH <<EOF
> [extensions]
> famend =!
> EOF
Reference in New Issue Copy Permalink