This is an archive of the discontinued Mercurial Phabricator instance.

Differential D8035

copy: add experimental support for marking committed copies
ClosedPublic

Authored by martinvonz on Jan 28 2020, 6:51 PM.

Details

Reviewers
durin42
marmoute
Group Reviewers
hg-reviewers
Commits
rHG9dab3fa64325: copy: add experimental support for marking committed copies
Summary

The simplest way I'm aware of to mark a file as copied/moved after
committing is this:

hg uncommit --keep <src> <dest>  # <src> needed for move, but not copy
hg mv --after <src> <dest>
hg amend

This patch teaches hg copy a --at-rev argument to simplify that
into:

hg copy --after --at-rev . <src> <dest>

In addition to being simpler, it doesn't touch the working copy, so it
can easily be used even if the destination file has been modified in
the working copy.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

martinvonz created this revision.Jan 28 2020, 6:51 PM
martinvonz updated this revision to Diff 19671.Jan 28 2020, 6:55 PM
martinvonz updated this revision to Diff 19697.Jan 29 2020, 6:37 PM
marmoute added a subscriber: marmoute.Feb 7 2020, 3:52 PM

See my comment in D8030, the feature is interresting, but it seems to me that we should implement that through regular amend.

martinvonz updated this revision to Diff 20073.Feb 10 2020, 5:43 PM
martinvonz updated this revision to Diff 20086.Feb 10 2020, 6:30 PM
durin42 accepted this revision.Feb 12 2020, 2:45 PM
durin42 added a subscriber: durin42.
In D8035#119861, @marmoute wrote:

See my comment in D8030, the feature is interresting, but it seems to me that we should implement that through regular amend.

On the one hand that's a thought, but I mostly feel like the functionality belongs in hg copy since that's where I'd look for it.

This revision is now accepted and ready to land.Feb 12 2020, 2:45 PM
martinvonz updated this revision to Diff 20195.Feb 13 2020, 2:09 PM
martinvonz updated this revision to Diff 20206.Feb 13 2020, 6:22 PM
marmoute added a comment.Feb 13 2020, 6:31 PM
In D8035#120590, @durin42 wrote:
In D8035#119861, @marmoute wrote:

See my comment in D8030, the feature is interresting, but it seems to me that we should implement that through regular amend.

On the one hand that's a thought, but I mostly feel like the functionality belongs in hg copy since that's where I'd look for it.

I am not sure I understand what you mean. What I meant was: adding new copies data seems like the jobs of hg copy but actually updating the working directory parents seems like a job for hg amend. So I would use a combinaison of the two commands to do so.

marmoute added a comment.Feb 13 2020, 6:32 PM

See my comment on D8030 https://phab.mercurial-scm.org/D8030#120771 This proposed change is part of a much bigger picture that requires wider discussion before we can safely proceed.

(Sorry for the delay this will involves, I wish the idea had explicitly surfaced earlier).

marmoute requested changes to this revision.Feb 13 2020, 6:35 PM
This revision now requires changes to proceed.Feb 13 2020, 6:35 PM
martinvonz retitled this revision from copy: add support for marking committed copies to copy: add experimental support for marking committed copies.Feb 13 2020, 6:53 PM
martinvonz updated this revision to Diff 20208.
martinvonz updated this revision to Diff 20233.Feb 14 2020, 6:19 PM

fixed stale uses of -r in commit message and transient code

martinvonz added a commit: rHG9dab3fa64325: copy: add experimental support for marking committed copies.Feb 15 2020, 2:12 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG9dab3fa64325: copy: add experimental support for marking committed copies (authored by martinvonz). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/cmdutil.py (62 lines)
Mmercurial/commands.py (7 lines)
Mrelnotes/next (4 lines)
Mtests/test-completion.t (2 lines)
Mtests/test-rename-after-merge.t (4 lines)
Ptests/test-rename-rev.t (718 lines)
Copied from tests/test-rename.t
Ptests/test-rename.t
Copied to tests/test-rename-rev.t

Diff 19671

mercurial/cmdutil.py

