This is an archive of the discontinued Mercurial Phabricator instance.

Differential D52

undo: implements relative undo, hg redo and tests
ClosedPublic

Authored by felixmerk on Jul 11 2017, 5:56 PM.
Tags
None
Subscribers
quark, stash

Details

Reviewers
quark
Group Reviewers
Restricted Project
Commits
rFBHGX46c7e52c1deb: undo: implements relative undo, hg redo and tests
Summary

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.

Diff Detail

Repository
rFBHGX Facebook Mercurial Extensions
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

stash added a subscriber: stash.Jul 12 2017, 9:31 AM

This revision has no reviewers. Is it expected?

felixmerk updated this revision to Diff 106.Jul 13 2017, 12:41 AM
felixmerk added a reviewer: Restricted Project.Jul 13 2017, 12:42 AM
felixmerk updated this revision to Diff 211.Jul 17 2017, 3:09 PM
felixmerk updated this revision to Diff 315.Jul 19 2017, 5:31 PM
quark accepted this revision.Jul 19 2017, 5:37 PM
quark added a subscriber: quark.

Looks good to me except for some minor issues that need fix before push.

hgext3rd/undo.py
183

nit: remove this line.

184

I think we want to use a different file name, like redonode. .i is usually considered as the index of revlog.

401–402

_like_

This revision is now accepted and ready to land.Jul 19 2017, 5:37 PM
felixmerk updated this revision to Diff 323.Jul 19 2017, 8:45 PM
Closed by commit rFBHGX46c7e52c1deb: undo: implements relative undo, hg redo and tests (authored by felixmerk). · Explain WhyJul 19 2017, 10:23 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mhgext3rd/undo.py (82 lines)
Mtests/test-undo.t (116 lines)

Diff 315

hgext3rd/undo.py

