This is an archive of the discontinued Mercurial Phabricator instance.

Differential D6186

changelog: parse copy metadata if available in extras
ClosedPublic

Authored by martinvonz on Apr 2 2019, 3:30 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG5382d8f8530b: changelog: parse copy metadata if available in extras
rHGc2165551eed6: changelog: parse copy metadata if available in extras
rHG0cfd1f9fb02b: changelog: parse copy metadata if available in extras
Summary

This lets read back the copy metadata we just started writing. There
are still many places left to teach about getting the copy information
from the changeset, but we have enough ({file_copies}, specifically)
that we can add it now and have some test coverage of it.

Diff Detail

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

Revision Contents
Changeset List

Diff 14792

mercurial/changelog.py

def encodecopies(copies): def encodecopies(copies):
items = [ items = [
'%s\0%s' % (k, copies[k]) '%s\0%s' % (k, copies[k])
for k in sorted(copies) for k in sorted(copies)
] ]
return "\n".join(items) return "\n".join(items)
def decodecopies(data):
try:
copies = {}
for l in data.split('\n'):
k, v = l.split('\0')
copies[k] = v
return copies
except ValueError:
# Perhaps someone had chosen the same key name (e.g. "p1copies") and
# used different syntax for the value.
return None
def stripdesc(desc): def stripdesc(desc):
"""strip trailing whitespace and leading and trailing empty lines""" """strip trailing whitespace and leading and trailing empty lines"""
return '\n'.join([l.rstrip() for l in desc.splitlines()]).strip('\n') return '\n'.join([l.rstrip() for l in desc.splitlines()]).strip('\n')
class appender(object): class appender(object):
'''the changelog index must be updated last on disk, so we use this class '''the changelog index must be updated last on disk, so we use this class
to delay writes to it''' to delay writes to it'''
def __init__(self, vfs, name, mode, buf): def __init__(self, vfs, name, mode, buf):
def files(self): def files(self):
off = self._offsets off = self._offsets
if off[2] == off[3]: if off[2] == off[3]:
return [] return []
return self._text[off[2] + 1:off[3]].split('\n') return self._text[off[2] + 1:off[3]].split('\n')
@property @property
def p1copies(self):
rawcopies = self.extra.get('p1copies')
return rawcopies and decodecopies(rawcopies)
@property
def p2copies(self):
rawcopies = self.extra.get('p2copies')
return rawcopies and decodecopies(rawcopies)
@property
def description(self): def description(self):
return encoding.tolocal(self._text[self._offsets[3] + 2:]) return encoding.tolocal(self._text[self._offsets[3] + 2:])
class changelog(revlog.revlog): class changelog(revlog.revlog):
def __init__(self, opener, trypending=False): def __init__(self, opener, trypending=False):
"""Load a changelog revlog using an opener. """Load a changelog revlog using an opener.
If ``trypending`` is true, we attempt to load the index from a If ``trypending`` is true, we attempt to load the index from a

mercurial/context.py

def user(self): def user(self):
return self._changeset.user return self._changeset.user
def date(self): def date(self):
return self._changeset.date return self._changeset.date
def files(self): def files(self):
return self._changeset.files return self._changeset.files
@propertycache @propertycache
def _copies(self): def _copies(self):
source = self._repo.ui.config('experimental', 'copies.read-from')
p1copies = self._changeset.p1copies
p2copies = self._changeset.p2copies
# If config says to get copy metadata only from changeset, then return
# that, defaulting to {} if there was no copy metadata.
# In compatibility mode, we return copy data from the changeset if
# it was recorded there, and otherwise we fall back to getting it from
# the filelogs (below).
if (source == 'changeset-only' or
(source == 'compatibility' and p1copies is not None)):
return p1copies or {}, p2copies or {}
# Otherwise (config said to read only from filelog, or we are in
# compatiblity mode and there is not data in the changeset), we get
# the copy metadata from the filelogs.
p1copies = {} p1copies = {}
p2copies = {} p2copies = {}
p1 = self.p1() p1 = self.p1()
p2 = self.p2() p2 = self.p2()
narrowmatch = self._repo.narrowmatch() narrowmatch = self._repo.narrowmatch()
for dst in self.files(): for dst in self.files():
if not narrowmatch(dst) or dst not in self: if not narrowmatch(dst) or dst not in self:
continue continue