# called with the repo lock held # called with the repo lock held
# #
# hgsep => pathname that uses "/" to separate directories # hgsep => pathname that uses "/" to separate directories
# ossep => pathname that uses os.sep to separate directories # ossep => pathname that uses os.sep to separate directories
cwd = repo.getcwd() cwd = repo.getcwd()
targets = {} targets = {}
after = opts.get(b"after") after = opts.get(b"after")
dryrun = opts.get(b"dry_run") dryrun = opts.get(b"dry_run")
rev = opts.get(b'rev')
if rev:
if not after:
# TODO: Remove this restriction and make it also create the copy
# targets (and remove the rename source if rename==True).
raise error.Abort(_(b'--rev requires --after'))
ctx = scmutil.revsingle(repo, rev)
if len(ctx.parents()) > 1:
raise error.Abort(_(b'cannot mark copy in merge commit'))
else:
ctx = repo[None] ctx = repo[None]
pctx = ctx.p1() pctx = ctx.p1()
pats = scmutil.expandpats(pats) pats = scmutil.expandpats(pats)
if not pats: if not pats:
raise error.Abort(_(b'no source or destination specified')) raise error.Abort(_(b'no source or destination specified'))
if len(pats) == 1: if len(pats) == 1:
raise error.Abort(_(b'no destination specified')) raise error.Abort(_(b'no destination specified'))
dest = pats.pop() dest = pats.pop()
) )
continue continue
# abs: hgsep # abs: hgsep
# rel: ossep # rel: ossep
srcs.append((abs, rel, exact)) srcs.append((abs, rel, exact))
return srcs return srcs
if ctx.rev() is not None:
rewriteutil.precheck(repo, [ctx.rev()], b'uncopy')
absdest = pathutil.canonpath(repo.root, cwd, dest)
if ctx.hasdir(absdest):
raise error.Abort(
_(b'%s: --rev does not support a directory as destination')
% uipathfn(absdest)
)
if absdest not in ctx:
raise error.Abort(
_(b'%s: copy destination does not exist in %s')
% (uipathfn(absdest), ctx)
)
# avoid cycle context -> subrepo -> cmdutil
from . import context
copylist = []
for pat in pats:
srcs = walkpat(pat)
if not srcs:
continue
for abs, rel, exact in srcs:
copylist.append(abs)
# TODO: Add support for `hg cp -r . foo bar dir` and
# `hg cp -r . dir1 dir2`, preferably unifying the code with the existing
# functions below.
if len(copylist) != 1:
raise error.Abort(_(b'--rev requires a single source'))
new_ctx = context.overlayworkingctx(repo)
new_ctx.setbase(ctx.p1())
mergemod.graft(repo, ctx, wctx=new_ctx)
new_ctx.markcopied(absdest, copylist[0])
with repo.lock():
mem_ctx = new_ctx.tomemctx_for_amend(ctx)
new_node = mem_ctx.commit()
if repo.dirstate.p1() == ctx.node():
with repo.dirstate.parentchange():
scmutil.movedirstate(repo, repo[new_node])
replacements = {ctx.node(): [new_node]}
scmutil.cleanupnodes(repo, replacements, b'copy', fixphase=True)
return
# abssrc: hgsep # abssrc: hgsep
# relsrc: ossep # relsrc: ossep
# otarget: ossep # otarget: ossep
def copyfile(abssrc, relsrc, otarget, exact): def copyfile(abssrc, relsrc, otarget, exact):
abstarget = pathutil.canonpath(repo.root, cwd, otarget) abstarget = pathutil.canonpath(repo.root, cwd, otarget)
if b'/' in abstarget: if b'/' in abstarget:
# We cannot normalize abstarget itself, this would prevent # We cannot normalize abstarget itself, this would prevent
# case only renames, like a => A. # case only renames, like a => A.

mercurial/commands.py

[ [
(b'A', b'after', None, _(b'record a copy that has already occurred')), (b'A', b'after', None, _(b'record a copy that has already occurred')),
( (
b'f', b'f',
b'force', b'force',
None, None,
_(b'forcibly copy over an existing managed file'), _(b'forcibly copy over an existing managed file'),
), ),
(
b'r',
b'rev',
'',
_(b'mark copied in the specified revision'),
_(b'REV'),
),
] ]
+ walkopts + walkopts
+ dryrunopts, + dryrunopts,
_(b'[OPTION]... SOURCE... DEST'), _(b'[OPTION]... SOURCE... DEST'),
helpcategory=command.CATEGORY_FILE_CONTENTS, helpcategory=command.CATEGORY_FILE_CONTENTS,
) )
def copy(ui, repo, *pats, **opts): def copy(ui, repo, *pats, **opts):
"""mark files as copied for the next commit """mark files as copied for the next commit

relnotes/next

