( )⚙ D625 copytrace: use the full copytracing method if only drafts are involved

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D625

copytrace: use the full copytracing method if only drafts are involved
ClosedPublic

Authored by pulkit on Sep 4 2017, 6:56 PM.

Details

Reviewers
yuja
durin42
Group Reviewers
hg-reviewers
Commits
rHGfc3b8483c6cb: copytrace: use the full copytracing method if only drafts are involved
Summary

This patch adds the functionality to use the full copytracing even if
experimental.copytrace = heuristics in cases when drafts are involved.

This is also a part of copytrace extension in fbext.

This also adds tests which are also taken from fbext.

.. feature::

The `heuristics` option for `experimental.copytrace` performs full
copytracing if both source and destination branches contains non-public
changsets only.

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.

Event Timeline

pulkit created this revision.Sep 4 2017, 6:56 PM
yuja requested changes to this revision.Sep 6 2017, 10:29 AM
yuja added a subscriber: yuja.

The heuristics option for experimental.copytrace performs full
copytracing if drafts are involved.

This sounds somewhat incorrect. One of the involved revisions should
always be draft on rebase. Can you rephrase?

mercurial/copies.py
371

Please comment "why" instead of "what this is doing."

386

What if some of them are "secret" ?

This revision now requires changes to proceed.Sep 6 2017, 10:29 AM
pulkit edited edge metadata.Sep 9 2017, 6:51 PM
pulkit edited the summary of this revision. (Show Details)
pulkit updated this revision to Diff 1689.
pulkit updated this revision to Diff 1792.Sep 13 2017, 2:54 PM
durin42 accepted this revision.Sep 20 2017, 12:12 PM
Closed by commit rHGfc3b8483c6cb: copytrace: use the full copytracing method if only drafts are involved (authored by pulkit). · Explain WhySep 20 2017, 12:26 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/copies.py (18 lines)
Mtests/test-copytrace-heuristics.t (76 lines)

Diff 1928

mercurial/copies.py

import collections import collections
import heapq import heapq
import os import os
from . import ( from . import (
match as matchmod, match as matchmod,
node, node,
pathutil, pathutil,
phases,
scmutil, scmutil,
util, util,
) )
def _findlimit(repo, a, b): def _findlimit(repo, a, b):
""" """
Find the last revision that needs to be checked to ensure that a full Find the last revision that needs to be checked to ensure that a full
transitive closure for file copies can be properly calculated. transitive closure for file copies can be properly calculated.
copytracing = repo.ui.config('experimental', 'copytrace') copytracing = repo.ui.config('experimental', 'copytrace')
# Copy trace disabling is explicitly below the node == p1 logic above # Copy trace disabling is explicitly below the node == p1 logic above
# because the logic above is required for a simple copy to be kept across a # because the logic above is required for a simple copy to be kept across a
# rebase. # rebase.
if copytracing == 'off': if copytracing == 'off':
return {}, {}, {}, {}, {} return {}, {}, {}, {}, {}
elif copytracing == 'heuristics': elif copytracing == 'heuristics':
# Do full copytracing if only drafts are involved as that will be fast
yujaUnsubmitted
Not Done

Please comment "why" instead of "what this is doing."

yuja: Please comment "why" instead of "what this is doing."
# enough and will also cover the copies which can be missed by
# heuristics
if _isfullcopytraceable(c1, base):
return _fullcopytracing(repo, c1, c2, base)
return _heuristicscopytracing(repo, c1, c2, base) return _heuristicscopytracing(repo, c1, c2, base)
else: else:
return _fullcopytracing(repo, c1, c2, base) return _fullcopytracing(repo, c1, c2, base)
def _isfullcopytraceable(c1, base):
""" Checks that if base, source and destination are all draft branches, if
yes let's use the full copytrace algorithm for increased capabilities since
it will be fast enough.
"""
nonpublicphases = set([phases.draft, phases.secret])
yujaUnsubmitted
Not Done

What if some of them are "secret" ?

yuja: What if some of them are "secret" ?
if (c1.phase() in nonpublicphases) and (base.phase() in nonpublicphases):
return True
return False
def _fullcopytracing(repo, c1, c2, base): def _fullcopytracing(repo, c1, c2, base):
""" The full copytracing algorithm which finds all the new files that were """ The full copytracing algorithm which finds all the new files that were
added from merge base up to the top commit and for each file it checks if added from merge base up to the top commit and for each file it checks if
this file was copied from another file. this file was copied from another file.
This is pretty slow when a lot of changesets are involved but will track all This is pretty slow when a lot of changesets are involved but will track all
the copies. the copies.
""" """

tests/test-copytrace-heuristics.t

merging b and a to b merging b and a to b
$ ls $ ls
b b
$ cat b $ cat b
b b
$ cd .. $ cd ..
$ rm -rf server $ rm -rf server
$ rm -rf repo $ rm -rf repo
Test full copytrace ability on draft branch
-------------------------------------------
File directory and base name changed in same move
$ hg init repo
$ initclient repo
$ mkdir repo/dir1
$ cd repo/dir1
$ echo a > a
$ hg add a
$ hg ci -qm initial
$ cd ..
$ hg mv -q dir1 dir2
$ hg mv dir2/a dir2/b
$ hg ci -qm 'mv a b; mv dir1 dir2'
$ hg up -q '.^'
$ cd dir1
$ echo b >> a
$ cd ..
$ hg ci -qm 'mod a'
$ hg log -G -T 'changeset {node}\n desc {desc}, phase: {phase}\n'
@ changeset 6207d2d318e710b882e3d5ada2a89770efc42c96
| desc mod a, phase: draft
| o changeset abffdd4e3dfc04bc375034b970299b2a309a1cce
|/ desc mv a b; mv dir1 dir2, phase: draft
o changeset 81973cd24b58db2fdf18ce3d64fb2cc3284e9ab3
desc initial, phase: draft
$ hg rebase -s . -d 1
rebasing 2:6207d2d318e7 "mod a" (tip)
merging dir2/b and dir1/a to dir2/b
saved backup bundle to $TESTTMP/repo/repo/.hg/strip-backup/6207d2d318e7-1c9779ad-rebase.hg (glob)
$ cat dir2/b
a
b
$ cd ..
$ rm -rf server
$ rm -rf repo
Move directory in one merge parent, while adding file to original directory
in other merge parent. File moved on rebase.
$ hg init repo
$ initclient repo
$ mkdir repo/dir1
$ cd repo/dir1
$ echo dummy > dummy
$ hg add dummy
$ cd ..
$ hg ci -qm initial
$ cd dir1
$ echo a > a
$ hg add a
$ cd ..
$ hg ci -qm 'hg add dir1/a'
$ hg up -q '.^'
$ hg mv -q dir1 dir2
$ hg ci -qm 'mv dir1 dir2'
$ hg log -G -T 'changeset {node}\n desc {desc}, phase: {phase}\n'
@ changeset e8919e7df8d036e07b906045eddcd4a42ff1915f
| desc mv dir1 dir2, phase: draft
| o changeset 7c7c6f339be00f849c3cb2df738ca91db78b32c8
|/ desc hg add dir1/a, phase: draft
o changeset a235dcce55dcf42034c4e374cb200662d0bb4a13
desc initial, phase: draft
$ hg rebase -s . -d 1
rebasing 2:e8919e7df8d0 "mv dir1 dir2" (tip)
saved backup bundle to $TESTTMP/repo/repo/.hg/strip-backup/e8919e7df8d0-f62fab62-rebase.hg (glob)
$ ls dir2
a
dummy
$ rm -rf server
$ rm -rf repo