mercurial/copies.py

files _forwardcopies is about to process. files _forwardcopies is about to process.
""" """
ma = a.manifest() ma = a.manifest()
mb = b.manifest() mb = b.manifest()
return mb.filesnotin(ma, match=match) return mb.filesnotin(ma, match=match)
def usechangesetcentricalgo(repo): def usechangesetcentricalgo(repo):
"""Checks if we should use changeset-centric copy algorithms""" """Checks if we should use changeset-centric copy algorithms"""
return (repo.ui.config('experimental', 'copies.read-from') == return (repo.ui.config('experimental', 'copies.read-from') in
'compatibility') ('changeset-only', 'compatibility'))
def _committedforwardcopies(a, b, match): def _committedforwardcopies(a, b, match):
"""Like _forwardcopies(), but b.rev() cannot be None (working copy)""" """Like _forwardcopies(), but b.rev() cannot be None (working copy)"""
# files might have to be traced back to the fctx parent of the last # files might have to be traced back to the fctx parent of the last
# one-side-only changeset, but not further back than that # one-side-only changeset, but not further back than that
repo = a._repo repo = a._repo
if usechangesetcentricalgo(repo): if usechangesetcentricalgo(repo):

tests/test-copies-in-changeset.t

$ cat >> $HGRCPATH << EOF $ cat >> $HGRCPATH << EOF
> [experimental] > [experimental]
> copies.write-to=changeset-only > copies.write-to=changeset-only
> copies.read-from=changeset-only
> [alias] > [alias]
> changesetcopies = log -r . -T 'files: {files} > changesetcopies = log -r . -T 'files: {files}
> {extras % "{ifcontains("copies", key, "{key}: {value}\n")}"}' > {extras % "{ifcontains("copies", key, "{key}: {value}\n")}"}'
> showcopies = log -r . -T '{file_copies % "{source} -> {name}\n"}'
> EOF > EOF
Check that copies are recorded correctly Check that copies are recorded correctly
$ hg init repo $ hg init repo
$ cd repo $ cd repo
$ echo a > a $ echo a > a
$ hg add a $ hg add a
$ hg ci -m initial $ hg ci -m initial
$ hg cp a b $ hg cp a b
$ hg cp a c $ hg cp a c
$ hg cp a d $ hg cp a d
$ hg ci -m 'copy a to b, c, and d' $ hg ci -m 'copy a to b, c, and d'
$ hg changesetcopies $ hg changesetcopies
files: b c d files: b c d
p1copies: b\x00a (esc) p1copies: b\x00a (esc)
c\x00a (esc) c\x00a (esc)
d\x00a (esc) d\x00a (esc)
$ hg showcopies
a -> b
a -> c
a -> d
$ hg showcopies --config experimental.copies.read-from=compatibility
a -> b
a -> c
a -> d
$ hg showcopies --config experimental.copies.read-from=filelog-only
Check that renames are recorded correctly Check that renames are recorded correctly
$ hg mv b b2 $ hg mv b b2
$ hg ci -m 'rename b to b2' $ hg ci -m 'rename b to b2'
$ hg changesetcopies $ hg changesetcopies
files: b b2 files: b b2
p1copies: b2\x00b (esc) p1copies: b2\x00b (esc)
$ hg showcopies
b -> b2
Rename onto existing file. This should get recorded in the changeset files list and in the extras, Rename onto existing file. This should get recorded in the changeset files list and in the extras,
even though there is no filelog entry. even though there is no filelog entry.
$ hg cp b2 c --force $ hg cp b2 c --force
$ hg st --copies $ hg st --copies
M c M c
b2 b2
$ hg debugindex c $ hg debugindex c
rev linkrev nodeid p1 p2 rev linkrev nodeid p1 p2
0 1 b789fdd96dc2 000000000000 000000000000 0 1 b789fdd96dc2 000000000000 000000000000
$ hg ci -m 'move b onto d' $ hg ci -m 'move b onto d'
$ hg changesetcopies $ hg changesetcopies
files: c files: c
p1copies: c\x00b2 (esc) p1copies: c\x00b2 (esc)
$ hg showcopies
b2 -> c
$ hg debugindex c $ hg debugindex c
rev linkrev nodeid p1 p2 rev linkrev nodeid p1 p2
0 1 b789fdd96dc2 000000000000 000000000000 0 1 b789fdd96dc2 000000000000 000000000000
Create a merge commit with copying done during merge. Create a merge commit with copying done during merge.
$ hg co 0 $ hg co 0
0 files updated, 0 files merged, 3 files removed, 0 files unresolved 0 files updated, 0 files merged, 3 files removed, 0 files unresolved
File 'f' exists only in p1, so 'i' should be from p1 File 'f' exists only in p1, so 'i' should be from p1
$ hg cp f i $ hg cp f i
$ hg ci -m 'merge' $ hg ci -m 'merge'
$ hg changesetcopies $ hg changesetcopies
files: g h i files: g h i
p1copies: g\x00a (esc) p1copies: g\x00a (esc)
i\x00f (esc) i\x00f (esc)
p2copies: h\x00d (esc) p2copies: h\x00d (esc)
$ hg showcopies
a -> g
d -> h
f -> i
Test writing to both changeset and filelog Test writing to both changeset and filelog
$ hg cp a j $ hg cp a j
$ hg ci -m 'copy a to j' --config experimental.copies.write-to=compatibility $ hg ci -m 'copy a to j' --config experimental.copies.write-to=compatibility
$ hg changesetcopies $ hg changesetcopies
files: j files: j
p1copies: j\x00a (esc) p1copies: j\x00a (esc)
$ hg debugdata j 0 $ hg debugdata j 0
\x01 (esc) \x01 (esc)
copy: a copy: a
copyrev: b789fdd96dc2f3bd229c1dd8eedf0fc60e2b68e3 copyrev: b789fdd96dc2f3bd229c1dd8eedf0fc60e2b68e3
\x01 (esc) \x01 (esc)
a a
$ hg showcopies
a -> j
$ hg showcopies --config experimental.copies.read-from=compatibility
a -> j
$ hg showcopies --config experimental.copies.read-from=filelog-only
a -> j
Test writing only to filelog Test writing only to filelog
$ hg cp a k $ hg cp a k
$ hg ci -m 'copy a to k' --config experimental.copies.write-to=filelog-only $ hg ci -m 'copy a to k' --config experimental.copies.write-to=filelog-only
$ hg changesetcopies $ hg changesetcopies
files: k files: k
$ hg debugdata k 0 $ hg debugdata k 0
\x01 (esc) \x01 (esc)
copy: a copy: a
copyrev: b789fdd96dc2f3bd229c1dd8eedf0fc60e2b68e3 copyrev: b789fdd96dc2f3bd229c1dd8eedf0fc60e2b68e3
\x01 (esc) \x01 (esc)
a a
$ hg showcopies
$ hg showcopies --config experimental.copies.read-from=compatibility
a -> k
$ hg showcopies --config experimental.copies.read-from=filelog-only
a -> k
$ cd .. $ cd ..