== New Features == == New Features ==
* `hg copy` now supports a `--rev` argument to mark files as copied in the
specified commit. It only works with `--after` for now (i.e., it's only
useful for marking files copied using non-hg `cp` as copied).
* `hg uncopy` can be used to unmark a file as copied. Use `hg uncopy -r REV` * `hg uncopy` can be used to unmark a file as copied. Use `hg uncopy -r REV`
to unmark already committed copies. to unmark already committed copies.
== New Experimental Features == == New Experimental Features ==
== Bug Fixes == == Bug Fixes ==

tests/test-completion.t

branch: force, clean, rev branch: force, clean, rev
branches: active, closed, rev, template branches: active, closed, rev, template
bundle: force, rev, branch, base, all, type, ssh, remotecmd, insecure bundle: force, rev, branch, base, all, type, ssh, remotecmd, insecure
cat: output, rev, decode, include, exclude, template cat: output, rev, decode, include, exclude, template
clone: noupdate, updaterev, rev, branch, pull, uncompressed, stream, ssh, remotecmd, insecure clone: noupdate, updaterev, rev, branch, pull, uncompressed, stream, ssh, remotecmd, insecure
commit: addremove, close-branch, amend, secret, edit, force-close-branch, interactive, include, exclude, message, logfile, date, user, subrepos commit: addremove, close-branch, amend, secret, edit, force-close-branch, interactive, include, exclude, message, logfile, date, user, subrepos
config: untrusted, edit, local, global, template config: untrusted, edit, local, global, template
continue: dry-run continue: dry-run
copy: after, force, include, exclude, dry-run copy: after, force, rev, include, exclude, dry-run
debugancestor: debugancestor:
debugapplystreamclonebundle: debugapplystreamclonebundle:
debugbuilddag: mergeable-file, overwritten-file, new-file debugbuilddag: mergeable-file, overwritten-file, new-file
debugbundle: all, part-type, spec debugbundle: all, part-type, spec
debugcapabilities: debugcapabilities:
debugcheckstate: debugcheckstate:
debugcolor: style debugcolor: style
debugcommands: debugcommands:

tests/test-rename-after-merge.t

copies: b2 (b1) copies: b2 (b1)
Test unmarking copies in merge commit Test unmarking copies in merge commit
$ hg uncopy -r . b2 $ hg uncopy -r . b2
abort: cannot unmark copy in merge commit abort: cannot unmark copy in merge commit
[255] [255]
$ hg copy --after -r . b1 b2
abort: cannot mark copy in merge commit
[255]
$ cd .. $ cd ..

tests/test-rename-rev.t

  • This file was copied from tests/test-rename.t.