# undo.py: records data in revlog for future undo functionality # undo.py: records data in revlog for future undo functionality
# #
# Copyright 2017 Facebook, Inc. # Copyright 2017 Facebook, Inc.
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
from __future__ import absolute_import from __future__ import absolute_import
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial import ( from mercurial import (
cmdutil, cmdutil,
dispatch, dispatch,
error, error,
extensions, extensions,
hg,
localrepo, localrepo,
lock as lockmod, lock as lockmod,
obsolete, obsolete,
registrar, registrar,
revlog, revlog,
revset, revset,
revsetlang, revsetlang,
smartset, smartset,
repo.vfs.makedirs('undolog') repo.vfs.makedirs('undolog')
with lockmod.lock(repo.vfs, "undolog/lock", desc="undolog"): with lockmod.lock(repo.vfs, "undolog/lock", desc="undolog"):
# developer config: undo._duringundologlock # developer config: undo._duringundologlock
if repo.ui.configbool('undo', '_duringundologlock'): if repo.ui.configbool('undo', '_duringundologlock'):
repo.hook("duringundologlock") repo.hook("duringundologlock")
tr = lighttransaction(repo) tr = lighttransaction(repo)
with tr: with tr:
changes = log(repo.filtered('visible'), command, tr) changes = log(repo.filtered('visible'), command, tr)
if changes and not ("undo" == command[0] or "redo" ==
command[0]):
_delundoredo(repo)
return changes return changes
def lighttransaction(repo): def lighttransaction(repo):
# full fledged transactions have two serious issues: # full fledged transactions have two serious issues:
# 1. they may cause infite loops through hooks # 1. they may cause infite loops through hooks
# that run commands # that run commands
# 2. they are really expensive performance wise # 2. they are really expensive performance wise
# #
def _logworkingparent(repo, tr): def _logworkingparent(repo, tr):
revstring = repo['.'].hex() revstring = repo['.'].hex()
return writelog(repo, tr, "workingparent.i", revstring) return writelog(repo, tr, "workingparent.i", revstring)
def _logindex(repo, tr, nodes): def _logindex(repo, tr, nodes):
revstring = "\n".join(sorted('%s %s' % (k, v) for k, v in nodes.items())) revstring = "\n".join(sorted('%s %s' % (k, v) for k, v in nodes.items()))
return writelog(repo, tr, "index.i", revstring) return writelog(repo, tr, "index.i", revstring)
def _logundoredoindex(repo, tr, reverseindex):
rlog = _getrevlog(repo, 'index.i')
hexnode = hex(rlog.node(_invertindex(rlog, reverseindex)))
#return writelog(repo, tr, "redo.i", "node " + str(hexnode))
quarkUnsubmitted
Not Done

nit: remove this line.

quark: nit: remove this line.
return repo.svfs.write("undolog/redo.i", str(hexnode))
quarkUnsubmitted
Not Done

I think we want to use a different file name, like redonode. .i is usually considered as the index of revlog.

quark: I think we want to use a different file name, like `redonode`. `.i` is usually considered as…
def _delundoredo(repo):
path = 'undolog' + '/' + 'redo.i'
repo.svfs.tryunlink(path)
# Read # Read
def _readindex(repo, reverseindex, prefetchedrevlog=None): def _readindex(repo, reverseindex, prefetchedrevlog=None):
if prefetchedrevlog is None: if prefetchedrevlog is None:
rlog = _getrevlog(repo, 'index.i') rlog = _getrevlog(repo, 'index.i')
else: else:
rlog = prefetchedrevlog rlog = prefetchedrevlog
index = _invertindex(rlog, reverseindex) index = _invertindex(rlog, reverseindex)
_('index must be a positive integer'), 1) _('index must be a positive integer'), 1)
revs = _getolddrafts(repo, reverseindex) revs = _getolddrafts(repo, reverseindex)
return smartset.baseset(revs) return smartset.baseset(revs)
# Undo: # Undo:
@command('undo', [ @command('undo', [
('n', 'index', 1, _("how many steps to undo back")), ('n', 'index', 1, _("how many steps to undo back")),
('a', 'absolute', False, _("absolute based on command index instead of "
"relative undo")),
]) ])
def undo(ui, repo, *args, **opts): def undo(ui, repo, *args, **opts):
"""perform an undo """perform an undo
Undoes an undoable command. An undoable command is one that changed at Undoes an undoable command. An undoable command is one that changed at
least one of the following three: bookmarks, working copy parent or least one of the following three: bookmarks, working copy parent or
changesets. Note that this specifically does not include commands like log. changesets. Note that this specifically does not include commands like log.
It will include update if update changes the working copy parent (you update It will include update if update changes the working copy parent (you update
to a changeset that isn't the current one). Note that commands that edit to a changeset that isn't the current one). Note that commands that edit
public repos can't be undone (specifically push). public repos can't be undone (specifically push).
Undo does not preserve the working copy changes. Undo does not preserve the working copy changes.
To undo to a specific state use the --index and --absolute flags.
See hg debugundohistory to get a list of indeces and commands run.
By undoing to a specific index you undo to the state after that command.
For example, hg undo --index 0 --absolute won't do anything, while
hg undo -n 1 -a will bring you back to the repo state before the current
one.
Without the --absolute flag, your undos will be relative. This means
they will behave how you expect them to. If you run hg undo twice,
you will move back two repo states from where you ran your first hg undo.
You can use this in conjunction with hg redo to move up and down repo
states. Note that as soon as you execute a different undoable command,
which isn't hg undo or hg redo, any new undos or redos will be relative to
the state after this command. When using --index with relative undos,
this is equivalent to running index many undos, except for leaving your
repo state history (hg debugundohistory) less cluttered.
Undo states are also distinct repo states and can thereby be inspected using
debugundohistory and specifically jumped to using undo --index --absolute.
""" """
reverseindex = opts.get("index") reverseindex = opts.get("index")
relativeundo = not opts.get("absolute")
with repo.wlock(), repo.lock(), repo.transaction("undo"): with repo.wlock(), repo.lock(), repo.transaction("undo"):
cmdutil.checkunfinished(repo) cmdutil.checkunfinished(repo)
cmdutil.bailifchanged(repo) cmdutil.bailifchanged(repo)
repo = repo.unfiltered() repo = repo.unfiltered()
if relativeundo:
reverseindex = _computerelative(repo, reverseindex)
_undoto(ui, repo, reverseindex)
# store undo data
# for absolute undos, think of this as a reset
# for relative undos, think of this as an update
_logundoredoindex(repo, repo.currenttransaction(), reverseindex)
@command('redo', [
('n', 'index', 1, _("how many commands to redo")),
])
def redo(ui, repo, *args, **opts):
""" perform a redo
Performs a redo. Specifically, redo moves forward a repo state relative to
the previous undo or redo command. If you run hg undo -n 10, you can redo
each of the 10 repo states one by one all the way back to the state from
which you ran undo. You can use --index to redo across more states at once,
and you can use any number of undos/redos up to the current state or back to
when the undo extension was first active.
"""
reverseindex = -1 * abs(opts.get("index"))
reverseindex = _computerelative(repo, reverseindex)
with repo.wlock(), repo.lock(), repo.transaction("redo"):
cmdutil.checkunfinished(repo)
cmdutil.bailifchanged(repo)
quarkUnsubmitted
Not Done

_like_

quark: _like_
repo = repo.unfiltered()
_undoto(ui, repo, reverseindex) _undoto(ui, repo, reverseindex)
_logundoredoindex(repo, repo.currenttransaction(), reverseindex)
def _undoto(ui, repo, reverseindex): def _undoto(ui, repo, reverseindex):
# undo to specific reverseindex # undo to specific reverseindex
# requires inhibit extension # requires inhibit extension
try: try:
nodedict = _readindex(repo, reverseindex) nodedict = _readindex(repo, reverseindex)
except IndexError: except IndexError:
raise error.Abort(_("index out of bounds")) raise error.Abort(_("index out of bounds"))
kv = mark.rsplit(" ", 1) kv = mark.rsplit(" ", 1)
bmchanges.append((kv[0], bin(kv[1]))) bmchanges.append((kv[0], bin(kv[1])))
repo._bookmarks.applychanges(repo, repo.currenttransaction(), bmchanges) repo._bookmarks.applychanges(repo, repo.currenttransaction(), bmchanges)
# working copy parent # working copy parent
workingcopyparent = _readnode(repo, "workingparent.i", workingcopyparent = _readnode(repo, "workingparent.i",
nodedict["workingparent"]) nodedict["workingparent"])
revealcommits(repo, workingcopyparent) revealcommits(repo, workingcopyparent)
commands.update(ui, repo, rev=workingcopyparent) hg.updatetotally(ui, repo, workingcopyparent, workingcopyparent,
clean=False, updatecheck='abort')
# visible changesets # visible changesets
addedrevs = revsetlang.formatspec('olddraft(0) - olddraft(%d)', addedrevs = revsetlang.formatspec('olddraft(0) - olddraft(%d)',
reverseindex) reverseindex)
hidecommits(repo, addedrevs) hidecommits(repo, addedrevs)
removedrevs = revsetlang.formatspec('olddraft(%d) - olddraft(0)', removedrevs = revsetlang.formatspec('olddraft(%d) - olddraft(0)',
reverseindex) reverseindex)
revealcommits(repo, removedrevs) revealcommits(repo, removedrevs)
def _computerelative(repo, reverseindex):
# allows for relative undos using
# redo.i storage
try:
hexnode = repo.svfs.read("undolog/redo.i")
rlog = _getrevlog(repo, 'index.i')
rev = rlog.rev(bin(hexnode))
reverseindex = _invertindex(rlog, rev) + reverseindex
except IOError:
# return input index
pass
return reverseindex
# hide and reveal commits # hide and reveal commits
def hidecommits(repo, rev): def hidecommits(repo, rev):
ctxts = repo.set(rev) ctxts = repo.set(rev)
for commit in ctxts: for commit in ctxts:
obsolete.createmarkers(repo, [[commit,[]]]) obsolete.createmarkers(repo, [[commit,[]]])
def revealcommits(repo, rev): def revealcommits(repo, rev):

tests/test-undo.t

$ cat >> $HGRCPATH <<EOF $ cat >> $HGRCPATH <<EOF
> [extensions] > [extensions]
> undo = $TESTDIR/../hgext3rd/undo.py > undo = $TESTDIR/../hgext3rd/undo.py
> inhibit=$TESTDIR/../hgext3rd/inhibit.py
> [undo] > [undo]
> _duringundologlock=1 > _duringundologlock=1
> [experimental]
> evolution=createmarkers
> EOF > EOF
Build up a repo Build up a repo
$ hg init repo $ hg init repo
$ cd repo $ cd repo
Test data store Test data store
aa430c8afedf9b2ec3f0655d39eef6b6b0a2ddb6 aa430c8afedf9b2ec3f0655d39eef6b6b0a2ddb6
REMOVED: REMOVED:
1dafc0b436123cab96f82a8e9e8d1d42c0301aaa 1dafc0b436123cab96f82a8e9e8d1d42c0301aaa
workingparent: workingparent:
aa430c8afedf9b2ec3f0655d39eef6b6b0a2ddb6 aa430c8afedf9b2ec3f0655d39eef6b6b0a2ddb6
Test 'olddraft([NUM])' revset Test 'olddraft([NUM])' revset
$ hg log -G -r 'olddraft(0) - olddraft(1)' --hidden -T compact $ hg log -G -r 'olddraft(0) - olddraft(1)' --hidden -T compact
@ 8[tip][master] aa430c8afedf 1970-01-01 00:00 +0000 test @ 10[tip][master] aa430c8afedf 1970-01-01 00:00 +0000 test
| a5 | a5
~ ~
Test undolog lock Test undolog lock
$ hg log --config hooks.duringundologlock="sleep 1" > /dev/null & $ hg log --config hooks.duringundologlock="sleep 1" > /dev/null &
$ sleep 0.1 $ sleep 0.1
$ hg st --time $ hg st --time
time: real [1-9]*\..* (re) time: real [1-9]*\..* (re)
hg undo command tests
$ hg undo
0 files updated, 0 files merged, 1 files removed, 0 files unresolved
(leaving bookmark master)
$ hg log -G -T compact -l2
@ 9[tip][master] 1dafc0b43612 1970-01-01 00:00 +0000 test
| cmiss
|
o 8:4 0a3dd3e15e65 1970-01-01 00:00 +0000 test
| words
~
$ hg update 0a3dd3e15e65
0 files updated, 0 files merged, 1 files removed, 0 files unresolved
$ hg undo
1 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ hg log -G -T compact -l1
@ 9[tip][master] 1dafc0b43612 1970-01-01 00:00 +0000 test
| cmiss
~
$ touch c11 && hg add c11
$ hg commit --amend
$ hg log -G -T compact -l1
@ 12[tip][master]:8 2dca609174c2 1970-01-01 00:00 +0000 test
| cmiss
~
$ hg undo
0 files updated, 0 files merged, 1 files removed, 0 files unresolved
$ hg log -G -T compact -l4
@ 9[tip][master] 1dafc0b43612 1970-01-01 00:00 +0000 test
| cmiss
|
o 8:4 0a3dd3e15e65 1970-01-01 00:00 +0000 test
| words
|
| o 7[feature2]:4 296fda51a303 1970-01-01 00:00 +0000 test
|/ d
|
o 4 38d85b506754 1970-01-01 00:00 +0000 test
| c2
~
$ hg graft 296fda51a303
grafting 7:296fda51a303 "d" (feature2)
$ hg log -G -T compact -l2
@ 13[tip]:9 f007a7cf4c3d 1970-01-01 00:00 +0000 test
| d
|
o 9[master] 1dafc0b43612 1970-01-01 00:00 +0000 test
| cmiss
~
$ hg undo
0 files updated, 0 files merged, 2 files removed, 0 files unresolved
$ hg log -G -T compact -l1
@ 9[tip][master] 1dafc0b43612 1970-01-01 00:00 +0000 test
| cmiss
~
$ hg book test
$ hg undo
0 files updated, 0 files merged, 0 files removed, 0 files unresolved
(leaving bookmark test)
$ hg bookmarks
feature1 2:49cdb4091aca
feature2 7:296fda51a303
master 9:1dafc0b43612
hg redo test
$ hg redo
0 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ hg log -G -T compact -l1
@ 9[tip][master,test] 1dafc0b43612 1970-01-01 00:00 +0000 test
| cmiss
~
$ hg undo
0 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ hg log -G -T compact -l1
@ 9[tip][master] 1dafc0b43612 1970-01-01 00:00 +0000 test
| cmiss
~
$ hg undo -n 5
0 files updated, 0 files merged, 1 files removed, 0 files unresolved
$ hg redo -n 5
1 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ hg log -G -T compact -l1
@ 9[tip][master] 1dafc0b43612 1970-01-01 00:00 +0000 test
| cmiss
~
$ hg redo -n 100
abort: index out of bounds
[255]
hg undo --absolute tests
$ hg undo -a
0 files updated, 0 files merged, 1 files removed, 0 files unresolved
$ hg redo
1 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ hg undo -a
0 files updated, 0 files merged, 1 files removed, 0 files unresolved
$ hg redo
1 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ hg undo -n 5
0 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ hg log -G -T compact -l1
@ 9[tip][master,test] 1dafc0b43612 1970-01-01 00:00 +0000 test
| cmiss
~
$ hg undo -a
0 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ hg log -G -T compact -l1
@ 9[tip][master] 1dafc0b43612 1970-01-01 00:00 +0000 test
| cmiss
~