tests/test-copies.t

#testcases filelog compatibility #testcases filelog compatibility changeset
$ cat >> $HGRCPATH << EOF $ cat >> $HGRCPATH << EOF
> [extensions] > [extensions]
> rebase= > rebase=
> [alias] > [alias]
> l = log -G -T '{rev} {desc}\n{files}\n' > l = log -G -T '{rev} {desc}\n{files}\n'
> EOF > EOF
#if compatibility #if compatibility
$ cat >> $HGRCPATH << EOF $ cat >> $HGRCPATH << EOF
> [experimental] > [experimental]
> copies.read-from = compatibility > copies.read-from = compatibility
> EOF > EOF
#endif #endif
#if changeset
$ cat >> $HGRCPATH << EOF
> [experimental]
> copies.read-from = changeset-only
> copies.write-to = changeset-only
> EOF
#endif
$ REPONUM=0 $ REPONUM=0
$ newrepo() { $ newrepo() {
> cd $TESTTMP > cd $TESTTMP
> REPONUM=`expr $REPONUM + 1` > REPONUM=`expr $REPONUM + 1`
> hg init repo-$REPONUM > hg init repo-$REPONUM
> cd repo-$REPONUM > cd repo-$REPONUM
> } > }
$ hg l $ hg l
@ 2 merge @ 2 merge
|\ x z |\ x z
| o 1 add x on branch 2 | o 1 add x on branch 2
| x | x
o 0 add x on branch 1 o 0 add x on branch 1
x x
$ hg debugp1copies -r 2 $ hg debugp1copies -r 2
x -> z (changeset !)
$ hg debugp2copies -r 2 $ hg debugp2copies -r 2
x -> z x -> z (no-changeset !)
$ hg debugpathcopies 1 2 $ hg debugpathcopies 1 2
x -> z (changeset !)
$ hg debugpathcopies 0 2 $ hg debugpathcopies 0 2
x -> z x -> z (no-changeset !)
Copy x->y on one side of merge and copy x->z on the other side. Pathcopies from one parent Copy x->y on one side of merge and copy x->z on the other side. Pathcopies from one parent
of the merge to the merge should include the copy from the other side. of the merge to the merge should include the copy from the other side.
$ newrepo $ newrepo
$ echo x > x $ echo x > x
$ hg ci -Aqm 'add x' $ hg ci -Aqm 'add x'
$ hg cp x y $ hg cp x y
$ hg ci -qm 'copy x to y' $ hg ci -qm 'copy x to y'
|/ b b1 |/ b b1
o 1 added b o 1 added b
| b | b
o 0 added a o 0 added a
a a
Grafting revision 4 on top of revision 2, showing that it respect the rename: Grafting revision 4 on top of revision 2, showing that it respect the rename:
TODO: Make this work with copy info in changesets (probably by writing a
changeset-centric version of copies.mergecopies())
#if no-changeset
$ hg up 2 -q $ hg up 2 -q
$ hg graft -r 4 --base 3 --hidden $ hg graft -r 4 --base 3 --hidden
grafting 4:af28412ec03c "added d, modified b" (tip) grafting 4:af28412ec03c "added d, modified b" (tip)
merging b1 and b to b1 merging b1 and b to b1
$ hg l -l1 -p $ hg l -l1 -p
@ 5 added d, modified b @ 5 added d, modified b
| b1 | b1
~ diff -r 5a4825cc2926 -r 94a2f1a0e8e2 b1 ~ diff -r 5a4825cc2926 -r 94a2f1a0e8e2 b1
--- a/b1 Thu Jan 01 00:00:00 1970 +0000 --- a/b1 Thu Jan 01 00:00:00 1970 +0000
+++ b/b1 Thu Jan 01 00:00:00 1970 +0000 +++ b/b1 Thu Jan 01 00:00:00 1970 +0000
@@ -1,1 +1,2 @@ @@ -1,1 +1,2 @@
b b
+baba +baba
#endif
Test to make sure that fullcopytracing algorithm don't fail when both the merging csets are dirty Test to make sure that fullcopytracing algorithm don't fail when both the merging csets are dirty
(a dirty cset is one who is not the descendant of merge base) (a dirty cset is one who is not the descendant of merge base)
------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------
$ newrepo $ newrepo
$ echo a > a $ echo a > a
$ hg add a $ hg add a
$ hg ci -m "added a" $ hg ci -m "added a"