$ hg init $ hg init
$ mkdir d1 d1/d11 d2 $ mkdir d1 d1/d11 d2
$ echo d1/a > d1/a $ echo d1/a > d1/a
$ echo d1/ba > d1/ba $ echo d1/ba > d1/ba
$ echo d1/a1 > d1/d11/a1 $ echo d1/a1 > d1/d11/a1
$ echo d1/b > d1/b $ echo d1/b > d1/b
$ echo d2/b > d2/b $ echo d2/b > d2/b
$ hg add d1/a d1/b d1/ba d1/d11/a1 d2/b $ hg add d1/a d1/b d1/ba d1/d11/a1 d2/b
$ hg commit -m "1" $ hg commit -m "intial"
rename a single file
$ hg rename d1/d11/a1 d2/c Test single file
$ hg --config ui.portablefilenames=abort rename d1/a d1/con.xml
abort: filename contains 'con', which is reserved on Windows: d1/con.xml
[255]
$ hg sum
parent: 0:9b4b6e7b2c26 tip
1
branch: default
commit: 1 renamed
update: (current)
phases: 1 draft
$ hg status -C
A d2/c
d1/d11/a1
R d1/d11/a1
$ hg update -C
1 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ rm d2/c
rename a single file using absolute paths
$ hg rename `pwd`/d1/d11/a1 `pwd`/d2/c
$ hg status -C
A d2/c
d1/d11/a1
R d1/d11/a1
$ hg update -C
1 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ rm d2/c
rename --after a single file
$ mv d1/d11/a1 d2/c
$ hg rename --after d1/d11/a1 d2/c
$ hg status -C
A d2/c
d1/d11/a1
R d1/d11/a1
$ hg update -C
1 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ rm d2/c
rename --after a single file when src and tgt already tracked
$ mv d1/d11/a1 d2/c
$ hg addrem -s 0
removing d1/d11/a1
adding d2/c
$ hg rename --after d1/d11/a1 d2/c
$ hg status -C
A d2/c
d1/d11/a1
R d1/d11/a1
$ hg update -C
1 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ rm d2/c
rename --after a single file to a nonexistent target filename
$ hg rename --after d1/a dummy
d1/a: not recording move - dummy does not exist
[1]
move a single file to an existing directory
$ hg rename d1/d11/a1 d2
$ hg status -C
A d2/a1
d1/d11/a1
R d1/d11/a1
$ hg update -C
1 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ rm d2/a1
move --after a single file to an existing directory
$ mv d1/d11/a1 d2
$ hg rename --after d1/d11/a1 d2
$ hg status -C
A d2/a1
d1/d11/a1
R d1/d11/a1
$ hg update -C
1 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ rm d2/a1
rename a file using a relative path
$ (cd d1/d11; hg rename ../../d2/b e)
$ hg status -C
A d1/d11/e
d2/b
R d2/b
$ hg update -C
1 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ rm d1/d11/e
rename --after a file using a relative path
$ (cd d1/d11; mv ../../d2/b e; hg rename --after ../../d2/b e)
$ hg status -C
A d1/d11/e
d2/b
R d2/b
$ hg update -C
1 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ rm d1/d11/e
rename directory d1 as d3
$ hg rename d1/ d3
moving d1/a to d3/a
moving d1/b to d3/b
moving d1/ba to d3/ba
moving d1/d11/a1 to d3/d11/a1
$ hg status -C
A d3/a
d1/a
A d3/b
d1/b
A d3/ba
d1/ba
A d3/d11/a1
d1/d11/a1
R d1/a
R d1/b
R d1/ba
R d1/d11/a1
$ hg update -C
4 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ rm -rf d3
rename --after directory d1 as d3
$ mv d1 d3
$ hg rename --after d1 d3
moving d1/a to d3/a
moving d1/b to d3/b
moving d1/ba to d3/ba
moving d1/d11/a1 to d3/d11/a1
$ hg status -C
A d3/a
d1/a
A d3/b
d1/b
A d3/ba
d1/ba
A d3/d11/a1
d1/d11/a1
R d1/a
R d1/b
R d1/ba
R d1/d11/a1
$ hg update -C
4 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ rm -rf d3
move a directory using a relative path
$ (cd d2; mkdir d3; hg rename ../d1/d11 d3)
moving ../d1/d11/a1 to d3/d11/a1
$ hg status -C
A d2/d3/d11/a1
d1/d11/a1
R d1/d11/a1
$ hg update -C
1 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ rm -rf d2/d3
move --after a directory using a relative path
$ (cd d2; mkdir d3; mv ../d1/d11 d3; hg rename --after ../d1/d11 d3)
moving ../d1/d11/a1 to d3/d11/a1
$ hg status -C
A d2/d3/d11/a1
d1/d11/a1
R d1/d11/a1
$ hg update -C
1 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ rm -rf d2/d3
move directory d1/d11 to an existing directory d2 (removes empty d1)
$ hg rename d1/d11/ d2
moving d1/d11/a1 to d2/d11/a1
$ hg status -C
A d2/d11/a1
d1/d11/a1
R d1/d11/a1
$ hg update -C
1 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ rm -rf d2/d11
move directories d1 and d2 to a new directory d3
$ mkdir d3
$ hg rename d1 d2 d3
moving d1/a to d3/d1/a
moving d1/b to d3/d1/b
moving d1/ba to d3/d1/ba
moving d1/d11/a1 to d3/d1/d11/a1
moving d2/b to d3/d2/b
$ hg status -C
A d3/d1/a
d1/a
A d3/d1/b
d1/b
A d3/d1/ba
d1/ba
A d3/d1/d11/a1
d1/d11/a1
A d3/d2/b
d2/b
R d1/a
R d1/b
R d1/ba
R d1/d11/a1
R d2/b
$ hg update -C
5 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ rm -rf d3
move --after directories d1 and d2 to a new directory d3
$ mkdir d3
$ mv d1 d2 d3
$ hg rename --after d1 d2 d3
moving d1/a to d3/d1/a
moving d1/b to d3/d1/b
moving d1/ba to d3/d1/ba
moving d1/d11/a1 to d3/d1/d11/a1
moving d2/b to d3/d2/b
$ hg status -C
A d3/d1/a
d1/a
A d3/d1/b
d1/b
A d3/d1/ba
d1/ba
A d3/d1/d11/a1
d1/d11/a1
A d3/d2/b
d2/b
R d1/a
R d1/b
R d1/ba
R d1/d11/a1
R d2/b
$ hg update -C
5 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ rm -rf d3
move everything under directory d1 to existing directory d2, do not
overwrite existing files (d2/b)
$ hg rename d1/* d2
d2/b: not overwriting - file already committed
('hg rename --force' to replace the file by recording a rename)
moving d1/d11/a1 to d2/d11/a1
[1]
$ hg status -C
A d2/a
d1/a
A d2/ba
d1/ba
A d2/d11/a1
d1/d11/a1
R d1/a
R d1/ba
R d1/d11/a1
$ diff -u d1/b d2/b
--- d1/b * (glob)
+++ d2/b * (glob)
@@ * (glob)
-d1/b
+d2/b
[1]
$ hg update -C
3 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ rm d2/a d2/ba d2/d11/a1
attempt to move one file into a non-existent directory
$ hg rename d1/a dx/
abort: destination dx/ is not a directory
[255]
$ hg status -C
$ hg update -C
0 files updated, 0 files merged, 0 files removed, 0 files unresolved
attempt to move potentially more than one file into a non-existent directory
$ hg rename 'glob:d1/**' dx
abort: with multiple sources, destination must be an existing directory
[255]
move every file under d1 to d2/d21
$ mkdir d2/d21
$ hg rename 'glob:d1/**' d2/d21
moving d1/a to d2/d21/a
moving d1/b to d2/d21/b
moving d1/ba to d2/d21/ba
moving d1/d11/a1 to d2/d21/a1
$ hg status -C
A d2/d21/a
d1/a
A d2/d21/a1
d1/d11/a1
A d2/d21/b
d1/b
A d2/d21/ba
d1/ba
R d1/a
R d1/b
R d1/ba
R d1/d11/a1
$ hg update -C
4 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ rm -rf d2/d21
move --after some files under d1 to d2/d21
$ mkdir d2/d21
$ mv d1/a d1/d11/a1 d2/d21
$ hg rename --after 'glob:d1/**' d2/d21
moving d1/a to d2/d21/a
d1/b: not recording move - d2/d21/b does not exist
d1/ba: not recording move - d2/d21/ba does not exist
moving d1/d11/a1 to d2/d21/a1
[1]
$ hg status -C
A d2/d21/a
d1/a
A d2/d21/a1
d1/d11/a1
R d1/a
R d1/d11/a1
$ hg update -C
2 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ rm -rf d2/d21
move every file under d1 starting with an 'a' to d2/d21 (regexp) # One recoded copy, one copy to record after commit
$ hg cp d1/b d1/c
$ mkdir d2/d21 $ cp d1/b d1/d
$ hg rename 're:d1/([^a][^/]*/)*a.*' d2/d21 $ hg add d1/d
moving d1/a to d2/d21/a $ hg ci -m 'copy d1/b to d1/c and d1/d'
moving d1/d11/a1 to d2/d21/a1 $ hg st -C --change .
$ hg status -C A d1/c
A d2/d21/a
d1/a
A d2/d21/a1
d1/d11/a1
R d1/a
R d1/d11/a1
$ hg update -C
2 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ rm -rf d2/d21
attempt to overwrite an existing file
$ echo "ca" > d1/ca
$ hg rename d1/ba d1/ca
d1/ca: not overwriting - file exists
('hg rename --after' to record the rename)
[1]
$ hg status -C
? d1/ca
$ hg update -C
0 files updated, 0 files merged, 0 files removed, 0 files unresolved
forced overwrite of an existing file
$ echo "ca" > d1/ca
$ hg rename --force d1/ba d1/ca
$ hg status -C
A d1/ca
d1/ba
R d1/ba
$ hg update -C
1 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ rm d1/ca
attempt to overwrite an existing broken symlink
#if symlink
$ ln -s ba d1/ca
$ hg rename --traceback d1/ba d1/ca
d1/ca: not overwriting - file exists
('hg rename --after' to record the rename)
[1]
$ hg status -C
? d1/ca
$ hg update -C
0 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ rm d1/ca
replace a symlink with a file
$ ln -s ba d1/ca
$ hg rename --force d1/ba d1/ca
$ hg status -C
A d1/ca
d1/ba
R d1/ba
$ hg update -C
1 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ rm d1/ca
#endif
do not copy more than one source file to the same destination file
$ mkdir d3
$ hg rename d1/* d2/* d3
moving d1/d11/a1 to d3/d11/a1
d3/b: not overwriting - d2/b collides with d1/b
[1]
$ hg status -C
A d3/a
d1/a
A d3/b
d1/b
A d3/ba
d1/ba
A d3/d11/a1
d1/d11/a1
R d1/a
R d1/b
R d1/ba
R d1/d11/a1
$ hg update -C
4 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ rm -rf d3
move a whole subtree with "hg rename ."
$ mkdir d3
$ (cd d1; hg rename . ../d3)
moving a to ../d3/d1/a
moving b to ../d3/d1/b
moving ba to ../d3/d1/ba
moving d11/a1 to ../d3/d1/d11/a1
$ hg status -C
A d3/d1/a
d1/a
A d3/d1/b
d1/b
A d3/d1/ba
d1/ba
A d3/d1/d11/a1
d1/d11/a1
R d1/a
R d1/b
R d1/ba
R d1/d11/a1
$ hg update -C
4 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ rm -rf d3
move a whole subtree with "hg rename --after ."
$ mkdir d3
$ mv d1/* d3
$ (cd d1; hg rename --after . ../d3)
moving a to ../d3/a
moving b to ../d3/b
moving ba to ../d3/ba
moving d11/a1 to ../d3/d11/a1
$ hg status -C
A d3/a
d1/a
A d3/b
d1/b
A d3/ba
d1/ba
A d3/d11/a1
d1/d11/a1
R d1/a
R d1/b
R d1/ba
R d1/d11/a1
$ hg update -C
4 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ rm -rf d3
move the parent tree with "hg rename .."
$ (cd d1/d11; hg rename .. ../../d3)
moving ../a to ../../d3/a
moving ../b to ../../d3/b
moving ../ba to ../../d3/ba
moving a1 to ../../d3/d11/a1
$ hg status -C
A d3/a
d1/a
A d3/b
d1/b
A d3/ba
d1/ba
A d3/d11/a1
d1/d11/a1
R d1/a
R d1/b
R d1/ba
R d1/d11/a1
$ hg update -C
4 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ rm -rf d3
skip removed files
$ hg remove d1/b
$ hg rename d1 d3
moving d1/a to d3/a
moving d1/ba to d3/ba
moving d1/d11/a1 to d3/d11/a1
$ hg status -C
A d3/a
d1/a
A d3/ba
d1/ba
A d3/d11/a1
d1/d11/a1
R d1/a
R d1/b
R d1/ba
R d1/d11/a1
$ hg update -C
4 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ rm -rf d3
transitive rename
$ hg rename d1/b d1/bb
$ hg rename d1/bb d1/bc
$ hg status -C
A d1/bc
d1/b d1/b
R d1/b A d1/d
$ hg update -C # Errors out without --after for now
1 files updated, 0 files merged, 0 files removed, 0 files unresolved $ hg cp -r . d1/b d1/d
$ rm d1/bc abort: --rev requires --after
[255]
transitive rename --after # Errors out with non-existent destination
$ hg cp -A -r . d1/b d1/non-existent
$ hg rename d1/b d1/bb abort: d1/non-existent: copy destination does not exist in 8a9d70fa20c9
$ mv d1/bb d1/bc [255]
$ hg rename --after d1/bb d1/bc # Successful invocation
$ hg status -C $ hg cp -A -r . d1/b d1/d
A d1/bc saved backup bundle to $TESTTMP/.hg/strip-backup/8a9d70fa20c9-973ae357-copy.hg
# New copy is recorded, and previously recorded copy is also still there
$ hg st -C --change .
A d1/c
d1/b d1/b
R d1/b A d1/d
$ hg update -C
1 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ rm d1/bc
$ echo "# idempotent renames (d1/b -> d1/bb followed by d1/bb -> d1/b)"
# idempotent renames (d1/b -> d1/bb followed by d1/bb -> d1/b)
$ hg rename d1/b d1/bb
$ echo "some stuff added to d1/bb" >> d1/bb
$ hg rename d1/bb d1/b
$ hg status -C
M d1/b
$ hg update -C
1 files updated, 0 files merged, 0 files removed, 0 files unresolved
overwriting with renames (issue1959)
$ hg rename d1/a d1/c
$ hg rename d1/b d1/a
$ hg status -C
M d1/a
d1/b d1/b
A d1/c
d1/a
R d1/b
$ hg diff --git
diff --git a/d1/a b/d1/a
--- a/d1/a
+++ b/d1/a
@@ -1,1 +1,1 @@
-d1/a
+d1/b
diff --git a/d1/b b/d1/b
deleted file mode 100644
--- a/d1/b
+++ /dev/null
@@ -1,1 +0,0 @@
-d1/b
diff --git a/d1/a b/d1/c
copy from d1/a
copy to d1/c
$ hg update -C
2 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ rm d1/c # The file was marked as added, so 'hg update' action was 'forget'
check illegal path components Test using directory as destination
$ hg rename d1/d11/a1 .hg/foo
abort: path contains illegal component: .hg/foo
[255]
$ hg status -C
$ hg rename d1/d11/a1 ../foo
abort: ../foo not under root '$TESTTMP'
[255]
$ hg status -C
$ mv d1/d11/a1 .hg/foo $ hg co 0
$ hg rename --after d1/d11/a1 .hg/foo 0 files updated, 0 files merged, 2 files removed, 0 files unresolved
abort: path contains illegal component: .hg/foo $ cp -R d1 d3
$ hg add d3
adding d3/a
adding d3/b
adding d3/ba
adding d3/d11/a1
$ hg ci -m 'copy d1/ to d3/'
created new head
$ hg cp -A -r . d1 d3
abort: d3: --rev does not support a directory as destination
[255] [255]
$ hg status -C
! d1/d11/a1
$ hg update -C
1 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ rm .hg/foo
$ hg rename d1/d11/a1 .hg
abort: path contains illegal component: .hg/a1
[255]
$ hg --config extensions.largefiles= rename d1/d11/a1 .hg
The fsmonitor extension is incompatible with the largefiles extension and has been disabled. (fsmonitor !)
abort: path contains illegal component: .hg/a1
[255]
$ hg status -C
$ hg rename d1/d11/a1 ..
abort: ../a1 not under root '$TESTTMP'
[255]
$ hg --config extensions.largefiles= rename d1/d11/a1 ..
The fsmonitor extension is incompatible with the largefiles extension and has been disabled. (fsmonitor !)
abort: ../a1 not under root '$TESTTMP'
[255]
$ hg status -C
$ mv d1/d11/a1 .hg
$ hg rename --after d1/d11/a1 .hg
abort: path contains illegal component: .hg/a1
[255]
$ hg status -C
! d1/d11/a1
$ hg update -C
1 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ rm .hg/a1
$ (cd d1/d11; hg rename ../../d2/b ../../.hg/foo)
abort: path contains illegal component: .hg/foo
[255]
$ hg status -C
$ (cd d1/d11; hg rename ../../d2/b ../../../foo)
abort: ../../../foo not under root '$TESTTMP'
[255]
$ hg status -C
check that stat information such as mtime is preserved on rename - it's unclear
whether the `touch` and `stat` commands are portable, so we mimic them using
python. Not all platforms support precision of even one-second granularity, so
we allow a rather generous fudge factor here; 1234567890 is 2009, and the
primary thing we care about is that it's not the machine's current time;
hopefully it's really unlikely for a machine to have such a broken clock that
this test fails. :)
$ mkdir mtime
Create the file (as empty), then update its mtime and atime to be 1234567890.
>>> import os
>>> filename = "mtime/f"
>>> mtime = 1234567890
>>> open(filename, "w").close()
>>> os.utime(filename, (mtime, mtime))
$ hg ci -qAm 'add mtime dir'
"hg cp" does not preserve the mtime, so it should be newer than the 2009
timestamp.
$ hg cp -q mtime mtime_cp
>>> from __future__ import print_function
>>> import os
>>> filename = "mtime_cp/f"
>>> print(os.stat(filename).st_mtime < 1234567999)
False
"hg mv" preserves the mtime, so it should be ~equal to the 2009 timestamp
(modulo some fudge factor due to not every system supporting 1s-level
precision).
$ hg mv -q mtime mtime_mv
>>> from __future__ import print_function
>>> import os
>>> filename = "mtime_mv/f"
>>> print(os.stat(filename).st_mtime < 1234567999)
True

tests/test-rename.t

  • This file was copied to tests/test-rename-rev.t.