author | Martin von Zweigbergk <martinvonz@google.com> |
Tue, 15 Sep 2020 23:19:14 -0700 | |
changeset 45502 | aad11a26a054 |
parent 45014 | cfd06649a1b8 |
child 45627 | fb000408bca5 |
permissions | -rw-r--r-- |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
1 |
# copies.py - copy detection for Mercurial |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
2 |
# |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
3 |
# Copyright 2008 Matt Mackall <mpm@selenic.com> |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
4 |
# |
8225
46293a0c7e9f
updated license to be explicit about GPL version 2
Martin Geisler <mg@lazybytes.net>
parents:
8209
diff
changeset
|
5 |
# This software may be used and distributed according to the terms of the |
10263 | 6 |
# GNU General Public License version 2 or any later version. |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
7 |
|
25924
cfc24c22454e
copies: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25289
diff
changeset
|
8 |
from __future__ import absolute_import |
cfc24c22454e
copies: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25289
diff
changeset
|
9 |
|
34191
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
10 |
import collections |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
11 |
import os |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
12 |
|
34846
f05a6e015ecc
copies: add a config to limit the number of candidates to check in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34787
diff
changeset
|
13 |
from .i18n import _ |
f05a6e015ecc
copies: add a config to limit the number of candidates to check in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34787
diff
changeset
|
14 |
|
43148
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
15 |
|
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
16 |
from .revlogutils.flagutil import REVIDX_SIDEDATA |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
17 |
|
25924
cfc24c22454e
copies: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25289
diff
changeset
|
18 |
from . import ( |
33886
252fb66ee5bb
copies: use intersectmatchers() in non-merge p1 optimization
Yuya Nishihara <yuya@tcha.org>
parents:
33843
diff
changeset
|
19 |
match as matchmod, |
28000
d4247c306d82
copies: optimize forward copy detection logic for rebases
Durham Goode <durham@fb.com>
parents:
27876
diff
changeset
|
20 |
node, |
25924
cfc24c22454e
copies: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25289
diff
changeset
|
21 |
pathutil, |
43106
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43077
diff
changeset
|
22 |
pycompat, |
25924
cfc24c22454e
copies: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25289
diff
changeset
|
23 |
util, |
cfc24c22454e
copies: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25289
diff
changeset
|
24 |
) |
43148
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
25 |
|
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
26 |
|
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
27 |
from .utils import stringutil |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
28 |
|
25924
cfc24c22454e
copies: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25289
diff
changeset
|
29 |
|
42593
11ceb1b8fd74
copies: inline _chainandfilter() to prepare for next patch
Martin von Zweigbergk <martinvonz@google.com>
parents:
42592
diff
changeset
|
30 |
def _filter(src, dst, t): |
11ceb1b8fd74
copies: inline _chainandfilter() to prepare for next patch
Martin von Zweigbergk <martinvonz@google.com>
parents:
42592
diff
changeset
|
31 |
"""filters out invalid copies after chaining""" |
42257
d1c2688eda80
copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42256
diff
changeset
|
32 |
|
42593
11ceb1b8fd74
copies: inline _chainandfilter() to prepare for next patch
Martin von Zweigbergk <martinvonz@google.com>
parents:
42592
diff
changeset
|
33 |
# When _chain()'ing copies in 'a' (from 'src' via some other commit 'mid') |
11ceb1b8fd74
copies: inline _chainandfilter() to prepare for next patch
Martin von Zweigbergk <martinvonz@google.com>
parents:
42592
diff
changeset
|
34 |
# with copies in 'b' (from 'mid' to 'dst'), we can get the different cases |
11ceb1b8fd74
copies: inline _chainandfilter() to prepare for next patch
Martin von Zweigbergk <martinvonz@google.com>
parents:
42592
diff
changeset
|
35 |
# in the following table (not including trivial cases). For example, case 2 |
11ceb1b8fd74
copies: inline _chainandfilter() to prepare for next patch
Martin von Zweigbergk <martinvonz@google.com>
parents:
42592
diff
changeset
|
36 |
# is where a file existed in 'src' and remained under that name in 'mid' and |
42257
d1c2688eda80
copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42256
diff
changeset
|
37 |
# then was renamed between 'mid' and 'dst'. |
d1c2688eda80
copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42256
diff
changeset
|
38 |
# |
d1c2688eda80
copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42256
diff
changeset
|
39 |
# case src mid dst result |
d1c2688eda80
copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42256
diff
changeset
|
40 |
# 1 x y - - |
d1c2688eda80
copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42256
diff
changeset
|
41 |
# 2 x y y x->y |
d1c2688eda80
copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42256
diff
changeset
|
42 |
# 3 x y x - |
d1c2688eda80
copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42256
diff
changeset
|
43 |
# 4 x y z x->z |
d1c2688eda80
copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42256
diff
changeset
|
44 |
# 5 - x y - |
d1c2688eda80
copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42256
diff
changeset
|
45 |
# 6 x x y x->y |
42395
f3d06d37e194
copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents:
42366
diff
changeset
|
46 |
# |
f3d06d37e194
copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents:
42366
diff
changeset
|
47 |
# _chain() takes care of chaining the copies in 'a' and 'b', but it |
f3d06d37e194
copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents:
42366
diff
changeset
|
48 |
# cannot tell the difference between cases 1 and 2, between 3 and 4, or |
f3d06d37e194
copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents:
42366
diff
changeset
|
49 |
# between 5 and 6, so it includes all cases in its result. |
f3d06d37e194
copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents:
42366
diff
changeset
|
50 |
# Cases 1, 3, and 5 are then removed by _filter(). |
42257
d1c2688eda80
copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42256
diff
changeset
|
51 |
|
42395
f3d06d37e194
copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents:
42366
diff
changeset
|
52 |
for k, v in list(t.items()): |
f3d06d37e194
copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents:
42366
diff
changeset
|
53 |
# remove copies from files that didn't exist |
f3d06d37e194
copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents:
42366
diff
changeset
|
54 |
if v not in src: |
f3d06d37e194
copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents:
42366
diff
changeset
|
55 |
del t[k] |
f3d06d37e194
copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents:
42366
diff
changeset
|
56 |
# remove criss-crossed copies |
f3d06d37e194
copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents:
42366
diff
changeset
|
57 |
elif k in src and v in dst: |
f3d06d37e194
copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents:
42366
diff
changeset
|
58 |
del t[k] |
f3d06d37e194
copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents:
42366
diff
changeset
|
59 |
# remove copies to files that were then removed |
f3d06d37e194
copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents:
42366
diff
changeset
|
60 |
elif k not in dst: |
f3d06d37e194
copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents:
42366
diff
changeset
|
61 |
del t[k] |
f3d06d37e194
copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents:
42366
diff
changeset
|
62 |
|
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
63 |
|
43804
995066c41bb2
copies: expand `_chain` variable name to make the function easier to read
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43803
diff
changeset
|
64 |
def _chain(prefix, suffix): |
995066c41bb2
copies: expand `_chain` variable name to make the function easier to read
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43803
diff
changeset
|
65 |
"""chain two sets of copies 'prefix' and 'suffix'""" |
995066c41bb2
copies: expand `_chain` variable name to make the function easier to read
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43803
diff
changeset
|
66 |
result = prefix.copy() |
995066c41bb2
copies: expand `_chain` variable name to make the function easier to read
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43803
diff
changeset
|
67 |
for key, value in pycompat.iteritems(suffix): |
995066c41bb2
copies: expand `_chain` variable name to make the function easier to read
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43803
diff
changeset
|
68 |
result[key] = prefix.get(value, value) |
995066c41bb2
copies: expand `_chain` variable name to make the function easier to read
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43803
diff
changeset
|
69 |
return result |
15775
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
70 |
|
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
71 |
|
43199
069cbbb53cdf
copies: drop the findlimit logic
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43198
diff
changeset
|
72 |
def _tracefile(fctx, am, basemf): |
35428
9cf37d111acb
copies: consistently use """ for docstrings
Martin von Zweigbergk <martinvonz@google.com>
parents:
35427
diff
changeset
|
73 |
"""return file context that is the ancestor of fctx present in ancestor |
43198
c16fe77e340a
pathcopies: give up any optimization based on `introrev`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43148
diff
changeset
|
74 |
manifest am |
c16fe77e340a
pathcopies: give up any optimization based on `introrev`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43148
diff
changeset
|
75 |
|
c16fe77e340a
pathcopies: give up any optimization based on `introrev`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43148
diff
changeset
|
76 |
Note: we used to try and stop after a given limit, however checking if that |
c16fe77e340a
pathcopies: give up any optimization based on `introrev`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43148
diff
changeset
|
77 |
limit is reached turned out to be very expensive. we are better off |
c16fe77e340a
pathcopies: give up any optimization based on `introrev`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43148
diff
changeset
|
78 |
disabling that feature.""" |
15775
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
79 |
|
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
80 |
for f in fctx.ancestors(): |
42554
4ebbd7c4a3c5
copies: return only path from _tracefile() since that's all caller needs
Martin von Zweigbergk <martinvonz@google.com>
parents:
42527
diff
changeset
|
81 |
path = f.path() |
4ebbd7c4a3c5
copies: return only path from _tracefile() since that's all caller needs
Martin von Zweigbergk <martinvonz@google.com>
parents:
42527
diff
changeset
|
82 |
if am.get(path, None) == f.filenode(): |
4ebbd7c4a3c5
copies: return only path from _tracefile() since that's all caller needs
Martin von Zweigbergk <martinvonz@google.com>
parents:
42527
diff
changeset
|
83 |
return path |
42595
819712deac69
copies: follow copies across merge base without source file (issue6163)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42594
diff
changeset
|
84 |
if basemf and basemf.get(path, None) == f.filenode(): |
819712deac69
copies: follow copies across merge base without source file (issue6163)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42594
diff
changeset
|
85 |
return path |
15775
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
86 |
|
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
87 |
|
41761
012f695546aa
copies: respect narrowmatcher in "parent -> working dir" case
Martin von Zweigbergk <martinvonz@google.com>
parents:
41735
diff
changeset
|
88 |
def _dirstatecopies(repo, match=None): |
012f695546aa
copies: respect narrowmatcher in "parent -> working dir" case
Martin von Zweigbergk <martinvonz@google.com>
parents:
41735
diff
changeset
|
89 |
ds = repo.dirstate |
15775
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
90 |
c = ds.copies().copy() |
34355
1a5abc45e2fa
py3: explicitly convert dict.keys() and dict.items() into a list
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34318
diff
changeset
|
91 |
for k in list(c): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
92 |
if ds[k] not in b'anm' or (match and not match(k)): |
15775
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
93 |
del c[k] |
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
94 |
return c |
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
95 |
|
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
96 |
|
24782
4906dc0e038c
copies: add matcher parameter to copy logic
Durham Goode <durham@fb.com>
parents:
24625
diff
changeset
|
97 |
def _computeforwardmissing(a, b, match=None): |
24011
d7d08337b3f6
copy: move _forwardcopies file logic to a function
Durham Goode <durham@fb.com>
parents:
24010
diff
changeset
|
98 |
"""Computes which files are in b but not a. |
d7d08337b3f6
copy: move _forwardcopies file logic to a function
Durham Goode <durham@fb.com>
parents:
24010
diff
changeset
|
99 |
This is its own function so extensions can easily wrap this call to see what |
d7d08337b3f6
copy: move _forwardcopies file logic to a function
Durham Goode <durham@fb.com>
parents:
24010
diff
changeset
|
100 |
files _forwardcopies is about to process. |
d7d08337b3f6
copy: move _forwardcopies file logic to a function
Durham Goode <durham@fb.com>
parents:
24010
diff
changeset
|
101 |
""" |
24782
4906dc0e038c
copies: add matcher parameter to copy logic
Durham Goode <durham@fb.com>
parents:
24625
diff
changeset
|
102 |
ma = a.manifest() |
4906dc0e038c
copies: add matcher parameter to copy logic
Durham Goode <durham@fb.com>
parents:
24625
diff
changeset
|
103 |
mb = b.manifest() |
31266
5a909a8098a1
copies: remove use of manifest.matches
Durham Goode <durham@fb.com>
parents:
30586
diff
changeset
|
104 |
return mb.filesnotin(ma, match=match) |
24011
d7d08337b3f6
copy: move _forwardcopies file logic to a function
Durham Goode <durham@fb.com>
parents:
24010
diff
changeset
|
105 |
|
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
106 |
|
42115
27475ae67676
copies: extract function for deciding whether to use changeset-centric algos
Martin von Zweigbergk <martinvonz@google.com>
parents:
41941
diff
changeset
|
107 |
def usechangesetcentricalgo(repo): |
27475ae67676
copies: extract function for deciding whether to use changeset-centric algos
Martin von Zweigbergk <martinvonz@google.com>
parents:
41941
diff
changeset
|
108 |
"""Checks if we should use changeset-centric copy algorithms""" |
43146
0171483b082f
sidedatacopies: read rename information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43117
diff
changeset
|
109 |
if repo.filecopiesmode == b'changeset-sidedata': |
0171483b082f
sidedatacopies: read rename information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43117
diff
changeset
|
110 |
return True |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
111 |
readfrom = repo.ui.config(b'experimental', b'copies.read-from') |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
112 |
changesetsource = (b'changeset-only', b'compatibility') |
43022
f3bcae1e9e23
copies: expand the logic of usechangesetcentricalgo
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42729
diff
changeset
|
113 |
return readfrom in changesetsource |
42115
27475ae67676
copies: extract function for deciding whether to use changeset-centric algos
Martin von Zweigbergk <martinvonz@google.com>
parents:
41941
diff
changeset
|
114 |
|
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
115 |
|
42595
819712deac69
copies: follow copies across merge base without source file (issue6163)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42594
diff
changeset
|
116 |
def _committedforwardcopies(a, b, base, match): |
35429
8801cdcea01f
copies: extract method for getting non-wdir forward copies
Martin von Zweigbergk <martinvonz@google.com>
parents:
35428
diff
changeset
|
117 |
"""Like _forwardcopies(), but b.rev() cannot be None (working copy)""" |
20294
243ea5ffdf31
diff: search beyond ancestor when detecting renames
Mads Kiilerich <madski@unity3d.com>
parents:
19178
diff
changeset
|
118 |
# files might have to be traced back to the fctx parent of the last |
243ea5ffdf31
diff: search beyond ancestor when detecting renames
Mads Kiilerich <madski@unity3d.com>
parents:
19178
diff
changeset
|
119 |
# one-side-only changeset, but not further back than that |
40058
25b2868206e2
copies: add a devel debug mode to trace what copy tracing does
Boris Feld <boris.feld@octobus.net>
parents:
39967
diff
changeset
|
120 |
repo = a._repo |
41765
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41763
diff
changeset
|
121 |
|
42115
27475ae67676
copies: extract function for deciding whether to use changeset-centric algos
Martin von Zweigbergk <martinvonz@google.com>
parents:
41941
diff
changeset
|
122 |
if usechangesetcentricalgo(repo): |
41765
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41763
diff
changeset
|
123 |
return _changesetforwardcopies(a, b, match) |
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41763
diff
changeset
|
124 |
|
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
125 |
debug = repo.ui.debugflag and repo.ui.configbool(b'devel', b'debug.copies') |
40058
25b2868206e2
copies: add a devel debug mode to trace what copy tracing does
Boris Feld <boris.feld@octobus.net>
parents:
39967
diff
changeset
|
126 |
dbg = repo.ui.debug |
25b2868206e2
copies: add a devel debug mode to trace what copy tracing does
Boris Feld <boris.feld@octobus.net>
parents:
39967
diff
changeset
|
127 |
if debug: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
128 |
dbg(b'debug.copies: looking into rename from %s to %s\n' % (a, b)) |
20294
243ea5ffdf31
diff: search beyond ancestor when detecting renames
Mads Kiilerich <madski@unity3d.com>
parents:
19178
diff
changeset
|
129 |
am = a.manifest() |
42595
819712deac69
copies: follow copies across merge base without source file (issue6163)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42594
diff
changeset
|
130 |
basemf = None if base is None else base.manifest() |
20294
243ea5ffdf31
diff: search beyond ancestor when detecting renames
Mads Kiilerich <madski@unity3d.com>
parents:
19178
diff
changeset
|
131 |
|
15775
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
132 |
# find where new files came from |
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
133 |
# we currently don't try to find where old files went, too expensive |
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
134 |
# this means we can miss a case like 'hg rm b; hg cp a b' |
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
135 |
cm = {} |
28000
d4247c306d82
copies: optimize forward copy detection logic for rebases
Durham Goode <durham@fb.com>
parents:
27876
diff
changeset
|
136 |
|
d4247c306d82
copies: optimize forward copy detection logic for rebases
Durham Goode <durham@fb.com>
parents:
27876
diff
changeset
|
137 |
# Computing the forward missing is quite expensive on large manifests, since |
d4247c306d82
copies: optimize forward copy detection logic for rebases
Durham Goode <durham@fb.com>
parents:
27876
diff
changeset
|
138 |
# it compares the entire manifests. We can optimize it in the common use |
d4247c306d82
copies: optimize forward copy detection logic for rebases
Durham Goode <durham@fb.com>
parents:
27876
diff
changeset
|
139 |
# case of computing what copies are in a commit versus its parent (like |
d4247c306d82
copies: optimize forward copy detection logic for rebases
Durham Goode <durham@fb.com>
parents:
27876
diff
changeset
|
140 |
# during a rebase or histedit). Note, we exclude merge commits from this |
d4247c306d82
copies: optimize forward copy detection logic for rebases
Durham Goode <durham@fb.com>
parents:
27876
diff
changeset
|
141 |
# optimization, since the ctx.files() for a merge commit is not correct for |
d4247c306d82
copies: optimize forward copy detection logic for rebases
Durham Goode <durham@fb.com>
parents:
27876
diff
changeset
|
142 |
# this comparison. |
d4247c306d82
copies: optimize forward copy detection logic for rebases
Durham Goode <durham@fb.com>
parents:
27876
diff
changeset
|
143 |
forwardmissingmatch = match |
33886
252fb66ee5bb
copies: use intersectmatchers() in non-merge p1 optimization
Yuya Nishihara <yuya@tcha.org>
parents:
33843
diff
changeset
|
144 |
if b.p1() == a and b.p2().node() == node.nullid: |
41941
a791623458ef
copies: remove dependency on scmutil by directly using match.exact()
Martin von Zweigbergk <martinvonz@google.com>
parents:
41937
diff
changeset
|
145 |
filesmatcher = matchmod.exact(b.files()) |
33886
252fb66ee5bb
copies: use intersectmatchers() in non-merge p1 optimization
Yuya Nishihara <yuya@tcha.org>
parents:
33843
diff
changeset
|
146 |
forwardmissingmatch = matchmod.intersectmatchers(match, filesmatcher) |
28000
d4247c306d82
copies: optimize forward copy detection logic for rebases
Durham Goode <durham@fb.com>
parents:
27876
diff
changeset
|
147 |
missing = _computeforwardmissing(a, b, match=forwardmissingmatch) |
d4247c306d82
copies: optimize forward copy detection logic for rebases
Durham Goode <durham@fb.com>
parents:
27876
diff
changeset
|
148 |
|
23980
c1ce5442453f
_adjustlinkrev: reuse ancestors set during rename detection (issue4514)
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23139
diff
changeset
|
149 |
ancestrycontext = a._repo.changelog.ancestors([b.rev()], inclusive=True) |
40058
25b2868206e2
copies: add a devel debug mode to trace what copy tracing does
Boris Feld <boris.feld@octobus.net>
parents:
39967
diff
changeset
|
150 |
|
25b2868206e2
copies: add a devel debug mode to trace what copy tracing does
Boris Feld <boris.feld@octobus.net>
parents:
39967
diff
changeset
|
151 |
if debug: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
152 |
dbg(b'debug.copies: missing files to search: %d\n' % len(missing)) |
40058
25b2868206e2
copies: add a devel debug mode to trace what copy tracing does
Boris Feld <boris.feld@octobus.net>
parents:
39967
diff
changeset
|
153 |
|
42243
390ec72b8ea4
copies: process files in deterministic order for stable tests
Martin von Zweigbergk <martinvonz@google.com>
parents:
42211
diff
changeset
|
154 |
for f in sorted(missing): |
40058
25b2868206e2
copies: add a devel debug mode to trace what copy tracing does
Boris Feld <boris.feld@octobus.net>
parents:
39967
diff
changeset
|
155 |
if debug: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
156 |
dbg(b'debug.copies: tracing file: %s\n' % f) |
23980
c1ce5442453f
_adjustlinkrev: reuse ancestors set during rename detection (issue4514)
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23139
diff
changeset
|
157 |
fctx = b[f] |
c1ce5442453f
_adjustlinkrev: reuse ancestors set during rename detection (issue4514)
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23139
diff
changeset
|
158 |
fctx._ancestrycontext = ancestrycontext |
40058
25b2868206e2
copies: add a devel debug mode to trace what copy tracing does
Boris Feld <boris.feld@octobus.net>
parents:
39967
diff
changeset
|
159 |
|
40059
cf01616f8d96
copies: add time information to the debug information
Boris Feld <boris.feld@octobus.net>
parents:
40058
diff
changeset
|
160 |
if debug: |
cf01616f8d96
copies: add time information to the debug information
Boris Feld <boris.feld@octobus.net>
parents:
40058
diff
changeset
|
161 |
start = util.timer() |
43199
069cbbb53cdf
copies: drop the findlimit logic
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43198
diff
changeset
|
162 |
opath = _tracefile(fctx, am, basemf) |
42554
4ebbd7c4a3c5
copies: return only path from _tracefile() since that's all caller needs
Martin von Zweigbergk <martinvonz@google.com>
parents:
42527
diff
changeset
|
163 |
if opath: |
40058
25b2868206e2
copies: add a devel debug mode to trace what copy tracing does
Boris Feld <boris.feld@octobus.net>
parents:
39967
diff
changeset
|
164 |
if debug: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
165 |
dbg(b'debug.copies: rename of: %s\n' % opath) |
42554
4ebbd7c4a3c5
copies: return only path from _tracefile() since that's all caller needs
Martin von Zweigbergk <martinvonz@google.com>
parents:
42527
diff
changeset
|
166 |
cm[f] = opath |
40059
cf01616f8d96
copies: add time information to the debug information
Boris Feld <boris.feld@octobus.net>
parents:
40058
diff
changeset
|
167 |
if debug: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
168 |
dbg( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
169 |
b'debug.copies: time: %f seconds\n' |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
170 |
% (util.timer() - start) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
171 |
) |
35429
8801cdcea01f
copies: extract method for getting non-wdir forward copies
Martin von Zweigbergk <martinvonz@google.com>
parents:
35428
diff
changeset
|
172 |
return cm |
8801cdcea01f
copies: extract method for getting non-wdir forward copies
Martin von Zweigbergk <martinvonz@google.com>
parents:
35428
diff
changeset
|
173 |
|
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
174 |
|
43255
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
175 |
def _revinfogetter(repo): |
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
176 |
"""return a function that return multiple data given a <rev>"i |
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
177 |
|
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
178 |
* p1: revision number of first parent |
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
179 |
* p2: revision number of first parent |
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
180 |
* p1copies: mapping of copies from p1 |
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
181 |
* p2copies: mapping of copies from p2 |
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
182 |
* removed: a list of removed files |
44858
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
183 |
* ismerged: a callback to know if file was merged in that revision |
43255
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
184 |
""" |
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
185 |
cl = repo.changelog |
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
186 |
parents = cl.parentrevs |
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
187 |
|
44858
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
188 |
def get_ismerged(rev): |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
189 |
ctx = repo[rev] |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
190 |
|
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
191 |
def ismerged(path): |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
192 |
if path not in ctx.files(): |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
193 |
return False |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
194 |
fctx = ctx[path] |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
195 |
parents = fctx._filelog.parents(fctx._filenode) |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
196 |
nb_parents = 0 |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
197 |
for n in parents: |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
198 |
if n != node.nullid: |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
199 |
nb_parents += 1 |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
200 |
return nb_parents >= 2 |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
201 |
|
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
202 |
return ismerged |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
203 |
|
43257
675c776fbcd1
sidedatacopies: directly fetch copies information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43256
diff
changeset
|
204 |
if repo.filecopiesmode == b'changeset-sidedata': |
675c776fbcd1
sidedatacopies: directly fetch copies information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43256
diff
changeset
|
205 |
changelogrevision = cl.changelogrevision |
43297
8a2925265402
sidedatacopies: fast path data fetching if revision has no sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43257
diff
changeset
|
206 |
flags = cl.flags |
43257
675c776fbcd1
sidedatacopies: directly fetch copies information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43256
diff
changeset
|
207 |
|
43301
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
208 |
# A small cache to avoid doing the work twice for merges |
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
209 |
# |
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
210 |
# In the vast majority of cases, if we ask information for a revision |
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
211 |
# about 1 parent, we'll later ask it for the other. So it make sense to |
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
212 |
# keep the information around when reaching the first parent of a merge |
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
213 |
# and dropping it after it was provided for the second parents. |
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
214 |
# |
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
215 |
# It exists cases were only one parent of the merge will be walked. It |
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
216 |
# happens when the "destination" the copy tracing is descendant from a |
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
217 |
# new root, not common with the "source". In that case, we will only walk |
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
218 |
# through merge parents that are descendant of changesets common |
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
219 |
# between "source" and "destination". |
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
220 |
# |
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
221 |
# With the current case implementation if such changesets have a copy |
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
222 |
# information, we'll keep them in memory until the end of |
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
223 |
# _changesetforwardcopies. We don't expect the case to be frequent |
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
224 |
# enough to matters. |
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
225 |
# |
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
226 |
# In addition, it would be possible to reach pathological case, were |
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
227 |
# many first parent are met before any second parent is reached. In |
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
228 |
# that case the cache could grow. If this even become an issue one can |
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
229 |
# safely introduce a maximum cache size. This would trade extra CPU/IO |
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
230 |
# time to save memory. |
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
231 |
merge_caches = {} |
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
232 |
|
43257
675c776fbcd1
sidedatacopies: directly fetch copies information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43256
diff
changeset
|
233 |
def revinfo(rev): |
675c776fbcd1
sidedatacopies: directly fetch copies information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43256
diff
changeset
|
234 |
p1, p2 = parents(rev) |
44858
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
235 |
value = None |
43297
8a2925265402
sidedatacopies: fast path data fetching if revision has no sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43257
diff
changeset
|
236 |
if flags(rev) & REVIDX_SIDEDATA: |
43301
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
237 |
e = merge_caches.pop(rev, None) |
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
238 |
if e is not None: |
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
239 |
return e |
43297
8a2925265402
sidedatacopies: fast path data fetching if revision has no sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43257
diff
changeset
|
240 |
c = changelogrevision(rev) |
8a2925265402
sidedatacopies: fast path data fetching if revision has no sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43257
diff
changeset
|
241 |
p1copies = c.p1copies |
8a2925265402
sidedatacopies: fast path data fetching if revision has no sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43257
diff
changeset
|
242 |
p2copies = c.p2copies |
8a2925265402
sidedatacopies: fast path data fetching if revision has no sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43257
diff
changeset
|
243 |
removed = c.filesremoved |
43301
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
244 |
if p1 != node.nullrev and p2 != node.nullrev: |
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
245 |
# XXX some case we over cache, IGNORE |
44858
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
246 |
value = merge_caches[rev] = ( |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
247 |
p1, |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
248 |
p2, |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
249 |
p1copies, |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
250 |
p2copies, |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
251 |
removed, |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
252 |
get_ismerged(rev), |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
253 |
) |
43297
8a2925265402
sidedatacopies: fast path data fetching if revision has no sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43257
diff
changeset
|
254 |
else: |
8a2925265402
sidedatacopies: fast path data fetching if revision has no sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43257
diff
changeset
|
255 |
p1copies = {} |
8a2925265402
sidedatacopies: fast path data fetching if revision has no sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43257
diff
changeset
|
256 |
p2copies = {} |
43802
79750d781928
copies: return consistent type from revinfo
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43302
diff
changeset
|
257 |
removed = [] |
44858
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
258 |
|
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
259 |
if value is None: |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
260 |
value = (p1, p2, p1copies, p2copies, removed, get_ismerged(rev)) |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
261 |
return value |
43257
675c776fbcd1
sidedatacopies: directly fetch copies information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43256
diff
changeset
|
262 |
|
675c776fbcd1
sidedatacopies: directly fetch copies information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43256
diff
changeset
|
263 |
else: |
675c776fbcd1
sidedatacopies: directly fetch copies information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43256
diff
changeset
|
264 |
|
675c776fbcd1
sidedatacopies: directly fetch copies information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43256
diff
changeset
|
265 |
def revinfo(rev): |
675c776fbcd1
sidedatacopies: directly fetch copies information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43256
diff
changeset
|
266 |
p1, p2 = parents(rev) |
675c776fbcd1
sidedatacopies: directly fetch copies information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43256
diff
changeset
|
267 |
ctx = repo[rev] |
675c776fbcd1
sidedatacopies: directly fetch copies information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43256
diff
changeset
|
268 |
p1copies, p2copies = ctx._copies |
675c776fbcd1
sidedatacopies: directly fetch copies information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43256
diff
changeset
|
269 |
removed = ctx.filesremoved() |
44858
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
270 |
return p1, p2, p1copies, p2copies, removed, get_ismerged(rev) |
43255
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
271 |
|
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
272 |
return revinfo |
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
273 |
|
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
274 |
|
41765
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41763
diff
changeset
|
275 |
def _changesetforwardcopies(a, b, match): |
42645
8c5a36805d5d
copies: fix crash on in changeset-centric tracing from commit to itself
Martin von Zweigbergk <martinvonz@google.com>
parents:
42595
diff
changeset
|
276 |
if a.rev() in (node.nullrev, b.rev()): |
41765
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41763
diff
changeset
|
277 |
return {} |
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41763
diff
changeset
|
278 |
|
43256
00de32aa834e
copies: use an unfiltered repository for the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43255
diff
changeset
|
279 |
repo = a.repo().unfiltered() |
41765
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41763
diff
changeset
|
280 |
children = {} |
43255
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
281 |
revinfo = _revinfogetter(repo) |
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
282 |
|
41765
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41763
diff
changeset
|
283 |
cl = repo.changelog |
44858
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
284 |
isancestor = cl.isancestorrev # XXX we should had chaching to this. |
41765
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41763
diff
changeset
|
285 |
missingrevs = cl.findmissingrevs(common=[a.rev()], heads=[b.rev()]) |
43299
83bb1e89ab9b
copies: compute the exact set of revision to walk
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43297
diff
changeset
|
286 |
mrset = set(missingrevs) |
83bb1e89ab9b
copies: compute the exact set of revision to walk
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43297
diff
changeset
|
287 |
roots = set() |
41765
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41763
diff
changeset
|
288 |
for r in missingrevs: |
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41763
diff
changeset
|
289 |
for p in cl.parentrevs(r): |
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41763
diff
changeset
|
290 |
if p == node.nullrev: |
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41763
diff
changeset
|
291 |
continue |
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41763
diff
changeset
|
292 |
if p not in children: |
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41763
diff
changeset
|
293 |
children[p] = [r] |
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41763
diff
changeset
|
294 |
else: |
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41763
diff
changeset
|
295 |
children[p].append(r) |
43299
83bb1e89ab9b
copies: compute the exact set of revision to walk
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43297
diff
changeset
|
296 |
if p not in mrset: |
83bb1e89ab9b
copies: compute the exact set of revision to walk
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43297
diff
changeset
|
297 |
roots.add(p) |
83bb1e89ab9b
copies: compute the exact set of revision to walk
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43297
diff
changeset
|
298 |
if not roots: |
83bb1e89ab9b
copies: compute the exact set of revision to walk
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43297
diff
changeset
|
299 |
# no common revision to track copies from |
83bb1e89ab9b
copies: compute the exact set of revision to walk
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43297
diff
changeset
|
300 |
return {} |
83bb1e89ab9b
copies: compute the exact set of revision to walk
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43297
diff
changeset
|
301 |
min_root = min(roots) |
41765
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41763
diff
changeset
|
302 |
|
43299
83bb1e89ab9b
copies: compute the exact set of revision to walk
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43297
diff
changeset
|
303 |
from_head = set( |
83bb1e89ab9b
copies: compute the exact set of revision to walk
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43297
diff
changeset
|
304 |
cl.reachableroots(min_root, [b.rev()], list(roots), includepath=True) |
83bb1e89ab9b
copies: compute the exact set of revision to walk
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43297
diff
changeset
|
305 |
) |
83bb1e89ab9b
copies: compute the exact set of revision to walk
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43297
diff
changeset
|
306 |
|
83bb1e89ab9b
copies: compute the exact set of revision to walk
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43297
diff
changeset
|
307 |
iterrevs = set(from_head) |
83bb1e89ab9b
copies: compute the exact set of revision to walk
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43297
diff
changeset
|
308 |
iterrevs &= mrset |
83bb1e89ab9b
copies: compute the exact set of revision to walk
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43297
diff
changeset
|
309 |
iterrevs.update(roots) |
83bb1e89ab9b
copies: compute the exact set of revision to walk
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43297
diff
changeset
|
310 |
iterrevs.remove(b.rev()) |
43806
421ea5772039
copies: split the combination of the copies mapping in its own function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43805
diff
changeset
|
311 |
revs = sorted(iterrevs) |
44858
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
312 |
return _combinechangesetcopies( |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
313 |
revs, children, b.rev(), revinfo, match, isancestor |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
314 |
) |
43806
421ea5772039
copies: split the combination of the copies mapping in its own function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43805
diff
changeset
|
315 |
|
421ea5772039
copies: split the combination of the copies mapping in its own function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43805
diff
changeset
|
316 |
|
44858
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
317 |
def _combinechangesetcopies( |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
318 |
revs, children, targetrev, revinfo, match, isancestor |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
319 |
): |
43806
421ea5772039
copies: split the combination of the copies mapping in its own function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43805
diff
changeset
|
320 |
"""combine the copies information for each item of iterrevs |
421ea5772039
copies: split the combination of the copies mapping in its own function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43805
diff
changeset
|
321 |
|
421ea5772039
copies: split the combination of the copies mapping in its own function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43805
diff
changeset
|
322 |
revs: sorted iterable of revision to visit |
421ea5772039
copies: split the combination of the copies mapping in its own function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43805
diff
changeset
|
323 |
children: a {parent: [children]} mapping. |
421ea5772039
copies: split the combination of the copies mapping in its own function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43805
diff
changeset
|
324 |
targetrev: the final copies destination revision (not in iterrevs) |
421ea5772039
copies: split the combination of the copies mapping in its own function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43805
diff
changeset
|
325 |
revinfo(rev): a function that return (p1, p2, p1copies, p2copies, removed) |
421ea5772039
copies: split the combination of the copies mapping in its own function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43805
diff
changeset
|
326 |
match: a matcher |
421ea5772039
copies: split the combination of the copies mapping in its own function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43805
diff
changeset
|
327 |
|
421ea5772039
copies: split the combination of the copies mapping in its own function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43805
diff
changeset
|
328 |
It returns the aggregated copies information for `targetrev`. |
421ea5772039
copies: split the combination of the copies mapping in its own function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43805
diff
changeset
|
329 |
""" |
43805
3b039e43a1e6
copies: do not initialize the dictionary with root in changeset copies
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43804
diff
changeset
|
330 |
all_copies = {} |
42503
c0b51449bf6b
copies: avoid calling matcher if matcher.always()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42502
diff
changeset
|
331 |
alwaysmatch = match.always() |
43806
421ea5772039
copies: split the combination of the copies mapping in its own function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43805
diff
changeset
|
332 |
for r in revs: |
43805
3b039e43a1e6
copies: do not initialize the dictionary with root in changeset copies
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43804
diff
changeset
|
333 |
copies = all_copies.pop(r, None) |
3b039e43a1e6
copies: do not initialize the dictionary with root in changeset copies
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43804
diff
changeset
|
334 |
if copies is None: |
3b039e43a1e6
copies: do not initialize the dictionary with root in changeset copies
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43804
diff
changeset
|
335 |
# this is a root |
3b039e43a1e6
copies: do not initialize the dictionary with root in changeset copies
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43804
diff
changeset
|
336 |
copies = {} |
42502
5ceb91136ebe
copies: avoid unnecessary copying of copy dict
Martin von Zweigbergk <martinvonz@google.com>
parents:
42501
diff
changeset
|
337 |
for i, c in enumerate(children[r]): |
44858
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
338 |
p1, p2, p1copies, p2copies, removed, ismerged = revinfo(c) |
43254
181d28ba05da
copies: avoid instancing more changectx to access parent revisions
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43253
diff
changeset
|
339 |
if r == p1: |
41765
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41763
diff
changeset
|
340 |
parent = 1 |
43253
82dabad535d2
copies: get copies information directly from _copies
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43252
diff
changeset
|
341 |
childcopies = p1copies |
41765
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41763
diff
changeset
|
342 |
else: |
43254
181d28ba05da
copies: avoid instancing more changectx to access parent revisions
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43253
diff
changeset
|
343 |
assert r == p2 |
41765
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41763
diff
changeset
|
344 |
parent = 2 |
43253
82dabad535d2
copies: get copies information directly from _copies
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43252
diff
changeset
|
345 |
childcopies = p2copies |
42503
c0b51449bf6b
copies: avoid calling matcher if matcher.always()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42502
diff
changeset
|
346 |
if not alwaysmatch: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
347 |
childcopies = { |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
348 |
dst: src for dst, src in childcopies.items() if match(dst) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
349 |
} |
43300
ffd04bc9f57d
copies: move from a copy on branchpoint to a copy on write approach
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43299
diff
changeset
|
350 |
newcopies = copies |
42522
e7c55e24d6bf
copies: avoid reusing the same variable for two different copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents:
42503
diff
changeset
|
351 |
if childcopies: |
44858
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
352 |
newcopies = copies.copy() |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
353 |
for dest, source in pycompat.iteritems(childcopies): |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
354 |
prev = copies.get(source) |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
355 |
if prev is not None and prev[1] is not None: |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
356 |
source = prev[1] |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
357 |
newcopies[dest] = (c, source) |
43300
ffd04bc9f57d
copies: move from a copy on branchpoint to a copy on write approach
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43299
diff
changeset
|
358 |
assert newcopies is not copies |
43255
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
359 |
for f in removed: |
42522
e7c55e24d6bf
copies: avoid reusing the same variable for two different copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents:
42503
diff
changeset
|
360 |
if f in newcopies: |
43300
ffd04bc9f57d
copies: move from a copy on branchpoint to a copy on write approach
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43299
diff
changeset
|
361 |
if newcopies is copies: |
ffd04bc9f57d
copies: move from a copy on branchpoint to a copy on write approach
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43299
diff
changeset
|
362 |
# copy on write to avoid affecting potential other |
ffd04bc9f57d
copies: move from a copy on branchpoint to a copy on write approach
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43299
diff
changeset
|
363 |
# branches. when there are no other branches, this |
ffd04bc9f57d
copies: move from a copy on branchpoint to a copy on write approach
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43299
diff
changeset
|
364 |
# could be avoided. |
ffd04bc9f57d
copies: move from a copy on branchpoint to a copy on write approach
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43299
diff
changeset
|
365 |
newcopies = copies.copy() |
44858
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
366 |
newcopies[f] = (c, None) |
43252
32187ae9eeb3
copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43231
diff
changeset
|
367 |
othercopies = all_copies.get(c) |
32187ae9eeb3
copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43231
diff
changeset
|
368 |
if othercopies is None: |
32187ae9eeb3
copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43231
diff
changeset
|
369 |
all_copies[c] = newcopies |
32187ae9eeb3
copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43231
diff
changeset
|
370 |
else: |
32187ae9eeb3
copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43231
diff
changeset
|
371 |
# we are the second parent to work on c, we need to merge our |
32187ae9eeb3
copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43231
diff
changeset
|
372 |
# work with the other. |
32187ae9eeb3
copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43231
diff
changeset
|
373 |
# |
32187ae9eeb3
copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43231
diff
changeset
|
374 |
# In case of conflict, parent 1 take precedence over parent 2. |
32187ae9eeb3
copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43231
diff
changeset
|
375 |
# This is an arbitrary choice made anew when implementing |
32187ae9eeb3
copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43231
diff
changeset
|
376 |
# changeset based copies. It was made without regards with |
32187ae9eeb3
copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43231
diff
changeset
|
377 |
# potential filelog related behavior. |
32187ae9eeb3
copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43231
diff
changeset
|
378 |
if parent == 1: |
44858
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
379 |
_merge_copies_dict( |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
380 |
othercopies, newcopies, isancestor, ismerged |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
381 |
) |
43252
32187ae9eeb3
copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43231
diff
changeset
|
382 |
else: |
44858
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
383 |
_merge_copies_dict( |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
384 |
newcopies, othercopies, isancestor, ismerged |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
385 |
) |
43252
32187ae9eeb3
copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43231
diff
changeset
|
386 |
all_copies[c] = newcopies |
44858
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
387 |
|
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
388 |
final_copies = {} |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
389 |
for dest, (tt, source) in all_copies[targetrev].items(): |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
390 |
if source is not None: |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
391 |
final_copies[dest] = source |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
392 |
return final_copies |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
393 |
|
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
394 |
|
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
395 |
def _merge_copies_dict(minor, major, isancestor, ismerged): |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
396 |
"""merge two copies-mapping together, minor and major |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
397 |
|
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
398 |
In case of conflict, value from "major" will be picked. |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
399 |
|
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
400 |
- `isancestors(low_rev, high_rev)`: callable return True if `low_rev` is an |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
401 |
ancestors of `high_rev`, |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
402 |
|
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
403 |
- `ismerged(path)`: callable return True if `path` have been merged in the |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
404 |
current revision, |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
405 |
""" |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
406 |
for dest, value in major.items(): |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
407 |
other = minor.get(dest) |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
408 |
if other is None: |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
409 |
minor[dest] = value |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
410 |
else: |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
411 |
new_tt = value[0] |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
412 |
other_tt = other[0] |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
413 |
if value[1] == other[1]: |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
414 |
continue |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
415 |
# content from "major" wins, unless it is older |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
416 |
# than the branch point or there is a merge |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
417 |
if ( |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
418 |
new_tt == other_tt |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
419 |
or not isancestor(new_tt, other_tt) |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
420 |
or ismerged(dest) |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
421 |
): |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
422 |
minor[dest] = value |
41765
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41763
diff
changeset
|
423 |
|
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
424 |
|
42595
819712deac69
copies: follow copies across merge base without source file (issue6163)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42594
diff
changeset
|
425 |
def _forwardcopies(a, b, base=None, match=None): |
35429
8801cdcea01f
copies: extract method for getting non-wdir forward copies
Martin von Zweigbergk <martinvonz@google.com>
parents:
35428
diff
changeset
|
426 |
"""find {dst@b: src@a} copy mapping where a is an ancestor of b""" |
8801cdcea01f
copies: extract method for getting non-wdir forward copies
Martin von Zweigbergk <martinvonz@google.com>
parents:
35428
diff
changeset
|
427 |
|
42595
819712deac69
copies: follow copies across merge base without source file (issue6163)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42594
diff
changeset
|
428 |
if base is None: |
819712deac69
copies: follow copies across merge base without source file (issue6163)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42594
diff
changeset
|
429 |
base = a |
40422
873f3682c8af
narrow: make copies.pathcopies() filter with narrowspec again
Martin von Zweigbergk <martinvonz@google.com>
parents:
40077
diff
changeset
|
430 |
match = a.repo().narrowmatch(match) |
35429
8801cdcea01f
copies: extract method for getting non-wdir forward copies
Martin von Zweigbergk <martinvonz@google.com>
parents:
35428
diff
changeset
|
431 |
# check for working copy |
8801cdcea01f
copies: extract method for getting non-wdir forward copies
Martin von Zweigbergk <martinvonz@google.com>
parents:
35428
diff
changeset
|
432 |
if b.rev() is None: |
42595
819712deac69
copies: follow copies across merge base without source file (issue6163)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42594
diff
changeset
|
433 |
cm = _committedforwardcopies(a, b.p1(), base, match) |
35430
e54f02ec6a05
copies: group wdir-handling in one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
35429
diff
changeset
|
434 |
# combine copies from dirstate if necessary |
42593
11ceb1b8fd74
copies: inline _chainandfilter() to prepare for next patch
Martin von Zweigbergk <martinvonz@google.com>
parents:
42592
diff
changeset
|
435 |
copies = _chain(cm, _dirstatecopies(b._repo, match)) |
42592
a48f6f18dc6d
copies: remove most early returns from pathcopies() and _forwardcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42591
diff
changeset
|
436 |
else: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
437 |
copies = _committedforwardcopies(a, b, base, match) |
42592
a48f6f18dc6d
copies: remove most early returns from pathcopies() and _forwardcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42591
diff
changeset
|
438 |
return copies |
15775
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
439 |
|
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
440 |
|
41762
3158cb74fbca
copies: make _backwardrenames() filter out copies by destination
Martin von Zweigbergk <martinvonz@google.com>
parents:
41761
diff
changeset
|
441 |
def _backwardrenames(a, b, match): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
442 |
if a._repo.ui.config(b'experimental', b'copytrace') == b'off': |
26013
38f92d12357c
copy: add flag for disabling copy tracing
Durham Goode <durham@fb.com>
parents:
25924
diff
changeset
|
443 |
return {} |
38f92d12357c
copy: add flag for disabling copy tracing
Durham Goode <durham@fb.com>
parents:
25924
diff
changeset
|
444 |
|
18136
f23dea2b296e
copies: do not track backward copies, only renames (issue3739)
Siddharth Agarwal <sid0@fb.com>
parents:
18135
diff
changeset
|
445 |
# Even though we're not taking copies into account, 1:n rename situations |
f23dea2b296e
copies: do not track backward copies, only renames (issue3739)
Siddharth Agarwal <sid0@fb.com>
parents:
18135
diff
changeset
|
446 |
# can still exist (e.g. hg cp a b; hg mv a c). In those cases we |
f23dea2b296e
copies: do not track backward copies, only renames (issue3739)
Siddharth Agarwal <sid0@fb.com>
parents:
18135
diff
changeset
|
447 |
# arbitrarily pick one of the renames. |
41762
3158cb74fbca
copies: make _backwardrenames() filter out copies by destination
Martin von Zweigbergk <martinvonz@google.com>
parents:
41761
diff
changeset
|
448 |
# We don't want to pass in "match" here, since that would filter |
3158cb74fbca
copies: make _backwardrenames() filter out copies by destination
Martin von Zweigbergk <martinvonz@google.com>
parents:
41761
diff
changeset
|
449 |
# the destination by it. Since we're reversing the copies, we want |
3158cb74fbca
copies: make _backwardrenames() filter out copies by destination
Martin von Zweigbergk <martinvonz@google.com>
parents:
41761
diff
changeset
|
450 |
# to filter the source instead. |
15775
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
451 |
f = _forwardcopies(b, a) |
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
452 |
r = {} |
43106
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43077
diff
changeset
|
453 |
for k, v in sorted(pycompat.iteritems(f)): |
41762
3158cb74fbca
copies: make _backwardrenames() filter out copies by destination
Martin von Zweigbergk <martinvonz@google.com>
parents:
41761
diff
changeset
|
454 |
if match and not match(v): |
3158cb74fbca
copies: make _backwardrenames() filter out copies by destination
Martin von Zweigbergk <martinvonz@google.com>
parents:
41761
diff
changeset
|
455 |
continue |
18136
f23dea2b296e
copies: do not track backward copies, only renames (issue3739)
Siddharth Agarwal <sid0@fb.com>
parents:
18135
diff
changeset
|
456 |
# remove copies |
f23dea2b296e
copies: do not track backward copies, only renames (issue3739)
Siddharth Agarwal <sid0@fb.com>
parents:
18135
diff
changeset
|
457 |
if v in a: |
f23dea2b296e
copies: do not track backward copies, only renames (issue3739)
Siddharth Agarwal <sid0@fb.com>
parents:
18135
diff
changeset
|
458 |
continue |
15775
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
459 |
r[v] = k |
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
460 |
return r |
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
461 |
|
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
462 |
|
24782
4906dc0e038c
copies: add matcher parameter to copy logic
Durham Goode <durham@fb.com>
parents:
24625
diff
changeset
|
463 |
def pathcopies(x, y, match=None): |
35428
9cf37d111acb
copies: consistently use """ for docstrings
Martin von Zweigbergk <martinvonz@google.com>
parents:
35427
diff
changeset
|
464 |
"""find {dst@y: src@x} copy mapping for directed compare""" |
40058
25b2868206e2
copies: add a devel debug mode to trace what copy tracing does
Boris Feld <boris.feld@octobus.net>
parents:
39967
diff
changeset
|
465 |
repo = x._repo |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
466 |
debug = repo.ui.debugflag and repo.ui.configbool(b'devel', b'debug.copies') |
40058
25b2868206e2
copies: add a devel debug mode to trace what copy tracing does
Boris Feld <boris.feld@octobus.net>
parents:
39967
diff
changeset
|
467 |
if debug: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
468 |
repo.ui.debug( |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
469 |
b'debug.copies: searching copies from %s to %s\n' % (x, y) |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
470 |
) |
15775
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
471 |
if x == y or not x or not y: |
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
472 |
return {} |
44323
30862e226339
copies: avoid filtering by short-circuit dirstate-only copies earlier
Martin von Zweigbergk <martinvonz@google.com>
parents:
44299
diff
changeset
|
473 |
if y.rev() is None and x == y.p1(): |
30862e226339
copies: avoid filtering by short-circuit dirstate-only copies earlier
Martin von Zweigbergk <martinvonz@google.com>
parents:
44299
diff
changeset
|
474 |
if debug: |
30862e226339
copies: avoid filtering by short-circuit dirstate-only copies earlier
Martin von Zweigbergk <martinvonz@google.com>
parents:
44299
diff
changeset
|
475 |
repo.ui.debug(b'debug.copies: search mode: dirstate\n') |
30862e226339
copies: avoid filtering by short-circuit dirstate-only copies earlier
Martin von Zweigbergk <martinvonz@google.com>
parents:
44299
diff
changeset
|
476 |
# short-circuit to avoid issues with merge states |
30862e226339
copies: avoid filtering by short-circuit dirstate-only copies earlier
Martin von Zweigbergk <martinvonz@google.com>
parents:
44299
diff
changeset
|
477 |
return _dirstatecopies(repo, match) |
15775
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
478 |
a = y.ancestor(x) |
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
479 |
if a == x: |
40058
25b2868206e2
copies: add a devel debug mode to trace what copy tracing does
Boris Feld <boris.feld@octobus.net>
parents:
39967
diff
changeset
|
480 |
if debug: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
481 |
repo.ui.debug(b'debug.copies: search mode: forward\n') |
42592
a48f6f18dc6d
copies: remove most early returns from pathcopies() and _forwardcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42591
diff
changeset
|
482 |
copies = _forwardcopies(x, y, match=match) |
a48f6f18dc6d
copies: remove most early returns from pathcopies() and _forwardcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42591
diff
changeset
|
483 |
elif a == y: |
40058
25b2868206e2
copies: add a devel debug mode to trace what copy tracing does
Boris Feld <boris.feld@octobus.net>
parents:
39967
diff
changeset
|
484 |
if debug: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
485 |
repo.ui.debug(b'debug.copies: search mode: backward\n') |
42592
a48f6f18dc6d
copies: remove most early returns from pathcopies() and _forwardcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42591
diff
changeset
|
486 |
copies = _backwardrenames(x, y, match=match) |
a48f6f18dc6d
copies: remove most early returns from pathcopies() and _forwardcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42591
diff
changeset
|
487 |
else: |
a48f6f18dc6d
copies: remove most early returns from pathcopies() and _forwardcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42591
diff
changeset
|
488 |
if debug: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
489 |
repo.ui.debug(b'debug.copies: search mode: combined\n') |
42595
819712deac69
copies: follow copies across merge base without source file (issue6163)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42594
diff
changeset
|
490 |
base = None |
819712deac69
copies: follow copies across merge base without source file (issue6163)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42594
diff
changeset
|
491 |
if a.rev() != node.nullrev: |
819712deac69
copies: follow copies across merge base without source file (issue6163)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42594
diff
changeset
|
492 |
base = x |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
493 |
copies = _chain( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
494 |
_backwardrenames(x, a, match=match), |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
495 |
_forwardcopies(a, y, base, match=match), |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
496 |
) |
42594
d013099c551b
copies: filter invalid copies only at end of pathcopies() (issue6163)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42593
diff
changeset
|
497 |
_filter(x, y, copies) |
42592
a48f6f18dc6d
copies: remove most early returns from pathcopies() and _forwardcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42591
diff
changeset
|
498 |
return copies |
15774
0bd17a4bed88
copies: split the copies api for "normal" and merge cases (API)
Matt Mackall <mpm@selenic.com>
parents:
14494
diff
changeset
|
499 |
|
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
500 |
|
30186
f7ed5af31242
mergecopies: rename 'ca' to 'base'
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30185
diff
changeset
|
501 |
def mergecopies(repo, c1, c2, base): |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
502 |
""" |
42118
967c098eed33
copies: move comment about implementation of mergecopies() to end
Martin von Zweigbergk <martinvonz@google.com>
parents:
42115
diff
changeset
|
503 |
Finds moves and copies between context c1 and c2 that are relevant for |
34095
b4b196092cc3
copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34094
diff
changeset
|
504 |
merging. 'base' will be used as the merge base. |
b4b196092cc3
copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34094
diff
changeset
|
505 |
|
b4b196092cc3
copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34094
diff
changeset
|
506 |
Copytracing is used in commands like rebase, merge, unshelve, etc to merge |
b4b196092cc3
copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34094
diff
changeset
|
507 |
files that were moved/ copied in one merge parent and modified in another. |
b4b196092cc3
copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34094
diff
changeset
|
508 |
For example: |
33843
42ad7cc645a4
copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32663
diff
changeset
|
509 |
|
42ad7cc645a4
copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32663
diff
changeset
|
510 |
o ---> 4 another commit |
42ad7cc645a4
copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32663
diff
changeset
|
511 |
| |
42ad7cc645a4
copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32663
diff
changeset
|
512 |
| o ---> 3 commit that modifies a.txt |
42ad7cc645a4
copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32663
diff
changeset
|
513 |
| / |
42ad7cc645a4
copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32663
diff
changeset
|
514 |
o / ---> 2 commit that moves a.txt to b.txt |
42ad7cc645a4
copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32663
diff
changeset
|
515 |
|/ |
42ad7cc645a4
copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32663
diff
changeset
|
516 |
o ---> 1 merge base |
42ad7cc645a4
copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32663
diff
changeset
|
517 |
|
42ad7cc645a4
copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32663
diff
changeset
|
518 |
If we try to rebase revision 3 on revision 4, since there is no a.txt in |
42ad7cc645a4
copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32663
diff
changeset
|
519 |
revision 4, and if user have copytrace disabled, we prints the following |
42ad7cc645a4
copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32663
diff
changeset
|
520 |
message: |
42ad7cc645a4
copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32663
diff
changeset
|
521 |
|
42ad7cc645a4
copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32663
diff
changeset
|
522 |
```other changed <file> which local deleted``` |
42ad7cc645a4
copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32663
diff
changeset
|
523 |
|
44274
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44272
diff
changeset
|
524 |
Returns a tuple where: |
16168
7bbabfe25321
copies: add docstring for mergecopies
Matt Mackall <mpm@selenic.com>
parents:
15994
diff
changeset
|
525 |
|
44274
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44272
diff
changeset
|
526 |
"branch_copies" an instance of branch_copies. |
18134
6c35b53cd28b
copies: separate moves via directory renames from explicit copies
Siddharth Agarwal <sid0@fb.com>
parents:
17055
diff
changeset
|
527 |
|
16168
7bbabfe25321
copies: add docstring for mergecopies
Matt Mackall <mpm@selenic.com>
parents:
15994
diff
changeset
|
528 |
"diverge" is a mapping of source name -> list of destination names |
7bbabfe25321
copies: add docstring for mergecopies
Matt Mackall <mpm@selenic.com>
parents:
15994
diff
changeset
|
529 |
for divergent renames. |
16794
98687cdddcb1
merge: warn about file deleted in one branch and renamed in other (issue3074)
Thomas Arendsen Hein <thomas@intevation.de>
parents:
16792
diff
changeset
|
530 |
|
42118
967c098eed33
copies: move comment about implementation of mergecopies() to end
Martin von Zweigbergk <martinvonz@google.com>
parents:
42115
diff
changeset
|
531 |
This function calls different copytracing algorithms based on config. |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
532 |
""" |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
533 |
# avoid silly behavior for update from empty dir |
6430
a6a66e812c34
copies: teach symmetric difference about working revisions
Matt Mackall <mpm@selenic.com>
parents:
6429
diff
changeset
|
534 |
if not c1 or not c2 or c1 == c2: |
44275
fa9ad1da2e77
merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents:
44274
diff
changeset
|
535 |
return branch_copies(), branch_copies(), {} |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
536 |
|
41761
012f695546aa
copies: respect narrowmatcher in "parent -> working dir" case
Martin von Zweigbergk <martinvonz@google.com>
parents:
41735
diff
changeset
|
537 |
narrowmatch = c1.repo().narrowmatch() |
012f695546aa
copies: respect narrowmatcher in "parent -> working dir" case
Martin von Zweigbergk <martinvonz@google.com>
parents:
41735
diff
changeset
|
538 |
|
6646
9eb274d773d9
copies: teach copies about dirstate.copies
Matt Mackall <mpm@selenic.com>
parents:
6431
diff
changeset
|
539 |
# avoid silly behavior for parent -> working dir |
13878
a8d13ee0ce68
misc: replace .parents()[0] with p1()
Matt Mackall <mpm@selenic.com>
parents:
12683
diff
changeset
|
540 |
if c2.node() is None and c1.node() == repo.dirstate.p1(): |
44275
fa9ad1da2e77
merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents:
44274
diff
changeset
|
541 |
return ( |
fa9ad1da2e77
merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents:
44274
diff
changeset
|
542 |
branch_copies(_dirstatecopies(repo, narrowmatch)), |
fa9ad1da2e77
merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents:
44274
diff
changeset
|
543 |
branch_copies(), |
fa9ad1da2e77
merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents:
44274
diff
changeset
|
544 |
{}, |
fa9ad1da2e77
merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents:
44274
diff
changeset
|
545 |
) |
6646
9eb274d773d9
copies: teach copies about dirstate.copies
Matt Mackall <mpm@selenic.com>
parents:
6431
diff
changeset
|
546 |
|
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
547 |
copytracing = repo.ui.config(b'experimental', b'copytrace') |
42255
d8ca7b99fc51
copies: move check for experimental.copytrace==<falsy> earlier
Martin von Zweigbergk <martinvonz@google.com>
parents:
42254
diff
changeset
|
548 |
if stringutil.parsebool(copytracing) is False: |
d8ca7b99fc51
copies: move check for experimental.copytrace==<falsy> earlier
Martin von Zweigbergk <martinvonz@google.com>
parents:
42254
diff
changeset
|
549 |
# stringutil.parsebool() returns None when it is unable to parse the |
d8ca7b99fc51
copies: move check for experimental.copytrace==<falsy> earlier
Martin von Zweigbergk <martinvonz@google.com>
parents:
42254
diff
changeset
|
550 |
# value, so we should rely on making sure copytracing is on such cases |
44275
fa9ad1da2e77
merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents:
44274
diff
changeset
|
551 |
return branch_copies(), branch_copies(), {} |
34095
b4b196092cc3
copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34094
diff
changeset
|
552 |
|
42256
a6be3af3a397
copies: ignore heuristics copytracing when using changeset-centric algos
Martin von Zweigbergk <martinvonz@google.com>
parents:
42255
diff
changeset
|
553 |
if usechangesetcentricalgo(repo): |
a6be3af3a397
copies: ignore heuristics copytracing when using changeset-centric algos
Martin von Zweigbergk <martinvonz@google.com>
parents:
42255
diff
changeset
|
554 |
# The heuristics don't make sense when we need changeset-centric algos |
a6be3af3a397
copies: ignore heuristics copytracing when using changeset-centric algos
Martin von Zweigbergk <martinvonz@google.com>
parents:
42255
diff
changeset
|
555 |
return _fullcopytracing(repo, c1, c2, base) |
a6be3af3a397
copies: ignore heuristics copytracing when using changeset-centric algos
Martin von Zweigbergk <martinvonz@google.com>
parents:
42255
diff
changeset
|
556 |
|
26013
38f92d12357c
copy: add flag for disabling copy tracing
Durham Goode <durham@fb.com>
parents:
25924
diff
changeset
|
557 |
# Copy trace disabling is explicitly below the node == p1 logic above |
38f92d12357c
copy: add flag for disabling copy tracing
Durham Goode <durham@fb.com>
parents:
25924
diff
changeset
|
558 |
# because the logic above is required for a simple copy to be kept across a |
38f92d12357c
copy: add flag for disabling copy tracing
Durham Goode <durham@fb.com>
parents:
25924
diff
changeset
|
559 |
# rebase. |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
560 |
if copytracing == b'heuristics': |
34367
d00910b286cd
copytrace: use ctx.mutable() instead of adhoc constant of non-public phases
Yuya Nishihara <yuya@tcha.org>
parents:
34355
diff
changeset
|
561 |
# Do full copytracing if only non-public revisions are involved as |
d00910b286cd
copytrace: use ctx.mutable() instead of adhoc constant of non-public phases
Yuya Nishihara <yuya@tcha.org>
parents:
34355
diff
changeset
|
562 |
# that will be fast enough and will also cover the copies which could |
d00910b286cd
copytrace: use ctx.mutable() instead of adhoc constant of non-public phases
Yuya Nishihara <yuya@tcha.org>
parents:
34355
diff
changeset
|
563 |
# be missed by heuristics |
34318
1826d695ad58
copytrace: add a a new config to limit the number of drafts in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34295
diff
changeset
|
564 |
if _isfullcopytraceable(repo, c1, base): |
34295
fc3b8483c6cb
copytrace: use the full copytracing method if only drafts are involved
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34191
diff
changeset
|
565 |
return _fullcopytracing(repo, c1, c2, base) |
34191
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
566 |
return _heuristicscopytracing(repo, c1, c2, base) |
34095
b4b196092cc3
copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34094
diff
changeset
|
567 |
else: |
b4b196092cc3
copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34094
diff
changeset
|
568 |
return _fullcopytracing(repo, c1, c2, base) |
26013
38f92d12357c
copy: add flag for disabling copy tracing
Durham Goode <durham@fb.com>
parents:
25924
diff
changeset
|
569 |
|
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
570 |
|
34318
1826d695ad58
copytrace: add a a new config to limit the number of drafts in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34295
diff
changeset
|
571 |
def _isfullcopytraceable(repo, c1, base): |
34367
d00910b286cd
copytrace: use ctx.mutable() instead of adhoc constant of non-public phases
Yuya Nishihara <yuya@tcha.org>
parents:
34355
diff
changeset
|
572 |
""" Checks that if base, source and destination are all no-public branches, |
d00910b286cd
copytrace: use ctx.mutable() instead of adhoc constant of non-public phases
Yuya Nishihara <yuya@tcha.org>
parents:
34355
diff
changeset
|
573 |
if yes let's use the full copytrace algorithm for increased capabilities |
d00910b286cd
copytrace: use ctx.mutable() instead of adhoc constant of non-public phases
Yuya Nishihara <yuya@tcha.org>
parents:
34355
diff
changeset
|
574 |
since it will be fast enough. |
34516
e79b3611223b
copies: add docs for config `experimental.copytrace.sourcecommitlimit`
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34367
diff
changeset
|
575 |
|
e79b3611223b
copies: add docs for config `experimental.copytrace.sourcecommitlimit`
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34367
diff
changeset
|
576 |
`experimental.copytrace.sourcecommitlimit` can be used to set a limit for |
e79b3611223b
copies: add docs for config `experimental.copytrace.sourcecommitlimit`
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34367
diff
changeset
|
577 |
number of changesets from c1 to base such that if number of changesets are |
e79b3611223b
copies: add docs for config `experimental.copytrace.sourcecommitlimit`
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34367
diff
changeset
|
578 |
more than the limit, full copytracing algorithm won't be used. |
34295
fc3b8483c6cb
copytrace: use the full copytracing method if only drafts are involved
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34191
diff
changeset
|
579 |
""" |
34318
1826d695ad58
copytrace: add a a new config to limit the number of drafts in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34295
diff
changeset
|
580 |
if c1.rev() is None: |
1826d695ad58
copytrace: add a a new config to limit the number of drafts in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34295
diff
changeset
|
581 |
c1 = c1.p1() |
34367
d00910b286cd
copytrace: use ctx.mutable() instead of adhoc constant of non-public phases
Yuya Nishihara <yuya@tcha.org>
parents:
34355
diff
changeset
|
582 |
if c1.mutable() and base.mutable(): |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
583 |
sourcecommitlimit = repo.ui.configint( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
584 |
b'experimental', b'copytrace.sourcecommitlimit' |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
585 |
) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
586 |
commits = len(repo.revs(b'%d::%d', base.rev(), c1.rev())) |
34318
1826d695ad58
copytrace: add a a new config to limit the number of drafts in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34295
diff
changeset
|
587 |
return commits < sourcecommitlimit |
34295
fc3b8483c6cb
copytrace: use the full copytracing method if only drafts are involved
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34191
diff
changeset
|
588 |
return False |
fc3b8483c6cb
copytrace: use the full copytracing method if only drafts are involved
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34191
diff
changeset
|
589 |
|
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
590 |
|
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
591 |
def _checksinglesidecopies( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
592 |
src, dsts1, m1, m2, mb, c2, base, copy, renamedelete |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
593 |
): |
42252
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
594 |
if src not in m2: |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
595 |
# deleted on side 2 |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
596 |
if src not in m1: |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
597 |
# renamed on side 1, deleted on side 2 |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
598 |
renamedelete[src] = dsts1 |
44284
d0c3eead515a
copies: fix crash when copy source is not in graft base
Martin von Zweigbergk <martinvonz@google.com>
parents:
44275
diff
changeset
|
599 |
elif src not in mb: |
d0c3eead515a
copies: fix crash when copy source is not in graft base
Martin von Zweigbergk <martinvonz@google.com>
parents:
44275
diff
changeset
|
600 |
# Work around the "short-circuit to avoid issues with merge states" |
d0c3eead515a
copies: fix crash when copy source is not in graft base
Martin von Zweigbergk <martinvonz@google.com>
parents:
44275
diff
changeset
|
601 |
# thing in pathcopies(): pathcopies(x, y) can return a copy where the |
d0c3eead515a
copies: fix crash when copy source is not in graft base
Martin von Zweigbergk <martinvonz@google.com>
parents:
44275
diff
changeset
|
602 |
# destination doesn't exist in y. |
d0c3eead515a
copies: fix crash when copy source is not in graft base
Martin von Zweigbergk <martinvonz@google.com>
parents:
44275
diff
changeset
|
603 |
pass |
44788
d452acc8cce8
flags: account for flag change when tracking rename relevant to merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
604 |
elif mb[src] != m2[src] and not _related(c2[src], base[src]): |
d452acc8cce8
flags: account for flag change when tracking rename relevant to merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
605 |
return |
d452acc8cce8
flags: account for flag change when tracking rename relevant to merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44323
diff
changeset
|
606 |
elif mb[src] != m2[src] or mb.flags(src) != m2.flags(src): |
42252
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
607 |
# modified on side 2 |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
608 |
for dst in dsts1: |
44299
b4057d001760
merge: when rename was made on both sides, use ancestor as merge base
Martin von Zweigbergk <martinvonz@google.com>
parents:
44284
diff
changeset
|
609 |
copy[dst] = src |
42252
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
610 |
|
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
611 |
|
44274
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44272
diff
changeset
|
612 |
class branch_copies(object): |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44272
diff
changeset
|
613 |
"""Information about copies made on one side of a merge/graft. |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44272
diff
changeset
|
614 |
|
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44272
diff
changeset
|
615 |
"copy" is a mapping from destination name -> source name, |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44272
diff
changeset
|
616 |
where source is in c1 and destination is in c2 or vice-versa. |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44272
diff
changeset
|
617 |
|
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44272
diff
changeset
|
618 |
"movewithdir" is a mapping from source name -> destination name, |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44272
diff
changeset
|
619 |
where the file at source present in one context but not the other |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44272
diff
changeset
|
620 |
needs to be moved to destination by the merge process, because the |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44272
diff
changeset
|
621 |
other context moved the directory it is in. |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44272
diff
changeset
|
622 |
|
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44272
diff
changeset
|
623 |
"renamedelete" is a mapping of source name -> list of destination |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44272
diff
changeset
|
624 |
names for files deleted in c1 that were renamed in c2 or vice-versa. |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44272
diff
changeset
|
625 |
|
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44272
diff
changeset
|
626 |
"dirmove" is a mapping of detected source dir -> destination dir renames. |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44272
diff
changeset
|
627 |
This is needed for handling changes to new files previously grafted into |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44272
diff
changeset
|
628 |
renamed directories. |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44272
diff
changeset
|
629 |
""" |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44272
diff
changeset
|
630 |
|
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44272
diff
changeset
|
631 |
def __init__( |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44272
diff
changeset
|
632 |
self, copy=None, renamedelete=None, dirmove=None, movewithdir=None |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44272
diff
changeset
|
633 |
): |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44272
diff
changeset
|
634 |
self.copy = {} if copy is None else copy |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44272
diff
changeset
|
635 |
self.renamedelete = {} if renamedelete is None else renamedelete |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44272
diff
changeset
|
636 |
self.dirmove = {} if dirmove is None else dirmove |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44272
diff
changeset
|
637 |
self.movewithdir = {} if movewithdir is None else movewithdir |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44272
diff
changeset
|
638 |
|
45014
cfd06649a1b8
copies: implement __repr__ on branch_copies for debugging
Martin von Zweigbergk <martinvonz@google.com>
parents:
44981
diff
changeset
|
639 |
def __repr__(self): |
cfd06649a1b8
copies: implement __repr__ on branch_copies for debugging
Martin von Zweigbergk <martinvonz@google.com>
parents:
44981
diff
changeset
|
640 |
return ( |
cfd06649a1b8
copies: implement __repr__ on branch_copies for debugging
Martin von Zweigbergk <martinvonz@google.com>
parents:
44981
diff
changeset
|
641 |
'<branch_copies\n copy=%r\n renamedelete=%r\n dirmove=%r\n movewithdir=%r\n>' |
cfd06649a1b8
copies: implement __repr__ on branch_copies for debugging
Martin von Zweigbergk <martinvonz@google.com>
parents:
44981
diff
changeset
|
642 |
% (self.copy, self.renamedelete, self.dirmove, self.movewithdir,) |
cfd06649a1b8
copies: implement __repr__ on branch_copies for debugging
Martin von Zweigbergk <martinvonz@google.com>
parents:
44981
diff
changeset
|
643 |
) |
cfd06649a1b8
copies: implement __repr__ on branch_copies for debugging
Martin von Zweigbergk <martinvonz@google.com>
parents:
44981
diff
changeset
|
644 |
|
44274
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44272
diff
changeset
|
645 |
|
34095
b4b196092cc3
copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34094
diff
changeset
|
646 |
def _fullcopytracing(repo, c1, c2, base): |
b4b196092cc3
copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34094
diff
changeset
|
647 |
""" The full copytracing algorithm which finds all the new files that were |
b4b196092cc3
copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34094
diff
changeset
|
648 |
added from merge base up to the top commit and for each file it checks if |
b4b196092cc3
copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34094
diff
changeset
|
649 |
this file was copied from another file. |
b4b196092cc3
copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34094
diff
changeset
|
650 |
|
b4b196092cc3
copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34094
diff
changeset
|
651 |
This is pretty slow when a lot of changesets are involved but will track all |
b4b196092cc3
copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34094
diff
changeset
|
652 |
the copies. |
b4b196092cc3
copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34094
diff
changeset
|
653 |
""" |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
654 |
m1 = c1.manifest() |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
655 |
m2 = c2.manifest() |
30186
f7ed5af31242
mergecopies: rename 'ca' to 'base'
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30185
diff
changeset
|
656 |
mb = base.manifest() |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
657 |
|
42252
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
658 |
copies1 = pathcopies(base, c1) |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
659 |
copies2 = pathcopies(base, c2) |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
660 |
|
44242
baf3fe2977cc
copies: move early return in mergecopies() earlier
Martin von Zweigbergk <martinvonz@google.com>
parents:
44093
diff
changeset
|
661 |
if not (copies1 or copies2): |
44275
fa9ad1da2e77
merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents:
44274
diff
changeset
|
662 |
return branch_copies(), branch_copies(), {} |
44242
baf3fe2977cc
copies: move early return in mergecopies() earlier
Martin von Zweigbergk <martinvonz@google.com>
parents:
44093
diff
changeset
|
663 |
|
42252
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
664 |
inversecopies1 = {} |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
665 |
inversecopies2 = {} |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
666 |
for dst, src in copies1.items(): |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
667 |
inversecopies1.setdefault(src, []).append(dst) |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
668 |
for dst, src in copies2.items(): |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
669 |
inversecopies2.setdefault(src, []).append(dst) |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
670 |
|
44271
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44244
diff
changeset
|
671 |
copy1 = {} |
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44244
diff
changeset
|
672 |
copy2 = {} |
42252
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
673 |
diverge = {} |
44271
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44244
diff
changeset
|
674 |
renamedelete1 = {} |
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44244
diff
changeset
|
675 |
renamedelete2 = {} |
42252
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
676 |
allsources = set(inversecopies1) | set(inversecopies2) |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
677 |
for src in allsources: |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
678 |
dsts1 = inversecopies1.get(src) |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
679 |
dsts2 = inversecopies2.get(src) |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
680 |
if dsts1 and dsts2: |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
681 |
# copied/renamed on both sides |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
682 |
if src not in m1 and src not in m2: |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
683 |
# renamed on both sides |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
684 |
dsts1 = set(dsts1) |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
685 |
dsts2 = set(dsts2) |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
686 |
# If there's some overlap in the rename destinations, we |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
687 |
# consider it not divergent. For example, if side 1 copies 'a' |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
688 |
# to 'b' and 'c' and deletes 'a', and side 2 copies 'a' to 'c' |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
689 |
# and 'd' and deletes 'a'. |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
690 |
if dsts1 & dsts2: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
691 |
for dst in dsts1 & dsts2: |
44271
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44244
diff
changeset
|
692 |
copy1[dst] = src |
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44244
diff
changeset
|
693 |
copy2[dst] = src |
42252
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
694 |
else: |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
695 |
diverge[src] = sorted(dsts1 | dsts2) |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
696 |
elif src in m1 and src in m2: |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
697 |
# copied on both sides |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
698 |
dsts1 = set(dsts1) |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
699 |
dsts2 = set(dsts2) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
700 |
for dst in dsts1 & dsts2: |
44271
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44244
diff
changeset
|
701 |
copy1[dst] = src |
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44244
diff
changeset
|
702 |
copy2[dst] = src |
42252
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
703 |
# TODO: Handle cases where it was renamed on one side and copied |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
704 |
# on the other side |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
705 |
elif dsts1: |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
706 |
# copied/renamed only on side 1 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
707 |
_checksinglesidecopies( |
44271
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44244
diff
changeset
|
708 |
src, dsts1, m1, m2, mb, c2, base, copy1, renamedelete1 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
709 |
) |
42252
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
710 |
elif dsts2: |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
711 |
# copied/renamed only on side 2 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
712 |
_checksinglesidecopies( |
44271
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44244
diff
changeset
|
713 |
src, dsts2, m2, m1, mb, c1, base, copy2, renamedelete2 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
714 |
) |
42252
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42243
diff
changeset
|
715 |
|
26659
df66736a128e
copies: group bothnew with other sets
Matt Mackall <mpm@selenic.com>
parents:
26658
diff
changeset
|
716 |
# find interesting file sets from manifests |
39967
707c3804e607
narrow: move copies overrides to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
39946
diff
changeset
|
717 |
addedinm1 = m1.filesnotin(mb, repo.narrowmatch()) |
707c3804e607
narrow: move copies overrides to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
39946
diff
changeset
|
718 |
addedinm2 = m2.filesnotin(mb, repo.narrowmatch()) |
42253
d69bc8ffbe6f
copies: inline _computenonoverlap() in mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42252
diff
changeset
|
719 |
u1 = sorted(addedinm1 - addedinm2) |
d69bc8ffbe6f
copies: inline _computenonoverlap() in mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42252
diff
changeset
|
720 |
u2 = sorted(addedinm2 - addedinm1) |
d69bc8ffbe6f
copies: inline _computenonoverlap() in mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42252
diff
changeset
|
721 |
|
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
722 |
header = b" unmatched files in %s" |
42253
d69bc8ffbe6f
copies: inline _computenonoverlap() in mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42252
diff
changeset
|
723 |
if u1: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
724 |
repo.ui.debug(b"%s:\n %s\n" % (header % b'local', b"\n ".join(u1))) |
42253
d69bc8ffbe6f
copies: inline _computenonoverlap() in mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42252
diff
changeset
|
725 |
if u2: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
726 |
repo.ui.debug(b"%s:\n %s\n" % (header % b'other', b"\n ".join(u2))) |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
727 |
|
42208
85f5934016f9
copies: move early return for "no copies" case a little earlier
Martin von Zweigbergk <martinvonz@google.com>
parents:
42207
diff
changeset
|
728 |
if repo.ui.debugflag: |
44243
782e0d9c3b74
copies: avoid calculating debug-only stuff without --debug
Martin von Zweigbergk <martinvonz@google.com>
parents:
44242
diff
changeset
|
729 |
renamedeleteset = set() |
782e0d9c3b74
copies: avoid calculating debug-only stuff without --debug
Martin von Zweigbergk <martinvonz@google.com>
parents:
44242
diff
changeset
|
730 |
divergeset = set() |
782e0d9c3b74
copies: avoid calculating debug-only stuff without --debug
Martin von Zweigbergk <martinvonz@google.com>
parents:
44242
diff
changeset
|
731 |
for dsts in diverge.values(): |
782e0d9c3b74
copies: avoid calculating debug-only stuff without --debug
Martin von Zweigbergk <martinvonz@google.com>
parents:
44242
diff
changeset
|
732 |
divergeset.update(dsts) |
44271
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44244
diff
changeset
|
733 |
for dsts in renamedelete1.values(): |
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44244
diff
changeset
|
734 |
renamedeleteset.update(dsts) |
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44244
diff
changeset
|
735 |
for dsts in renamedelete2.values(): |
44243
782e0d9c3b74
copies: avoid calculating debug-only stuff without --debug
Martin von Zweigbergk <martinvonz@google.com>
parents:
44242
diff
changeset
|
736 |
renamedeleteset.update(dsts) |
782e0d9c3b74
copies: avoid calculating debug-only stuff without --debug
Martin von Zweigbergk <martinvonz@google.com>
parents:
44242
diff
changeset
|
737 |
|
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
738 |
repo.ui.debug( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
739 |
b" all copies found (* = to merge, ! = divergent, " |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
740 |
b"% = renamed and deleted):\n" |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
741 |
) |
44272
17e12938f8e7
copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents:
44271
diff
changeset
|
742 |
for side, copies in ((b"local", copies1), (b"remote", copies2)): |
17e12938f8e7
copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents:
44271
diff
changeset
|
743 |
if not copies: |
17e12938f8e7
copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents:
44271
diff
changeset
|
744 |
continue |
17e12938f8e7
copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents:
44271
diff
changeset
|
745 |
repo.ui.debug(b" on %s side:\n" % side) |
17e12938f8e7
copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents:
44271
diff
changeset
|
746 |
for f in sorted(copies): |
17e12938f8e7
copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents:
44271
diff
changeset
|
747 |
note = b"" |
17e12938f8e7
copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents:
44271
diff
changeset
|
748 |
if f in copy1 or f in copy2: |
17e12938f8e7
copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents:
44271
diff
changeset
|
749 |
note += b"*" |
17e12938f8e7
copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents:
44271
diff
changeset
|
750 |
if f in divergeset: |
17e12938f8e7
copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents:
44271
diff
changeset
|
751 |
note += b"!" |
17e12938f8e7
copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents:
44271
diff
changeset
|
752 |
if f in renamedeleteset: |
17e12938f8e7
copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents:
44271
diff
changeset
|
753 |
note += b"%" |
17e12938f8e7
copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents:
44271
diff
changeset
|
754 |
repo.ui.debug( |
17e12938f8e7
copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents:
44271
diff
changeset
|
755 |
b" src: '%s' -> dst: '%s' %s\n" % (copies[f], f, note) |
17e12938f8e7
copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents:
44271
diff
changeset
|
756 |
) |
44243
782e0d9c3b74
copies: avoid calculating debug-only stuff without --debug
Martin von Zweigbergk <martinvonz@google.com>
parents:
44242
diff
changeset
|
757 |
del renamedeleteset |
782e0d9c3b74
copies: avoid calculating debug-only stuff without --debug
Martin von Zweigbergk <martinvonz@google.com>
parents:
44242
diff
changeset
|
758 |
del divergeset |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
759 |
|
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
760 |
repo.ui.debug(b" checking for directory renames\n") |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
761 |
|
44271
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44244
diff
changeset
|
762 |
dirmove1, movewithdir2 = _dir_renames(repo, c1, copy1, copies1, u2) |
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44244
diff
changeset
|
763 |
dirmove2, movewithdir1 = _dir_renames(repo, c2, copy2, copies2, u1) |
44244
45192589555c
copies: extract function for finding directory renames
Martin von Zweigbergk <martinvonz@google.com>
parents:
44243
diff
changeset
|
764 |
|
44275
fa9ad1da2e77
merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents:
44274
diff
changeset
|
765 |
branch_copies1 = branch_copies(copy1, renamedelete1, dirmove1, movewithdir1) |
fa9ad1da2e77
merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents:
44274
diff
changeset
|
766 |
branch_copies2 = branch_copies(copy2, renamedelete2, dirmove2, movewithdir2) |
44271
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44244
diff
changeset
|
767 |
|
44275
fa9ad1da2e77
merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents:
44274
diff
changeset
|
768 |
return branch_copies1, branch_copies2, diverge |
44244
45192589555c
copies: extract function for finding directory renames
Martin von Zweigbergk <martinvonz@google.com>
parents:
44243
diff
changeset
|
769 |
|
45192589555c
copies: extract function for finding directory renames
Martin von Zweigbergk <martinvonz@google.com>
parents:
44243
diff
changeset
|
770 |
|
44271
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44244
diff
changeset
|
771 |
def _dir_renames(repo, ctx, copy, fullcopy, addedfiles): |
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44244
diff
changeset
|
772 |
"""Finds moved directories and files that should move with them. |
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44244
diff
changeset
|
773 |
|
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44244
diff
changeset
|
774 |
ctx: the context for one of the sides |
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44244
diff
changeset
|
775 |
copy: files copied on the same side (as ctx) |
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44244
diff
changeset
|
776 |
fullcopy: files copied on the same side (as ctx), including those that |
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44244
diff
changeset
|
777 |
merge.manifestmerge() won't care about |
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44244
diff
changeset
|
778 |
addedfiles: added files on the other side (compared to ctx) |
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44244
diff
changeset
|
779 |
""" |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
780 |
# generate a directory move map |
44271
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44244
diff
changeset
|
781 |
d = ctx.dirs() |
17055
8b7cd9a998f0
copies: re-include root directory in directory rename detection (issue3511)
Matt Mackall <mpm@selenic.com>
parents:
16795
diff
changeset
|
782 |
invalid = set() |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
783 |
dirmove = {} |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
784 |
|
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
785 |
# examine each file copy for a potential directory move, which is |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
786 |
# when all the files in a directory are moved to a new directory |
43106
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43077
diff
changeset
|
787 |
for dst, src in pycompat.iteritems(fullcopy): |
25282
0f28815ef066
copies: switch to using pathutil.dirname
Durham Goode <durham@fb.com>
parents:
24782
diff
changeset
|
788 |
dsrc, ddst = pathutil.dirname(src), pathutil.dirname(dst) |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
789 |
if dsrc in invalid: |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
790 |
# already seen to be uninteresting |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
791 |
continue |
44271
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44244
diff
changeset
|
792 |
elif dsrc in d and ddst in d: |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
793 |
# directory wasn't entirely moved locally |
39291
eebd591803ab
copies: correctly skip directories that have already been considered
Kyle Lippincott <spectral@google.com>
parents:
38670
diff
changeset
|
794 |
invalid.add(dsrc) |
eebd591803ab
copies: correctly skip directories that have already been considered
Kyle Lippincott <spectral@google.com>
parents:
38670
diff
changeset
|
795 |
elif dsrc in dirmove and dirmove[dsrc] != ddst: |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
796 |
# files from the same directory moved to two different places |
39291
eebd591803ab
copies: correctly skip directories that have already been considered
Kyle Lippincott <spectral@google.com>
parents:
38670
diff
changeset
|
797 |
invalid.add(dsrc) |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
798 |
else: |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
799 |
# looks good so far |
39291
eebd591803ab
copies: correctly skip directories that have already been considered
Kyle Lippincott <spectral@google.com>
parents:
38670
diff
changeset
|
800 |
dirmove[dsrc] = ddst |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
801 |
|
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
802 |
for i in invalid: |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
803 |
if i in dirmove: |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
804 |
del dirmove[i] |
44271
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44244
diff
changeset
|
805 |
del d, invalid |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
806 |
|
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
807 |
if not dirmove: |
44244
45192589555c
copies: extract function for finding directory renames
Martin von Zweigbergk <martinvonz@google.com>
parents:
44243
diff
changeset
|
808 |
return {}, {} |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
809 |
|
43106
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43077
diff
changeset
|
810 |
dirmove = {k + b"/": v + b"/" for k, v in pycompat.iteritems(dirmove)} |
39291
eebd591803ab
copies: correctly skip directories that have already been considered
Kyle Lippincott <spectral@google.com>
parents:
38670
diff
changeset
|
811 |
|
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
812 |
for d in dirmove: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
813 |
repo.ui.debug( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
814 |
b" discovered dir src: '%s' -> dst: '%s'\n" % (d, dirmove[d]) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
815 |
) |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
816 |
|
30183
0106f93ca1d5
checkcopies: move 'movewithdir' initialisation right before its usage
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30138
diff
changeset
|
817 |
movewithdir = {} |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
818 |
# check unaccounted nonoverlapping files against directory moves |
44271
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44244
diff
changeset
|
819 |
for f in addedfiles: |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
820 |
if f not in fullcopy: |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
821 |
for d in dirmove: |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
822 |
if f.startswith(d): |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
823 |
# new file added in a directory that was moved, move it |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
824 |
df = dirmove[d] + f[len(d) :] |
6426
e2c49ef2dd6e
copies: don't double-detect items in the directory copy check
Matt Mackall <mpm@selenic.com>
parents:
6425
diff
changeset
|
825 |
if df not in copy: |
18134
6c35b53cd28b
copies: separate moves via directory renames from explicit copies
Siddharth Agarwal <sid0@fb.com>
parents:
17055
diff
changeset
|
826 |
movewithdir[f] = df |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
827 |
repo.ui.debug( |
43117
8ff1ecfadcd1
cleanup: join string literals that are already on one line
Martin von Zweigbergk <martinvonz@google.com>
parents:
43106
diff
changeset
|
828 |
b" pending file src: '%s' -> dst: '%s'\n" |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
829 |
% (f, df) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
830 |
) |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
831 |
break |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
832 |
|
44244
45192589555c
copies: extract function for finding directory renames
Martin von Zweigbergk <martinvonz@google.com>
parents:
44243
diff
changeset
|
833 |
return dirmove, movewithdir |
19178
4327687ca757
copies: refactor checkcopies() into a top level method
Durham Goode <durham@fb.com>
parents:
18899
diff
changeset
|
834 |
|
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
835 |
|
34191
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
836 |
def _heuristicscopytracing(repo, c1, c2, base): |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
837 |
""" Fast copytracing using filename heuristics |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
838 |
|
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
839 |
Assumes that moves or renames are of following two types: |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
840 |
|
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
841 |
1) Inside a directory only (same directory name but different filenames) |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
842 |
2) Move from one directory to another |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
843 |
(same filenames but different directory names) |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
844 |
|
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
845 |
Works only when there are no merge commits in the "source branch". |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
846 |
Source branch is commits from base up to c2 not including base. |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
847 |
|
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
848 |
If merge is involved it fallbacks to _fullcopytracing(). |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
849 |
|
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
850 |
Can be used by setting the following config: |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
851 |
|
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
852 |
[experimental] |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
853 |
copytrace = heuristics |
34846
f05a6e015ecc
copies: add a config to limit the number of candidates to check in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34787
diff
changeset
|
854 |
|
f05a6e015ecc
copies: add a config to limit the number of candidates to check in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34787
diff
changeset
|
855 |
In some cases the copy/move candidates found by heuristics can be very large |
f05a6e015ecc
copies: add a config to limit the number of candidates to check in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34787
diff
changeset
|
856 |
in number and that will make the algorithm slow. The number of possible |
f05a6e015ecc
copies: add a config to limit the number of candidates to check in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34787
diff
changeset
|
857 |
candidates to check can be limited by using the config |
f05a6e015ecc
copies: add a config to limit the number of candidates to check in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34787
diff
changeset
|
858 |
`experimental.copytrace.movecandidateslimit` which defaults to 100. |
34191
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
859 |
""" |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
860 |
|
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
861 |
if c1.rev() is None: |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
862 |
c1 = c1.p1() |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
863 |
if c2.rev() is None: |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
864 |
c2 = c2.p1() |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
865 |
|
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
866 |
changedfiles = set() |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
867 |
m1 = c1.manifest() |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
868 |
if not repo.revs(b'%d::%d', base.rev(), c2.rev()): |
34191
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
869 |
# If base is not in c2 branch, we switch to fullcopytracing |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
870 |
repo.ui.debug( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
871 |
b"switching to full copytracing as base is not " |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
872 |
b"an ancestor of c2\n" |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
873 |
) |
34191
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
874 |
return _fullcopytracing(repo, c1, c2, base) |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
875 |
|
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
876 |
ctx = c2 |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
877 |
while ctx != base: |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
878 |
if len(ctx.parents()) == 2: |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
879 |
# To keep things simple let's not handle merges |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
880 |
repo.ui.debug(b"switching to full copytracing because of merges\n") |
34191
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
881 |
return _fullcopytracing(repo, c1, c2, base) |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
882 |
changedfiles.update(ctx.files()) |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
883 |
ctx = ctx.p1() |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
884 |
|
44275
fa9ad1da2e77
merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents:
44274
diff
changeset
|
885 |
copies2 = {} |
34191
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
886 |
cp = _forwardcopies(base, c2) |
43106
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43077
diff
changeset
|
887 |
for dst, src in pycompat.iteritems(cp): |
34191
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
888 |
if src in m1: |
44275
fa9ad1da2e77
merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents:
44274
diff
changeset
|
889 |
copies2[dst] = src |
34191
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
890 |
|
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
891 |
# file is missing if it isn't present in the destination, but is present in |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
892 |
# the base and present in the source. |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
893 |
# Presence in the base is important to exclude added files, presence in the |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
894 |
# source is important to exclude removed files. |
36379
f62369667a7c
py3: use list comprehensions instead of filter where we need to eagerly filter
Augie Fackler <augie@google.com>
parents:
36155
diff
changeset
|
895 |
filt = lambda f: f not in m1 and f in base and f in c2 |
f62369667a7c
py3: use list comprehensions instead of filter where we need to eagerly filter
Augie Fackler <augie@google.com>
parents:
36155
diff
changeset
|
896 |
missingfiles = [f for f in changedfiles if filt(f)] |
34191
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
897 |
|
44275
fa9ad1da2e77
merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents:
44274
diff
changeset
|
898 |
copies1 = {} |
34191
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
899 |
if missingfiles: |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
900 |
basenametofilename = collections.defaultdict(list) |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
901 |
dirnametofilename = collections.defaultdict(list) |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
902 |
|
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
903 |
for f in m1.filesnotin(base.manifest()): |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
904 |
basename = os.path.basename(f) |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
905 |
dirname = os.path.dirname(f) |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
906 |
basenametofilename[basename].append(f) |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
907 |
dirnametofilename[dirname].append(f) |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
908 |
|
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
909 |
for f in missingfiles: |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
910 |
basename = os.path.basename(f) |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
911 |
dirname = os.path.dirname(f) |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
912 |
samebasename = basenametofilename[basename] |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
913 |
samedirname = dirnametofilename[dirname] |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
914 |
movecandidates = samebasename + samedirname |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
915 |
# f is guaranteed to be present in c2, that's why |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
916 |
# c2.filectx(f) won't fail |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
917 |
f2 = c2.filectx(f) |
34846
f05a6e015ecc
copies: add a config to limit the number of candidates to check in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34787
diff
changeset
|
918 |
# we can have a lot of candidates which can slow down the heuristics |
f05a6e015ecc
copies: add a config to limit the number of candidates to check in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34787
diff
changeset
|
919 |
# config value to limit the number of candidates moves to check |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
920 |
maxcandidates = repo.ui.configint( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
921 |
b'experimental', b'copytrace.movecandidateslimit' |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
922 |
) |
34846
f05a6e015ecc
copies: add a config to limit the number of candidates to check in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34787
diff
changeset
|
923 |
|
f05a6e015ecc
copies: add a config to limit the number of candidates to check in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34787
diff
changeset
|
924 |
if len(movecandidates) > maxcandidates: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
925 |
repo.ui.status( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
926 |
_( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
927 |
b"skipping copytracing for '%s', more " |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
928 |
b"candidates than the limit: %d\n" |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
929 |
) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
930 |
% (f, len(movecandidates)) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
931 |
) |
34846
f05a6e015ecc
copies: add a config to limit the number of candidates to check in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34787
diff
changeset
|
932 |
continue |
f05a6e015ecc
copies: add a config to limit the number of candidates to check in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34787
diff
changeset
|
933 |
|
34191
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
934 |
for candidate in movecandidates: |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
935 |
f1 = c1.filectx(candidate) |
37392
a4f02a17420d
copies: clean up _related logic
Gábor Stefanik <gabor.stefanik@nng.com>
parents:
36379
diff
changeset
|
936 |
if _related(f1, f2): |
34191
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
937 |
# if there are a few related copies then we'll merge |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
938 |
# changes into all of them. This matches the behaviour |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
939 |
# of upstream copytracing |
44275
fa9ad1da2e77
merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents:
44274
diff
changeset
|
940 |
copies1[candidate] = f |
34191
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
941 |
|
44275
fa9ad1da2e77
merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents:
44274
diff
changeset
|
942 |
return branch_copies(copies1), branch_copies(copies2), {} |
34191
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34095
diff
changeset
|
943 |
|
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
944 |
|
37392
a4f02a17420d
copies: clean up _related logic
Gábor Stefanik <gabor.stefanik@nng.com>
parents:
36379
diff
changeset
|
945 |
def _related(f1, f2): |
30138
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
946 |
"""return True if f1 and f2 filectx have a common ancestor |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
947 |
|
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
948 |
Walk back to common ancestor to see if the two files originate |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
949 |
from the same file. Since workingfilectx's rev() is None it messes |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
950 |
up the integer comparison logic, hence the pre-step check for |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
951 |
None (f1 and f2 can only be workingfilectx's initially). |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
952 |
""" |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
953 |
|
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
954 |
if f1 == f2: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
955 |
return True # a match |
30138
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
956 |
|
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
957 |
g1, g2 = f1.ancestors(), f2.ancestors() |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
958 |
try: |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
959 |
f1r, f2r = f1.linkrev(), f2.linkrev() |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
960 |
|
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
961 |
if f1r is None: |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
962 |
f1 = next(g1) |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
963 |
if f2r is None: |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
964 |
f2 = next(g2) |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
965 |
|
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
966 |
while True: |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
967 |
f1r, f2r = f1.linkrev(), f2.linkrev() |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
968 |
if f1r > f2r: |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
969 |
f1 = next(g1) |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
970 |
elif f2r > f1r: |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
971 |
f2 = next(g2) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
972 |
else: # f1 and f2 point to files in the same linkrev |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
973 |
return f1 == f2 # true if they point to the same file |
30138
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
974 |
except StopIteration: |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
975 |
return False |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
976 |
|
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43022
diff
changeset
|
977 |
|
44092
833210fbd900
graftcopies: remove `skip` and `repo` arguments
Martin von Zweigbergk <martinvonz@google.com>
parents:
44091
diff
changeset
|
978 |
def graftcopies(wctx, ctx, base): |
44093
06e7e7652ac0
graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents:
44092
diff
changeset
|
979 |
"""reproduce copies between base and ctx in the wctx |
06e7e7652ac0
graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents:
44092
diff
changeset
|
980 |
|
06e7e7652ac0
graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents:
44092
diff
changeset
|
981 |
Unlike mergecopies(), this function will only consider copies between base |
06e7e7652ac0
graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents:
44092
diff
changeset
|
982 |
and ctx; it will ignore copies between base and wctx. Also unlike |
06e7e7652ac0
graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents:
44092
diff
changeset
|
983 |
mergecopies(), this function will apply copies to the working copy (instead |
06e7e7652ac0
graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents:
44092
diff
changeset
|
984 |
of just returning information about the copies). That makes it cheaper |
06e7e7652ac0
graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents:
44092
diff
changeset
|
985 |
(especially in the common case of base==ctx.p1()) and useful also when |
06e7e7652ac0
graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents:
44092
diff
changeset
|
986 |
experimental.copytrace=off. |
06e7e7652ac0
graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents:
44092
diff
changeset
|
987 |
|
06e7e7652ac0
graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents:
44092
diff
changeset
|
988 |
merge.update() will have already marked most copies, but it will only |
06e7e7652ac0
graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents:
44092
diff
changeset
|
989 |
mark copies if it thinks the source files are related (see |
06e7e7652ac0
graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents:
44092
diff
changeset
|
990 |
merge._related()). It will also not mark copies if the file wasn't modified |
06e7e7652ac0
graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents:
44092
diff
changeset
|
991 |
on the local side. This function adds the copies that were "missed" |
06e7e7652ac0
graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents:
44092
diff
changeset
|
992 |
by merge.update(). |
06e7e7652ac0
graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents:
44092
diff
changeset
|
993 |
""" |
44091
3df0bd706c40
graftcopies: use _filter() for filtering out invalid copies
Martin von Zweigbergk <martinvonz@google.com>
parents:
44090
diff
changeset
|
994 |
new_copies = pathcopies(base, ctx) |
3df0bd706c40
graftcopies: use _filter() for filtering out invalid copies
Martin von Zweigbergk <martinvonz@google.com>
parents:
44090
diff
changeset
|
995 |
_filter(wctx.p1(), wctx, new_copies) |
3df0bd706c40
graftcopies: use _filter() for filtering out invalid copies
Martin von Zweigbergk <martinvonz@google.com>
parents:
44090
diff
changeset
|
996 |
for dst, src in pycompat.iteritems(new_copies): |
3df0bd706c40
graftcopies: use _filter() for filtering out invalid copies
Martin von Zweigbergk <martinvonz@google.com>
parents:
44090
diff
changeset
|
997 |
wctx[dst].markcopied(src) |