Mercurial > hg
annotate mercurial/copies.py @ 43783:bbd7172bc3df
copies: show we can read data from the "first" mapping
In practice this make no difference since `t` is a copy of `a`. Having this
change before hand will make the next cleanup changeset clearer.
This is work on the road to using some native code for some performance critical
part of copy tracing.
author | Pierre-Yves David <pierre-yves.david@octobus.net> |
---|---|
date | Wed, 13 Nov 2019 20:45:34 +0100 |
parents | 79750d781928 |
children | 995066c41bb2 |
rev | line source |
---|---|
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 |
34179
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
10 import collections |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
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 ( |
43147
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
19 error, |
33867
252fb66ee5bb
copies: use intersectmatchers() in non-merge p1 optimization
Yuya Nishihara <yuya@tcha.org>
parents:
33822
diff
changeset
|
20 match as matchmod, |
28000
d4247c306d82
copies: optimize forward copy detection logic for rebases
Durham Goode <durham@fb.com>
parents:
27876
diff
changeset
|
21 node, |
25924
cfc24c22454e
copies: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25289
diff
changeset
|
22 pathutil, |
43106
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43077
diff
changeset
|
23 pycompat, |
25924
cfc24c22454e
copies: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25289
diff
changeset
|
24 util, |
cfc24c22454e
copies: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25289
diff
changeset
|
25 ) |
43148
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
26 |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
27 from .revlogutils import sidedata as sidedatamod |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
28 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
29 from .utils import stringutil |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
30 |
25924
cfc24c22454e
copies: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25289
diff
changeset
|
31 |
42593
11ceb1b8fd74
copies: inline _chainandfilter() to prepare for next patch
Martin von Zweigbergk <martinvonz@google.com>
parents:
42592
diff
changeset
|
32 def _filter(src, dst, t): |
11ceb1b8fd74
copies: inline _chainandfilter() to prepare for next patch
Martin von Zweigbergk <martinvonz@google.com>
parents:
42592
diff
changeset
|
33 """filters out invalid copies after chaining""" |
42227
d1c2688eda80
copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42226
diff
changeset
|
34 |
42593
11ceb1b8fd74
copies: inline _chainandfilter() to prepare for next patch
Martin von Zweigbergk <martinvonz@google.com>
parents:
42592
diff
changeset
|
35 # 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
|
36 # 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
|
37 # 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
|
38 # is where a file existed in 'src' and remained under that name in 'mid' and |
42227
d1c2688eda80
copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42226
diff
changeset
|
39 # then was renamed between 'mid' and 'dst'. |
d1c2688eda80
copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42226
diff
changeset
|
40 # |
d1c2688eda80
copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42226
diff
changeset
|
41 # case src mid dst result |
d1c2688eda80
copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42226
diff
changeset
|
42 # 1 x y - - |
d1c2688eda80
copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42226
diff
changeset
|
43 # 2 x y y x->y |
d1c2688eda80
copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42226
diff
changeset
|
44 # 3 x y x - |
d1c2688eda80
copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42226
diff
changeset
|
45 # 4 x y z x->z |
d1c2688eda80
copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42226
diff
changeset
|
46 # 5 - x y - |
d1c2688eda80
copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42226
diff
changeset
|
47 # 6 x x y x->y |
42373
f3d06d37e194
copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents:
42344
diff
changeset
|
48 # |
f3d06d37e194
copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents:
42344
diff
changeset
|
49 # _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:
42344
diff
changeset
|
50 # 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:
42344
diff
changeset
|
51 # 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:
42344
diff
changeset
|
52 # Cases 1, 3, and 5 are then removed by _filter(). |
42227
d1c2688eda80
copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42226
diff
changeset
|
53 |
42373
f3d06d37e194
copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents:
42344
diff
changeset
|
54 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:
42344
diff
changeset
|
55 # 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:
42344
diff
changeset
|
56 if v not in src: |
f3d06d37e194
copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents:
42344
diff
changeset
|
57 del t[k] |
f3d06d37e194
copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents:
42344
diff
changeset
|
58 # remove criss-crossed copies |
f3d06d37e194
copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents:
42344
diff
changeset
|
59 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:
42344
diff
changeset
|
60 del t[k] |
f3d06d37e194
copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents:
42344
diff
changeset
|
61 # 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:
42344
diff
changeset
|
62 elif k not in dst: |
f3d06d37e194
copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents:
42344
diff
changeset
|
63 del t[k] |
f3d06d37e194
copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents:
42344
diff
changeset
|
64 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
65 |
42373
f3d06d37e194
copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents:
42344
diff
changeset
|
66 def _chain(a, b): |
f3d06d37e194
copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents:
42344
diff
changeset
|
67 """chain two sets of copies 'a' and 'b'""" |
15775
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
68 t = a.copy() |
43106
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43077
diff
changeset
|
69 for k, v in pycompat.iteritems(b): |
43783
bbd7172bc3df
copies: show we can read data from the "first" mapping
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43782
diff
changeset
|
70 t[k] = a.get(v, v) |
15775
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
71 return t |
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
72 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
73 |
43199
069cbbb53cdf
copies: drop the findlimit logic
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43198
diff
changeset
|
74 def _tracefile(fctx, am, basemf): |
35421
9cf37d111acb
copies: consistently use """ for docstrings
Martin von Zweigbergk <martinvonz@google.com>
parents:
35420
diff
changeset
|
75 """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
|
76 manifest am |
c16fe77e340a
pathcopies: give up any optimization based on `introrev`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43148
diff
changeset
|
77 |
c16fe77e340a
pathcopies: give up any optimization based on `introrev`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43148
diff
changeset
|
78 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
|
79 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
|
80 disabling that feature.""" |
15775
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
81 |
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
82 for f in fctx.ancestors(): |
42548
4ebbd7c4a3c5
copies: return only path from _tracefile() since that's all caller needs
Martin von Zweigbergk <martinvonz@google.com>
parents:
42520
diff
changeset
|
83 path = f.path() |
4ebbd7c4a3c5
copies: return only path from _tracefile() since that's all caller needs
Martin von Zweigbergk <martinvonz@google.com>
parents:
42520
diff
changeset
|
84 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:
42520
diff
changeset
|
85 return path |
42595
819712deac69
copies: follow copies across merge base without source file (issue6163)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42594
diff
changeset
|
86 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
|
87 return path |
15775
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
88 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
89 |
41752
012f695546aa
copies: respect narrowmatcher in "parent -> working dir" case
Martin von Zweigbergk <martinvonz@google.com>
parents:
41724
diff
changeset
|
90 def _dirstatecopies(repo, match=None): |
012f695546aa
copies: respect narrowmatcher in "parent -> working dir" case
Martin von Zweigbergk <martinvonz@google.com>
parents:
41724
diff
changeset
|
91 ds = repo.dirstate |
15775
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
92 c = ds.copies().copy() |
34348
1a5abc45e2fa
py3: explicitly convert dict.keys() and dict.items() into a list
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34311
diff
changeset
|
93 for k in list(c): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
94 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
|
95 del c[k] |
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
96 return c |
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
97 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
98 |
24782
4906dc0e038c
copies: add matcher parameter to copy logic
Durham Goode <durham@fb.com>
parents:
24625
diff
changeset
|
99 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
|
100 """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
|
101 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
|
102 files _forwardcopies is about to process. |
d7d08337b3f6
copy: move _forwardcopies file logic to a function
Durham Goode <durham@fb.com>
parents:
24010
diff
changeset
|
103 """ |
24782
4906dc0e038c
copies: add matcher parameter to copy logic
Durham Goode <durham@fb.com>
parents:
24625
diff
changeset
|
104 ma = a.manifest() |
4906dc0e038c
copies: add matcher parameter to copy logic
Durham Goode <durham@fb.com>
parents:
24625
diff
changeset
|
105 mb = b.manifest() |
31256
5a909a8098a1
copies: remove use of manifest.matches
Durham Goode <durham@fb.com>
parents:
30581
diff
changeset
|
106 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
|
107 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
108 |
42115
27475ae67676
copies: extract function for deciding whether to use changeset-centric algos
Martin von Zweigbergk <martinvonz@google.com>
parents:
41936
diff
changeset
|
109 def usechangesetcentricalgo(repo): |
27475ae67676
copies: extract function for deciding whether to use changeset-centric algos
Martin von Zweigbergk <martinvonz@google.com>
parents:
41936
diff
changeset
|
110 """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
|
111 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
|
112 return True |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
113 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
|
114 changesetsource = (b'changeset-only', b'compatibility') |
43020
f3bcae1e9e23
copies: expand the logic of usechangesetcentricalgo
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42707
diff
changeset
|
115 return readfrom in changesetsource |
42115
27475ae67676
copies: extract function for deciding whether to use changeset-centric algos
Martin von Zweigbergk <martinvonz@google.com>
parents:
41936
diff
changeset
|
116 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
117 |
42595
819712deac69
copies: follow copies across merge base without source file (issue6163)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42594
diff
changeset
|
118 def _committedforwardcopies(a, b, base, match): |
35422
8801cdcea01f
copies: extract method for getting non-wdir forward copies
Martin von Zweigbergk <martinvonz@google.com>
parents:
35421
diff
changeset
|
119 """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
|
120 # 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
|
121 # one-side-only changeset, but not further back than that |
40057
25b2868206e2
copies: add a devel debug mode to trace what copy tracing does
Boris Feld <boris.feld@octobus.net>
parents:
39966
diff
changeset
|
122 repo = a._repo |
41756
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41754
diff
changeset
|
123 |
42115
27475ae67676
copies: extract function for deciding whether to use changeset-centric algos
Martin von Zweigbergk <martinvonz@google.com>
parents:
41936
diff
changeset
|
124 if usechangesetcentricalgo(repo): |
41756
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41754
diff
changeset
|
125 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:
41754
diff
changeset
|
126 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
127 debug = repo.ui.debugflag and repo.ui.configbool(b'devel', b'debug.copies') |
40057
25b2868206e2
copies: add a devel debug mode to trace what copy tracing does
Boris Feld <boris.feld@octobus.net>
parents:
39966
diff
changeset
|
128 dbg = repo.ui.debug |
25b2868206e2
copies: add a devel debug mode to trace what copy tracing does
Boris Feld <boris.feld@octobus.net>
parents:
39966
diff
changeset
|
129 if debug: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
130 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
|
131 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
|
132 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
|
133 |
15775
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
134 # find where new files came from |
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
135 # 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
|
136 # 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
|
137 cm = {} |
28000
d4247c306d82
copies: optimize forward copy detection logic for rebases
Durham Goode <durham@fb.com>
parents:
27876
diff
changeset
|
138 |
d4247c306d82
copies: optimize forward copy detection logic for rebases
Durham Goode <durham@fb.com>
parents:
27876
diff
changeset
|
139 # 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
|
140 # 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
|
141 # 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
|
142 # 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
|
143 # 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
|
144 # this comparison. |
d4247c306d82
copies: optimize forward copy detection logic for rebases
Durham Goode <durham@fb.com>
parents:
27876
diff
changeset
|
145 forwardmissingmatch = match |
33867
252fb66ee5bb
copies: use intersectmatchers() in non-merge p1 optimization
Yuya Nishihara <yuya@tcha.org>
parents:
33822
diff
changeset
|
146 if b.p1() == a and b.p2().node() == node.nullid: |
41936
a791623458ef
copies: remove dependency on scmutil by directly using match.exact()
Martin von Zweigbergk <martinvonz@google.com>
parents:
41932
diff
changeset
|
147 filesmatcher = matchmod.exact(b.files()) |
33867
252fb66ee5bb
copies: use intersectmatchers() in non-merge p1 optimization
Yuya Nishihara <yuya@tcha.org>
parents:
33822
diff
changeset
|
148 forwardmissingmatch = matchmod.intersectmatchers(match, filesmatcher) |
28000
d4247c306d82
copies: optimize forward copy detection logic for rebases
Durham Goode <durham@fb.com>
parents:
27876
diff
changeset
|
149 missing = _computeforwardmissing(a, b, match=forwardmissingmatch) |
d4247c306d82
copies: optimize forward copy detection logic for rebases
Durham Goode <durham@fb.com>
parents:
27876
diff
changeset
|
150 |
23980
c1ce5442453f
_adjustlinkrev: reuse ancestors set during rename detection (issue4514)
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23139
diff
changeset
|
151 ancestrycontext = a._repo.changelog.ancestors([b.rev()], inclusive=True) |
40057
25b2868206e2
copies: add a devel debug mode to trace what copy tracing does
Boris Feld <boris.feld@octobus.net>
parents:
39966
diff
changeset
|
152 |
25b2868206e2
copies: add a devel debug mode to trace what copy tracing does
Boris Feld <boris.feld@octobus.net>
parents:
39966
diff
changeset
|
153 if debug: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
154 dbg(b'debug.copies: missing files to search: %d\n' % len(missing)) |
40057
25b2868206e2
copies: add a devel debug mode to trace what copy tracing does
Boris Feld <boris.feld@octobus.net>
parents:
39966
diff
changeset
|
155 |
42210
390ec72b8ea4
copies: process files in deterministic order for stable tests
Martin von Zweigbergk <martinvonz@google.com>
parents:
42169
diff
changeset
|
156 for f in sorted(missing): |
40057
25b2868206e2
copies: add a devel debug mode to trace what copy tracing does
Boris Feld <boris.feld@octobus.net>
parents:
39966
diff
changeset
|
157 if debug: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
158 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
|
159 fctx = b[f] |
c1ce5442453f
_adjustlinkrev: reuse ancestors set during rename detection (issue4514)
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23139
diff
changeset
|
160 fctx._ancestrycontext = ancestrycontext |
40057
25b2868206e2
copies: add a devel debug mode to trace what copy tracing does
Boris Feld <boris.feld@octobus.net>
parents:
39966
diff
changeset
|
161 |
40058
cf01616f8d96
copies: add time information to the debug information
Boris Feld <boris.feld@octobus.net>
parents:
40057
diff
changeset
|
162 if debug: |
cf01616f8d96
copies: add time information to the debug information
Boris Feld <boris.feld@octobus.net>
parents:
40057
diff
changeset
|
163 start = util.timer() |
43199
069cbbb53cdf
copies: drop the findlimit logic
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43198
diff
changeset
|
164 opath = _tracefile(fctx, am, basemf) |
42548
4ebbd7c4a3c5
copies: return only path from _tracefile() since that's all caller needs
Martin von Zweigbergk <martinvonz@google.com>
parents:
42520
diff
changeset
|
165 if opath: |
40057
25b2868206e2
copies: add a devel debug mode to trace what copy tracing does
Boris Feld <boris.feld@octobus.net>
parents:
39966
diff
changeset
|
166 if debug: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
167 dbg(b'debug.copies: rename of: %s\n' % opath) |
42548
4ebbd7c4a3c5
copies: return only path from _tracefile() since that's all caller needs
Martin von Zweigbergk <martinvonz@google.com>
parents:
42520
diff
changeset
|
168 cm[f] = opath |
40058
cf01616f8d96
copies: add time information to the debug information
Boris Feld <boris.feld@octobus.net>
parents:
40057
diff
changeset
|
169 if debug: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
170 dbg( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
171 b'debug.copies: time: %f seconds\n' |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
172 % (util.timer() - start) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
173 ) |
35422
8801cdcea01f
copies: extract method for getting non-wdir forward copies
Martin von Zweigbergk <martinvonz@google.com>
parents:
35421
diff
changeset
|
174 return cm |
8801cdcea01f
copies: extract method for getting non-wdir forward copies
Martin von Zweigbergk <martinvonz@google.com>
parents:
35421
diff
changeset
|
175 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
176 |
43255
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
177 def _revinfogetter(repo): |
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
178 """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
|
179 |
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
180 * 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
|
181 * 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
|
182 * 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
|
183 * 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
|
184 * removed: a list of removed files |
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
185 """ |
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
186 cl = repo.changelog |
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
187 parents = cl.parentrevs |
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
188 |
43257
675c776fbcd1
sidedatacopies: directly fetch copies information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43256
diff
changeset
|
189 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
|
190 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
|
191 flags = cl.flags |
43257
675c776fbcd1
sidedatacopies: directly fetch copies information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43256
diff
changeset
|
192 |
43301
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
193 # 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
|
194 # |
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
195 # 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
|
196 # 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
|
197 # 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
|
198 # 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
|
199 # |
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
200 # 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
|
201 # 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
|
202 # 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
|
203 # 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
|
204 # between "source" and "destination". |
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
205 # |
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
206 # 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
|
207 # 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
|
208 # _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
|
209 # enough to matters. |
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
210 # |
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
211 # 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
|
212 # 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
|
213 # 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
|
214 # 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
|
215 # time to save memory. |
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
216 merge_caches = {} |
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
217 |
43257
675c776fbcd1
sidedatacopies: directly fetch copies information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43256
diff
changeset
|
218 def revinfo(rev): |
675c776fbcd1
sidedatacopies: directly fetch copies information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43256
diff
changeset
|
219 p1, p2 = parents(rev) |
43297
8a2925265402
sidedatacopies: fast path data fetching if revision has no sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43257
diff
changeset
|
220 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
|
221 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
|
222 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
|
223 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
|
224 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
|
225 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
|
226 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
|
227 removed = c.filesremoved |
43301
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
228 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
|
229 # XXX some case we over cache, IGNORE |
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
230 merge_caches[rev] = (p1, p2, p1copies, p2copies, removed) |
43297
8a2925265402
sidedatacopies: fast path data fetching if revision has no sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43257
diff
changeset
|
231 else: |
8a2925265402
sidedatacopies: fast path data fetching if revision has no sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43257
diff
changeset
|
232 p1copies = {} |
8a2925265402
sidedatacopies: fast path data fetching if revision has no sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43257
diff
changeset
|
233 p2copies = {} |
43782
79750d781928
copies: return consistent type from revinfo
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43302
diff
changeset
|
234 removed = [] |
43257
675c776fbcd1
sidedatacopies: directly fetch copies information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43256
diff
changeset
|
235 return p1, p2, p1copies, p2copies, removed |
675c776fbcd1
sidedatacopies: directly fetch copies information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43256
diff
changeset
|
236 |
675c776fbcd1
sidedatacopies: directly fetch copies information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43256
diff
changeset
|
237 else: |
675c776fbcd1
sidedatacopies: directly fetch copies information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43256
diff
changeset
|
238 |
675c776fbcd1
sidedatacopies: directly fetch copies information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43256
diff
changeset
|
239 def revinfo(rev): |
675c776fbcd1
sidedatacopies: directly fetch copies information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43256
diff
changeset
|
240 p1, p2 = parents(rev) |
675c776fbcd1
sidedatacopies: directly fetch copies information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43256
diff
changeset
|
241 ctx = repo[rev] |
675c776fbcd1
sidedatacopies: directly fetch copies information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43256
diff
changeset
|
242 p1copies, p2copies = ctx._copies |
675c776fbcd1
sidedatacopies: directly fetch copies information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43256
diff
changeset
|
243 removed = ctx.filesremoved() |
675c776fbcd1
sidedatacopies: directly fetch copies information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43256
diff
changeset
|
244 return p1, p2, p1copies, p2copies, removed |
43255
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
245 |
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
246 return revinfo |
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
247 |
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
248 |
41756
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41754
diff
changeset
|
249 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
|
250 if a.rev() in (node.nullrev, b.rev()): |
41756
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41754
diff
changeset
|
251 return {} |
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41754
diff
changeset
|
252 |
43256
00de32aa834e
copies: use an unfiltered repository for the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43255
diff
changeset
|
253 repo = a.repo().unfiltered() |
41756
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41754
diff
changeset
|
254 children = {} |
43255
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
255 revinfo = _revinfogetter(repo) |
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
256 |
41756
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41754
diff
changeset
|
257 cl = repo.changelog |
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41754
diff
changeset
|
258 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
|
259 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
|
260 roots = set() |
41756
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41754
diff
changeset
|
261 for r in missingrevs: |
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41754
diff
changeset
|
262 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:
41754
diff
changeset
|
263 if p == node.nullrev: |
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41754
diff
changeset
|
264 continue |
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41754
diff
changeset
|
265 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:
41754
diff
changeset
|
266 children[p] = [r] |
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41754
diff
changeset
|
267 else: |
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41754
diff
changeset
|
268 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
|
269 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
|
270 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
|
271 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
|
272 # 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
|
273 return {} |
83bb1e89ab9b
copies: compute the exact set of revision to walk
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43297
diff
changeset
|
274 min_root = min(roots) |
41756
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41754
diff
changeset
|
275 |
43299
83bb1e89ab9b
copies: compute the exact set of revision to walk
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43297
diff
changeset
|
276 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
|
277 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
|
278 ) |
83bb1e89ab9b
copies: compute the exact set of revision to walk
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43297
diff
changeset
|
279 |
83bb1e89ab9b
copies: compute the exact set of revision to walk
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43297
diff
changeset
|
280 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
|
281 iterrevs &= mrset |
83bb1e89ab9b
copies: compute the exact set of revision to walk
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43297
diff
changeset
|
282 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
|
283 iterrevs.remove(b.rev()) |
43252
32187ae9eeb3
copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43231
diff
changeset
|
284 all_copies = {r: {} for r in roots} |
42488
c0b51449bf6b
copies: avoid calling matcher if matcher.always()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42487
diff
changeset
|
285 alwaysmatch = match.always() |
43299
83bb1e89ab9b
copies: compute the exact set of revision to walk
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43297
diff
changeset
|
286 for r in sorted(iterrevs): |
43252
32187ae9eeb3
copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43231
diff
changeset
|
287 copies = all_copies.pop(r) |
42487
5ceb91136ebe
copies: avoid unnecessary copying of copy dict
Martin von Zweigbergk <martinvonz@google.com>
parents:
42486
diff
changeset
|
288 for i, c in enumerate(children[r]): |
43255
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
289 p1, p2, p1copies, p2copies, removed = 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
|
290 if r == p1: |
41756
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41754
diff
changeset
|
291 parent = 1 |
43253
82dabad535d2
copies: get copies information directly from _copies
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43252
diff
changeset
|
292 childcopies = p1copies |
41756
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41754
diff
changeset
|
293 else: |
43254
181d28ba05da
copies: avoid instancing more changectx to access parent revisions
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43253
diff
changeset
|
294 assert r == p2 |
41756
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41754
diff
changeset
|
295 parent = 2 |
43253
82dabad535d2
copies: get copies information directly from _copies
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43252
diff
changeset
|
296 childcopies = p2copies |
42488
c0b51449bf6b
copies: avoid calling matcher if matcher.always()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42487
diff
changeset
|
297 if not alwaysmatch: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
298 childcopies = { |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
299 dst: src for dst, src in childcopies.items() if match(dst) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
300 } |
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
|
301 newcopies = copies |
42514
e7c55e24d6bf
copies: avoid reusing the same variable for two different copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents:
42488
diff
changeset
|
302 if childcopies: |
e7c55e24d6bf
copies: avoid reusing the same variable for two different copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents:
42488
diff
changeset
|
303 newcopies = _chain(newcopies, childcopies) |
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
|
304 # _chain makes a copies, we can avoid doing so in some |
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
|
305 # simple/linear cases. |
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
|
306 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
|
307 for f in removed: |
42514
e7c55e24d6bf
copies: avoid reusing the same variable for two different copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents:
42488
diff
changeset
|
308 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
|
309 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
|
310 # 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
|
311 # 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
|
312 # 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
|
313 newcopies = copies.copy() |
42514
e7c55e24d6bf
copies: avoid reusing the same variable for two different copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents:
42488
diff
changeset
|
314 del newcopies[f] |
43252
32187ae9eeb3
copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43231
diff
changeset
|
315 othercopies = all_copies.get(c) |
32187ae9eeb3
copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43231
diff
changeset
|
316 if othercopies is None: |
32187ae9eeb3
copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43231
diff
changeset
|
317 all_copies[c] = newcopies |
32187ae9eeb3
copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43231
diff
changeset
|
318 else: |
32187ae9eeb3
copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43231
diff
changeset
|
319 # 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
|
320 # work with the other. |
32187ae9eeb3
copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43231
diff
changeset
|
321 # |
32187ae9eeb3
copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43231
diff
changeset
|
322 # Unlike when copies are stored in the filelog, we consider |
32187ae9eeb3
copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43231
diff
changeset
|
323 # it a copy even if the destination already existed on the |
32187ae9eeb3
copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43231
diff
changeset
|
324 # other branch. It's simply too expensive to check if the |
32187ae9eeb3
copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43231
diff
changeset
|
325 # file existed in the manifest. |
32187ae9eeb3
copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43231
diff
changeset
|
326 # |
32187ae9eeb3
copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43231
diff
changeset
|
327 # 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
|
328 # 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
|
329 # 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
|
330 # potential filelog related behavior. |
32187ae9eeb3
copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43231
diff
changeset
|
331 if parent == 1: |
32187ae9eeb3
copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43231
diff
changeset
|
332 othercopies.update(newcopies) |
32187ae9eeb3
copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43231
diff
changeset
|
333 else: |
32187ae9eeb3
copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43231
diff
changeset
|
334 newcopies.update(othercopies) |
32187ae9eeb3
copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43231
diff
changeset
|
335 all_copies[c] = newcopies |
43299
83bb1e89ab9b
copies: compute the exact set of revision to walk
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43297
diff
changeset
|
336 return all_copies[b.rev()] |
41756
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41754
diff
changeset
|
337 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
338 |
42595
819712deac69
copies: follow copies across merge base without source file (issue6163)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42594
diff
changeset
|
339 def _forwardcopies(a, b, base=None, match=None): |
35422
8801cdcea01f
copies: extract method for getting non-wdir forward copies
Martin von Zweigbergk <martinvonz@google.com>
parents:
35421
diff
changeset
|
340 """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:
35421
diff
changeset
|
341 |
42595
819712deac69
copies: follow copies across merge base without source file (issue6163)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42594
diff
changeset
|
342 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
|
343 base = a |
40448
873f3682c8af
narrow: make copies.pathcopies() filter with narrowspec again
Martin von Zweigbergk <martinvonz@google.com>
parents:
40076
diff
changeset
|
344 match = a.repo().narrowmatch(match) |
35422
8801cdcea01f
copies: extract method for getting non-wdir forward copies
Martin von Zweigbergk <martinvonz@google.com>
parents:
35421
diff
changeset
|
345 # check for working copy |
8801cdcea01f
copies: extract method for getting non-wdir forward copies
Martin von Zweigbergk <martinvonz@google.com>
parents:
35421
diff
changeset
|
346 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
|
347 cm = _committedforwardcopies(a, b.p1(), base, match) |
35423
e54f02ec6a05
copies: group wdir-handling in one place
Martin von Zweigbergk <martinvonz@google.com>
parents:
35422
diff
changeset
|
348 # 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
|
349 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
|
350 else: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
351 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
|
352 return copies |
15775
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
353 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
354 |
41753
3158cb74fbca
copies: make _backwardrenames() filter out copies by destination
Martin von Zweigbergk <martinvonz@google.com>
parents:
41752
diff
changeset
|
355 def _backwardrenames(a, b, match): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
356 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
|
357 return {} |
38f92d12357c
copy: add flag for disabling copy tracing
Durham Goode <durham@fb.com>
parents:
25924
diff
changeset
|
358 |
18136
f23dea2b296e
copies: do not track backward copies, only renames (issue3739)
Siddharth Agarwal <sid0@fb.com>
parents:
18135
diff
changeset
|
359 # 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
|
360 # 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
|
361 # arbitrarily pick one of the renames. |
41753
3158cb74fbca
copies: make _backwardrenames() filter out copies by destination
Martin von Zweigbergk <martinvonz@google.com>
parents:
41752
diff
changeset
|
362 # 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:
41752
diff
changeset
|
363 # 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:
41752
diff
changeset
|
364 # to filter the source instead. |
15775
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
365 f = _forwardcopies(b, a) |
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
366 r = {} |
43106
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43077
diff
changeset
|
367 for k, v in sorted(pycompat.iteritems(f)): |
41753
3158cb74fbca
copies: make _backwardrenames() filter out copies by destination
Martin von Zweigbergk <martinvonz@google.com>
parents:
41752
diff
changeset
|
368 if match and not match(v): |
3158cb74fbca
copies: make _backwardrenames() filter out copies by destination
Martin von Zweigbergk <martinvonz@google.com>
parents:
41752
diff
changeset
|
369 continue |
18136
f23dea2b296e
copies: do not track backward copies, only renames (issue3739)
Siddharth Agarwal <sid0@fb.com>
parents:
18135
diff
changeset
|
370 # remove copies |
f23dea2b296e
copies: do not track backward copies, only renames (issue3739)
Siddharth Agarwal <sid0@fb.com>
parents:
18135
diff
changeset
|
371 if v in a: |
f23dea2b296e
copies: do not track backward copies, only renames (issue3739)
Siddharth Agarwal <sid0@fb.com>
parents:
18135
diff
changeset
|
372 continue |
15775
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
373 r[v] = k |
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
374 return r |
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
375 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
376 |
24782
4906dc0e038c
copies: add matcher parameter to copy logic
Durham Goode <durham@fb.com>
parents:
24625
diff
changeset
|
377 def pathcopies(x, y, match=None): |
35421
9cf37d111acb
copies: consistently use """ for docstrings
Martin von Zweigbergk <martinvonz@google.com>
parents:
35420
diff
changeset
|
378 """find {dst@y: src@x} copy mapping for directed compare""" |
40057
25b2868206e2
copies: add a devel debug mode to trace what copy tracing does
Boris Feld <boris.feld@octobus.net>
parents:
39966
diff
changeset
|
379 repo = x._repo |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
380 debug = repo.ui.debugflag and repo.ui.configbool(b'devel', b'debug.copies') |
40057
25b2868206e2
copies: add a devel debug mode to trace what copy tracing does
Boris Feld <boris.feld@octobus.net>
parents:
39966
diff
changeset
|
381 if debug: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
382 repo.ui.debug( |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
383 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
|
384 ) |
15775
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
385 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
|
386 return {} |
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
387 a = y.ancestor(x) |
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
388 if a == x: |
40057
25b2868206e2
copies: add a devel debug mode to trace what copy tracing does
Boris Feld <boris.feld@octobus.net>
parents:
39966
diff
changeset
|
389 if debug: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
390 repo.ui.debug(b'debug.copies: search mode: forward\n') |
42591
bcb4b5c5964b
copies: move short-circuiting of dirstate copies out of _forwardcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42548
diff
changeset
|
391 if y.rev() is None and x == y.p1(): |
bcb4b5c5964b
copies: move short-circuiting of dirstate copies out of _forwardcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42548
diff
changeset
|
392 # short-circuit to avoid issues with merge states |
bcb4b5c5964b
copies: move short-circuiting of dirstate copies out of _forwardcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42548
diff
changeset
|
393 return _dirstatecopies(repo, match) |
42592
a48f6f18dc6d
copies: remove most early returns from pathcopies() and _forwardcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42591
diff
changeset
|
394 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
|
395 elif a == y: |
40057
25b2868206e2
copies: add a devel debug mode to trace what copy tracing does
Boris Feld <boris.feld@octobus.net>
parents:
39966
diff
changeset
|
396 if debug: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
397 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
|
398 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
|
399 else: |
a48f6f18dc6d
copies: remove most early returns from pathcopies() and _forwardcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42591
diff
changeset
|
400 if debug: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
401 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
|
402 base = None |
819712deac69
copies: follow copies across merge base without source file (issue6163)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42594
diff
changeset
|
403 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
|
404 base = x |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
405 copies = _chain( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
406 _backwardrenames(x, a, match=match), |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
407 _forwardcopies(a, y, base, match=match), |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
408 ) |
42594
d013099c551b
copies: filter invalid copies only at end of pathcopies() (issue6163)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42593
diff
changeset
|
409 _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
|
410 return copies |
15774
0bd17a4bed88
copies: split the copies api for "normal" and merge cases (API)
Matt Mackall <mpm@selenic.com>
parents:
14494
diff
changeset
|
411 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
412 |
30186
f7ed5af31242
mergecopies: rename 'ca' to 'base'
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30185
diff
changeset
|
413 def mergecopies(repo, c1, c2, base): |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
414 """ |
42118
967c098eed33
copies: move comment about implementation of mergecopies() to end
Martin von Zweigbergk <martinvonz@google.com>
parents:
42115
diff
changeset
|
415 Finds moves and copies between context c1 and c2 that are relevant for |
34078
b4b196092cc3
copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34077
diff
changeset
|
416 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:
34077
diff
changeset
|
417 |
b4b196092cc3
copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34077
diff
changeset
|
418 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:
34077
diff
changeset
|
419 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:
34077
diff
changeset
|
420 For example: |
33822
42ad7cc645a4
copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32640
diff
changeset
|
421 |
42ad7cc645a4
copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32640
diff
changeset
|
422 o ---> 4 another commit |
42ad7cc645a4
copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32640
diff
changeset
|
423 | |
42ad7cc645a4
copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32640
diff
changeset
|
424 | o ---> 3 commit that modifies a.txt |
42ad7cc645a4
copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32640
diff
changeset
|
425 | / |
42ad7cc645a4
copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32640
diff
changeset
|
426 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:
32640
diff
changeset
|
427 |/ |
42ad7cc645a4
copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32640
diff
changeset
|
428 o ---> 1 merge base |
42ad7cc645a4
copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32640
diff
changeset
|
429 |
42ad7cc645a4
copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32640
diff
changeset
|
430 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:
32640
diff
changeset
|
431 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:
32640
diff
changeset
|
432 message: |
42ad7cc645a4
copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32640
diff
changeset
|
433 |
42ad7cc645a4
copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32640
diff
changeset
|
434 ```other changed <file> which local deleted``` |
42ad7cc645a4
copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32640
diff
changeset
|
435 |
30581
43a9e02a7b7f
graft: support grafting changes to new file in renamed directory (issue5436)
Gábor Stefanik <gabor.stefanik@nng.com>
parents:
30361
diff
changeset
|
436 Returns five dicts: "copy", "movewithdir", "diverge", "renamedelete" and |
43a9e02a7b7f
graft: support grafting changes to new file in renamed directory (issue5436)
Gábor Stefanik <gabor.stefanik@nng.com>
parents:
30361
diff
changeset
|
437 "dirmove". |
16168
7bbabfe25321
copies: add docstring for mergecopies
Matt Mackall <mpm@selenic.com>
parents:
15994
diff
changeset
|
438 |
16177
b8c1a8a57540
copies: fix mergecopies doc mapping direction
Matt Mackall <mpm@selenic.com>
parents:
16169
diff
changeset
|
439 "copy" is a mapping from destination name -> source name, |
16168
7bbabfe25321
copies: add docstring for mergecopies
Matt Mackall <mpm@selenic.com>
parents:
15994
diff
changeset
|
440 where source is in c1 and destination is in c2 or vice-versa. |
7bbabfe25321
copies: add docstring for mergecopies
Matt Mackall <mpm@selenic.com>
parents:
15994
diff
changeset
|
441 |
18134
6c35b53cd28b
copies: separate moves via directory renames from explicit copies
Siddharth Agarwal <sid0@fb.com>
parents:
17055
diff
changeset
|
442 "movewithdir" is a mapping from source name -> destination name, |
6c35b53cd28b
copies: separate moves via directory renames from explicit copies
Siddharth Agarwal <sid0@fb.com>
parents:
17055
diff
changeset
|
443 where the file at source present in one context but not the other |
6c35b53cd28b
copies: separate moves via directory renames from explicit copies
Siddharth Agarwal <sid0@fb.com>
parents:
17055
diff
changeset
|
444 needs to be moved to destination by the merge process, because the |
6c35b53cd28b
copies: separate moves via directory renames from explicit copies
Siddharth Agarwal <sid0@fb.com>
parents:
17055
diff
changeset
|
445 other context moved the directory it is in. |
6c35b53cd28b
copies: separate moves via directory renames from explicit copies
Siddharth Agarwal <sid0@fb.com>
parents:
17055
diff
changeset
|
446 |
16168
7bbabfe25321
copies: add docstring for mergecopies
Matt Mackall <mpm@selenic.com>
parents:
15994
diff
changeset
|
447 "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
|
448 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
|
449 |
98687cdddcb1
merge: warn about file deleted in one branch and renamed in other (issue3074)
Thomas Arendsen Hein <thomas@intevation.de>
parents:
16792
diff
changeset
|
450 "renamedelete" is a mapping of source name -> list of destination |
98687cdddcb1
merge: warn about file deleted in one branch and renamed in other (issue3074)
Thomas Arendsen Hein <thomas@intevation.de>
parents:
16792
diff
changeset
|
451 names for files deleted in c1 that were renamed in c2 or vice-versa. |
30581
43a9e02a7b7f
graft: support grafting changes to new file in renamed directory (issue5436)
Gábor Stefanik <gabor.stefanik@nng.com>
parents:
30361
diff
changeset
|
452 |
43a9e02a7b7f
graft: support grafting changes to new file in renamed directory (issue5436)
Gábor Stefanik <gabor.stefanik@nng.com>
parents:
30361
diff
changeset
|
453 "dirmove" is a mapping of detected source dir -> destination dir renames. |
43a9e02a7b7f
graft: support grafting changes to new file in renamed directory (issue5436)
Gábor Stefanik <gabor.stefanik@nng.com>
parents:
30361
diff
changeset
|
454 This is needed for handling changes to new files previously grafted into |
43a9e02a7b7f
graft: support grafting changes to new file in renamed directory (issue5436)
Gábor Stefanik <gabor.stefanik@nng.com>
parents:
30361
diff
changeset
|
455 renamed directories. |
42118
967c098eed33
copies: move comment about implementation of mergecopies() to end
Martin von Zweigbergk <martinvonz@google.com>
parents:
42115
diff
changeset
|
456 |
967c098eed33
copies: move comment about implementation of mergecopies() to end
Martin von Zweigbergk <martinvonz@google.com>
parents:
42115
diff
changeset
|
457 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
|
458 """ |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
459 # 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
|
460 if not c1 or not c2 or c1 == c2: |
30581
43a9e02a7b7f
graft: support grafting changes to new file in renamed directory (issue5436)
Gábor Stefanik <gabor.stefanik@nng.com>
parents:
30361
diff
changeset
|
461 return {}, {}, {}, {}, {} |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
462 |
41752
012f695546aa
copies: respect narrowmatcher in "parent -> working dir" case
Martin von Zweigbergk <martinvonz@google.com>
parents:
41724
diff
changeset
|
463 narrowmatch = c1.repo().narrowmatch() |
012f695546aa
copies: respect narrowmatcher in "parent -> working dir" case
Martin von Zweigbergk <martinvonz@google.com>
parents:
41724
diff
changeset
|
464 |
6646
9eb274d773d9
copies: teach copies about dirstate.copies
Matt Mackall <mpm@selenic.com>
parents:
6431
diff
changeset
|
465 # avoid silly behavior for parent -> working dir |
13878
a8d13ee0ce68
misc: replace .parents()[0] with p1()
Matt Mackall <mpm@selenic.com>
parents:
12683
diff
changeset
|
466 if c2.node() is None and c1.node() == repo.dirstate.p1(): |
41752
012f695546aa
copies: respect narrowmatcher in "parent -> working dir" case
Martin von Zweigbergk <martinvonz@google.com>
parents:
41724
diff
changeset
|
467 return _dirstatecopies(repo, narrowmatch), {}, {}, {}, {} |
6646
9eb274d773d9
copies: teach copies about dirstate.copies
Matt Mackall <mpm@selenic.com>
parents:
6431
diff
changeset
|
468 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
469 copytracing = repo.ui.config(b'experimental', b'copytrace') |
42225
d8ca7b99fc51
copies: move check for experimental.copytrace==<falsy> earlier
Martin von Zweigbergk <martinvonz@google.com>
parents:
42224
diff
changeset
|
470 if stringutil.parsebool(copytracing) is False: |
d8ca7b99fc51
copies: move check for experimental.copytrace==<falsy> earlier
Martin von Zweigbergk <martinvonz@google.com>
parents:
42224
diff
changeset
|
471 # 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:
42224
diff
changeset
|
472 # value, so we should rely on making sure copytracing is on such cases |
d8ca7b99fc51
copies: move check for experimental.copytrace==<falsy> earlier
Martin von Zweigbergk <martinvonz@google.com>
parents:
42224
diff
changeset
|
473 return {}, {}, {}, {}, {} |
34078
b4b196092cc3
copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34077
diff
changeset
|
474 |
42226
a6be3af3a397
copies: ignore heuristics copytracing when using changeset-centric algos
Martin von Zweigbergk <martinvonz@google.com>
parents:
42225
diff
changeset
|
475 if usechangesetcentricalgo(repo): |
a6be3af3a397
copies: ignore heuristics copytracing when using changeset-centric algos
Martin von Zweigbergk <martinvonz@google.com>
parents:
42225
diff
changeset
|
476 # 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:
42225
diff
changeset
|
477 return _fullcopytracing(repo, c1, c2, base) |
a6be3af3a397
copies: ignore heuristics copytracing when using changeset-centric algos
Martin von Zweigbergk <martinvonz@google.com>
parents:
42225
diff
changeset
|
478 |
26013
38f92d12357c
copy: add flag for disabling copy tracing
Durham Goode <durham@fb.com>
parents:
25924
diff
changeset
|
479 # 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
|
480 # 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
|
481 # rebase. |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
482 if copytracing == b'heuristics': |
34366
d00910b286cd
copytrace: use ctx.mutable() instead of adhoc constant of non-public phases
Yuya Nishihara <yuya@tcha.org>
parents:
34348
diff
changeset
|
483 # 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:
34348
diff
changeset
|
484 # 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:
34348
diff
changeset
|
485 # be missed by heuristics |
34311
1826d695ad58
copytrace: add a a new config to limit the number of drafts in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34288
diff
changeset
|
486 if _isfullcopytraceable(repo, c1, base): |
34288
fc3b8483c6cb
copytrace: use the full copytracing method if only drafts are involved
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34179
diff
changeset
|
487 return _fullcopytracing(repo, c1, c2, base) |
34179
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
488 return _heuristicscopytracing(repo, c1, c2, base) |
34078
b4b196092cc3
copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34077
diff
changeset
|
489 else: |
b4b196092cc3
copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34077
diff
changeset
|
490 return _fullcopytracing(repo, c1, c2, base) |
26013
38f92d12357c
copy: add flag for disabling copy tracing
Durham Goode <durham@fb.com>
parents:
25924
diff
changeset
|
491 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
492 |
34311
1826d695ad58
copytrace: add a a new config to limit the number of drafts in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34288
diff
changeset
|
493 def _isfullcopytraceable(repo, c1, base): |
34366
d00910b286cd
copytrace: use ctx.mutable() instead of adhoc constant of non-public phases
Yuya Nishihara <yuya@tcha.org>
parents:
34348
diff
changeset
|
494 """ 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:
34348
diff
changeset
|
495 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:
34348
diff
changeset
|
496 since it will be fast enough. |
34516
e79b3611223b
copies: add docs for config `experimental.copytrace.sourcecommitlimit`
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34366
diff
changeset
|
497 |
e79b3611223b
copies: add docs for config `experimental.copytrace.sourcecommitlimit`
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34366
diff
changeset
|
498 `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:
34366
diff
changeset
|
499 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:
34366
diff
changeset
|
500 more than the limit, full copytracing algorithm won't be used. |
34288
fc3b8483c6cb
copytrace: use the full copytracing method if only drafts are involved
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34179
diff
changeset
|
501 """ |
34311
1826d695ad58
copytrace: add a a new config to limit the number of drafts in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34288
diff
changeset
|
502 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:
34288
diff
changeset
|
503 c1 = c1.p1() |
34366
d00910b286cd
copytrace: use ctx.mutable() instead of adhoc constant of non-public phases
Yuya Nishihara <yuya@tcha.org>
parents:
34348
diff
changeset
|
504 if c1.mutable() and base.mutable(): |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
505 sourcecommitlimit = repo.ui.configint( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
506 b'experimental', b'copytrace.sourcecommitlimit' |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
507 ) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
508 commits = len(repo.revs(b'%d::%d', base.rev(), c1.rev())) |
34311
1826d695ad58
copytrace: add a a new config to limit the number of drafts in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34288
diff
changeset
|
509 return commits < sourcecommitlimit |
34288
fc3b8483c6cb
copytrace: use the full copytracing method if only drafts are involved
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34179
diff
changeset
|
510 return False |
fc3b8483c6cb
copytrace: use the full copytracing method if only drafts are involved
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34179
diff
changeset
|
511 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
512 |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
513 def _checksinglesidecopies( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
514 src, dsts1, m1, m2, mb, c2, base, copy, renamedelete |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
515 ): |
42222
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
516 if src not in m2: |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
517 # deleted on side 2 |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
518 if src not in m1: |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
519 # renamed on side 1, deleted on side 2 |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
520 renamedelete[src] = dsts1 |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
521 elif m2[src] != mb[src]: |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
522 if not _related(c2[src], base[src]): |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
523 return |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
524 # modified on side 2 |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
525 for dst in dsts1: |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
526 if dst not in m2: |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
527 # dst not added on side 2 (handle as regular |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
528 # "both created" case in manifestmerge otherwise) |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
529 copy[dst] = src |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
530 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
531 |
34078
b4b196092cc3
copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34077
diff
changeset
|
532 def _fullcopytracing(repo, c1, c2, base): |
b4b196092cc3
copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34077
diff
changeset
|
533 """ 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:
34077
diff
changeset
|
534 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:
34077
diff
changeset
|
535 this file was copied from another file. |
b4b196092cc3
copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34077
diff
changeset
|
536 |
b4b196092cc3
copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34077
diff
changeset
|
537 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:
34077
diff
changeset
|
538 the copies. |
b4b196092cc3
copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34077
diff
changeset
|
539 """ |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
540 m1 = c1.manifest() |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
541 m2 = c2.manifest() |
30186
f7ed5af31242
mergecopies: rename 'ca' to 'base'
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30185
diff
changeset
|
542 mb = base.manifest() |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
543 |
42222
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
544 copies1 = pathcopies(base, c1) |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
545 copies2 = pathcopies(base, c2) |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
546 |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
547 inversecopies1 = {} |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
548 inversecopies2 = {} |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
549 for dst, src in copies1.items(): |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
550 inversecopies1.setdefault(src, []).append(dst) |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
551 for dst, src in copies2.items(): |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
552 inversecopies2.setdefault(src, []).append(dst) |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
553 |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
554 copy = {} |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
555 diverge = {} |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
556 renamedelete = {} |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
557 allsources = set(inversecopies1) | set(inversecopies2) |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
558 for src in allsources: |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
559 dsts1 = inversecopies1.get(src) |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
560 dsts2 = inversecopies2.get(src) |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
561 if dsts1 and dsts2: |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
562 # copied/renamed on both sides |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
563 if src not in m1 and src not in m2: |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
564 # renamed on both sides |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
565 dsts1 = set(dsts1) |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
566 dsts2 = set(dsts2) |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
567 # If there's some overlap in the rename destinations, we |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
568 # 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:
42210
diff
changeset
|
569 # 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:
42210
diff
changeset
|
570 # and 'd' and deletes 'a'. |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
571 if dsts1 & dsts2: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
572 for dst in dsts1 & dsts2: |
42222
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
573 copy[dst] = src |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
574 else: |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
575 diverge[src] = sorted(dsts1 | dsts2) |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
576 elif src in m1 and src in m2: |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
577 # copied on both sides |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
578 dsts1 = set(dsts1) |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
579 dsts2 = set(dsts2) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
580 for dst in dsts1 & dsts2: |
42222
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
581 copy[dst] = src |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
582 # 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:
42210
diff
changeset
|
583 # on the other side |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
584 elif dsts1: |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
585 # copied/renamed only on side 1 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
586 _checksinglesidecopies( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
587 src, dsts1, m1, m2, mb, c2, base, copy, renamedelete |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
588 ) |
42222
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
589 elif dsts2: |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
590 # copied/renamed only on side 2 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
591 _checksinglesidecopies( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
592 src, dsts2, m2, m1, mb, c1, base, copy, renamedelete |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
593 ) |
42222
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
594 |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
595 renamedeleteset = set() |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
596 divergeset = set() |
42224
a20d7c6abff2
copies: replace .items() by .values() where appropriate
Martin von Zweigbergk <martinvonz@google.com>
parents:
42223
diff
changeset
|
597 for dsts in diverge.values(): |
42222
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
598 divergeset.update(dsts) |
42224
a20d7c6abff2
copies: replace .items() by .values() where appropriate
Martin von Zweigbergk <martinvonz@google.com>
parents:
42223
diff
changeset
|
599 for dsts in renamedelete.values(): |
42222
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
600 renamedeleteset.update(dsts) |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
601 |
26659
df66736a128e
copies: group bothnew with other sets
Matt Mackall <mpm@selenic.com>
parents:
26658
diff
changeset
|
602 # find interesting file sets from manifests |
39966
707c3804e607
narrow: move copies overrides to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
39945
diff
changeset
|
603 addedinm1 = m1.filesnotin(mb, repo.narrowmatch()) |
707c3804e607
narrow: move copies overrides to core
Martin von Zweigbergk <martinvonz@google.com>
parents:
39945
diff
changeset
|
604 addedinm2 = m2.filesnotin(mb, repo.narrowmatch()) |
42223
d69bc8ffbe6f
copies: inline _computenonoverlap() in mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42222
diff
changeset
|
605 u1 = sorted(addedinm1 - addedinm2) |
d69bc8ffbe6f
copies: inline _computenonoverlap() in mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42222
diff
changeset
|
606 u2 = sorted(addedinm2 - addedinm1) |
d69bc8ffbe6f
copies: inline _computenonoverlap() in mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42222
diff
changeset
|
607 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
608 header = b" unmatched files in %s" |
42223
d69bc8ffbe6f
copies: inline _computenonoverlap() in mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42222
diff
changeset
|
609 if u1: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
610 repo.ui.debug(b"%s:\n %s\n" % (header % b'local', b"\n ".join(u1))) |
42223
d69bc8ffbe6f
copies: inline _computenonoverlap() in mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42222
diff
changeset
|
611 if u2: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
612 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
|
613 |
42222
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
614 fullcopy = copies1.copy() |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
615 fullcopy.update(copies2) |
42166
85f5934016f9
copies: move early return for "no copies" case a little earlier
Martin von Zweigbergk <martinvonz@google.com>
parents:
42165
diff
changeset
|
616 if not fullcopy: |
85f5934016f9
copies: move early return for "no copies" case a little earlier
Martin von Zweigbergk <martinvonz@google.com>
parents:
42165
diff
changeset
|
617 return copy, {}, diverge, renamedelete, {} |
85f5934016f9
copies: move early return for "no copies" case a little earlier
Martin von Zweigbergk <martinvonz@google.com>
parents:
42165
diff
changeset
|
618 |
85f5934016f9
copies: move early return for "no copies" case a little earlier
Martin von Zweigbergk <martinvonz@google.com>
parents:
42165
diff
changeset
|
619 if repo.ui.debugflag: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
620 repo.ui.debug( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
621 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
|
622 b"% = renamed and deleted):\n" |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
623 ) |
18362
5a4f220fbfca
copies: report found copies sorted
Mads Kiilerich <mads@kiilerich.com>
parents:
18355
diff
changeset
|
624 for f in sorted(fullcopy): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
625 note = b"" |
10282
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10263
diff
changeset
|
626 if f in copy: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
627 note += b"*" |
26317
07ac78ba2e37
copies: rename diverge2 to divergeset for clarity
Matt Mackall <mpm@selenic.com>
parents:
26316
diff
changeset
|
628 if f in divergeset: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
629 note += b"!" |
26658
aabfa0fb7e3e
copies: rename renamedelete to renamedeleteset for clarity
Matt Mackall <mpm@selenic.com>
parents:
26657
diff
changeset
|
630 if f in renamedeleteset: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
631 note += b"%" |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
632 repo.ui.debug( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
633 b" src: '%s' -> dst: '%s' %s\n" % (fullcopy[f], f, note) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
634 ) |
26317
07ac78ba2e37
copies: rename diverge2 to divergeset for clarity
Matt Mackall <mpm@selenic.com>
parents:
26316
diff
changeset
|
635 del divergeset |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
636 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
637 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
|
638 |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
639 # generate a directory move map |
16178
828fe2ca7cbb
copies: use ctx.dirs() for directory rename detection
Matt Mackall <mpm@selenic.com>
parents:
16177
diff
changeset
|
640 d1, d2 = c1.dirs(), c2.dirs() |
17055
8b7cd9a998f0
copies: re-include root directory in directory rename detection (issue3511)
Matt Mackall <mpm@selenic.com>
parents:
16795
diff
changeset
|
641 invalid = set() |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
642 dirmove = {} |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
643 |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
644 # 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
|
645 # 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
|
646 for dst, src in pycompat.iteritems(fullcopy): |
25282
0f28815ef066
copies: switch to using pathutil.dirname
Durham Goode <durham@fb.com>
parents:
24782
diff
changeset
|
647 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
|
648 if dsrc in invalid: |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
649 # already seen to be uninteresting |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
650 continue |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
651 elif dsrc in d1 and ddst in d1: |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
652 # directory wasn't entirely moved locally |
39263
eebd591803ab
copies: correctly skip directories that have already been considered
Kyle Lippincott <spectral@google.com>
parents:
38670
diff
changeset
|
653 invalid.add(dsrc) |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
654 elif dsrc in d2 and ddst in d2: |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
655 # directory wasn't entirely moved remotely |
39263
eebd591803ab
copies: correctly skip directories that have already been considered
Kyle Lippincott <spectral@google.com>
parents:
38670
diff
changeset
|
656 invalid.add(dsrc) |
eebd591803ab
copies: correctly skip directories that have already been considered
Kyle Lippincott <spectral@google.com>
parents:
38670
diff
changeset
|
657 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
|
658 # files from the same directory moved to two different places |
39263
eebd591803ab
copies: correctly skip directories that have already been considered
Kyle Lippincott <spectral@google.com>
parents:
38670
diff
changeset
|
659 invalid.add(dsrc) |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
660 else: |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
661 # looks good so far |
39263
eebd591803ab
copies: correctly skip directories that have already been considered
Kyle Lippincott <spectral@google.com>
parents:
38670
diff
changeset
|
662 dirmove[dsrc] = ddst |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
663 |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
664 for i in invalid: |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
665 if i in dirmove: |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
666 del dirmove[i] |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
667 del d1, d2, invalid |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
668 |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
669 if not dirmove: |
30581
43a9e02a7b7f
graft: support grafting changes to new file in renamed directory (issue5436)
Gábor Stefanik <gabor.stefanik@nng.com>
parents:
30361
diff
changeset
|
670 return copy, {}, diverge, renamedelete, {} |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
671 |
43106
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43077
diff
changeset
|
672 dirmove = {k + b"/": v + b"/" for k, v in pycompat.iteritems(dirmove)} |
39263
eebd591803ab
copies: correctly skip directories that have already been considered
Kyle Lippincott <spectral@google.com>
parents:
38670
diff
changeset
|
673 |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
674 for d in dirmove: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
675 repo.ui.debug( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
676 b" discovered dir src: '%s' -> dst: '%s'\n" % (d, dirmove[d]) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
677 ) |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
678 |
30183
0106f93ca1d5
checkcopies: move 'movewithdir' initialisation right before its usage
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30138
diff
changeset
|
679 movewithdir = {} |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
680 # check unaccounted nonoverlapping files against directory moves |
42222
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
681 for f in u1 + u2: |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
682 if f not in fullcopy: |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
683 for d in dirmove: |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
684 if f.startswith(d): |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
685 # new file added in a directory that was moved, move it |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
686 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
|
687 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
|
688 movewithdir[f] = df |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
689 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
|
690 b" pending file src: '%s' -> dst: '%s'\n" |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
691 % (f, df) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
692 ) |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
693 break |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
694 |
30581
43a9e02a7b7f
graft: support grafting changes to new file in renamed directory (issue5436)
Gábor Stefanik <gabor.stefanik@nng.com>
parents:
30361
diff
changeset
|
695 return copy, movewithdir, diverge, renamedelete, dirmove |
19178
4327687ca757
copies: refactor checkcopies() into a top level method
Durham Goode <durham@fb.com>
parents:
18899
diff
changeset
|
696 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
697 |
34179
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
698 def _heuristicscopytracing(repo, c1, c2, base): |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
699 """ Fast copytracing using filename heuristics |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
700 |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
701 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:
34078
diff
changeset
|
702 |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
703 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:
34078
diff
changeset
|
704 2) Move from one directory to another |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
705 (same filenames but different directory names) |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
706 |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
707 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:
34078
diff
changeset
|
708 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:
34078
diff
changeset
|
709 |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
710 If merge is involved it fallbacks to _fullcopytracing(). |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
711 |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
712 Can be used by setting the following config: |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
713 |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
714 [experimental] |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
715 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
|
716 |
f05a6e015ecc
copies: add a config to limit the number of candidates to check in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34787
diff
changeset
|
717 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
|
718 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
|
719 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
|
720 `experimental.copytrace.movecandidateslimit` which defaults to 100. |
34179
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
721 """ |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
722 |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
723 if c1.rev() is None: |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
724 c1 = c1.p1() |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
725 if c2.rev() is None: |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
726 c2 = c2.p1() |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
727 |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
728 copies = {} |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
729 |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
730 changedfiles = set() |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
731 m1 = c1.manifest() |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
732 if not repo.revs(b'%d::%d', base.rev(), c2.rev()): |
34179
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
733 # If base is not in c2 branch, we switch to fullcopytracing |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
734 repo.ui.debug( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
735 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
|
736 b"an ancestor of c2\n" |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
737 ) |
34179
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
738 return _fullcopytracing(repo, c1, c2, base) |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
739 |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
740 ctx = c2 |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
741 while ctx != base: |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
742 if len(ctx.parents()) == 2: |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
743 # 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
|
744 repo.ui.debug(b"switching to full copytracing because of merges\n") |
34179
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
745 return _fullcopytracing(repo, c1, c2, base) |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
746 changedfiles.update(ctx.files()) |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
747 ctx = ctx.p1() |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
748 |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
749 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
|
750 for dst, src in pycompat.iteritems(cp): |
34179
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
751 if src in m1: |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
752 copies[dst] = src |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
753 |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
754 # 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:
34078
diff
changeset
|
755 # the base and present in the source. |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
756 # 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:
34078
diff
changeset
|
757 # source is important to exclude removed files. |
36346
f62369667a7c
py3: use list comprehensions instead of filter where we need to eagerly filter
Augie Fackler <augie@google.com>
parents:
36117
diff
changeset
|
758 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:
36117
diff
changeset
|
759 missingfiles = [f for f in changedfiles if filt(f)] |
34179
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
760 |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
761 if missingfiles: |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
762 basenametofilename = collections.defaultdict(list) |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
763 dirnametofilename = collections.defaultdict(list) |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
764 |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
765 for f in m1.filesnotin(base.manifest()): |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
766 basename = os.path.basename(f) |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
767 dirname = os.path.dirname(f) |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
768 basenametofilename[basename].append(f) |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
769 dirnametofilename[dirname].append(f) |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
770 |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
771 for f in missingfiles: |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
772 basename = os.path.basename(f) |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
773 dirname = os.path.dirname(f) |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
774 samebasename = basenametofilename[basename] |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
775 samedirname = dirnametofilename[dirname] |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
776 movecandidates = samebasename + samedirname |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
777 # 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:
34078
diff
changeset
|
778 # c2.filectx(f) won't fail |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
779 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
|
780 # 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
|
781 # config value to limit the number of candidates moves to check |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
782 maxcandidates = repo.ui.configint( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
783 b'experimental', b'copytrace.movecandidateslimit' |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
784 ) |
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
|
785 |
f05a6e015ecc
copies: add a config to limit the number of candidates to check in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34787
diff
changeset
|
786 if len(movecandidates) > maxcandidates: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
787 repo.ui.status( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
788 _( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
789 b"skipping copytracing for '%s', more " |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
790 b"candidates than the limit: %d\n" |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
791 ) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
792 % (f, len(movecandidates)) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
793 ) |
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
|
794 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
|
795 |
34179
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
796 for candidate in movecandidates: |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
797 f1 = c1.filectx(candidate) |
37392
a4f02a17420d
copies: clean up _related logic
Gábor Stefanik <gabor.stefanik@nng.com>
parents:
36346
diff
changeset
|
798 if _related(f1, f2): |
34179
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
799 # 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:
34078
diff
changeset
|
800 # changes into all of them. This matches the behaviour |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
801 # of upstream copytracing |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
802 copies[candidate] = f |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
803 |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
804 return copies, {}, {}, {}, {} |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
805 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
806 |
37392
a4f02a17420d
copies: clean up _related logic
Gábor Stefanik <gabor.stefanik@nng.com>
parents:
36346
diff
changeset
|
807 def _related(f1, f2): |
30138
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
808 """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
|
809 |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
810 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
|
811 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
|
812 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
|
813 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
|
814 """ |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
815 |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
816 if f1 == f2: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
817 return True # a match |
30138
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
818 |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
819 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
|
820 try: |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
821 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
|
822 |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
823 if f1r is None: |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
824 f1 = next(g1) |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
825 if f2r is None: |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
826 f2 = next(g2) |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
827 |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
828 while True: |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
829 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
|
830 if f1r > f2r: |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
831 f1 = next(g1) |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
832 elif f2r > f1r: |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
833 f2 = next(g2) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
834 else: # f1 and f2 point to files in the same linkrev |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
835 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
|
836 except StopIteration: |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
837 return False |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
838 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
839 |
34787
754b5117622f
context: add workingfilectx.markcopied
Phil Cohen <phillco@fb.com>
parents:
34516
diff
changeset
|
840 def duplicatecopies(repo, wctx, rev, fromrev, skiprev=None): |
35421
9cf37d111acb
copies: consistently use """ for docstrings
Martin von Zweigbergk <martinvonz@google.com>
parents:
35420
diff
changeset
|
841 """reproduce copies from fromrev to rev in the dirstate |
22901
722117c8e023
duplicatecopies: move from cmdutil to copies
Matt Mackall <mpm@selenic.com>
parents:
20990
diff
changeset
|
842 |
722117c8e023
duplicatecopies: move from cmdutil to copies
Matt Mackall <mpm@selenic.com>
parents:
20990
diff
changeset
|
843 If skiprev is specified, it's a revision that should be used to |
722117c8e023
duplicatecopies: move from cmdutil to copies
Matt Mackall <mpm@selenic.com>
parents:
20990
diff
changeset
|
844 filter copy records. Any copies that occur between fromrev and |
722117c8e023
duplicatecopies: move from cmdutil to copies
Matt Mackall <mpm@selenic.com>
parents:
20990
diff
changeset
|
845 skiprev will not be duplicated, even if they appear in the set of |
722117c8e023
duplicatecopies: move from cmdutil to copies
Matt Mackall <mpm@selenic.com>
parents:
20990
diff
changeset
|
846 copies between fromrev and rev. |
35421
9cf37d111acb
copies: consistently use """ for docstrings
Martin von Zweigbergk <martinvonz@google.com>
parents:
35420
diff
changeset
|
847 """ |
22901
722117c8e023
duplicatecopies: move from cmdutil to copies
Matt Mackall <mpm@selenic.com>
parents:
20990
diff
changeset
|
848 exclude = {} |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
849 ctraceconfig = repo.ui.config(b'experimental', b'copytrace') |
39366
a41497b5117c
copies: improve logic of deciding copytracing on based of config options
Pulkit Goyal <pulkit@yandex-team.ru>
parents:
39263
diff
changeset
|
850 bctrace = stringutil.parsebool(ctraceconfig) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
851 if skiprev is not None and ( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
852 ctraceconfig == b'heuristics' or bctrace or bctrace is None |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
853 ): |
34077
26531db4647a
copytrace: replace experimental.disablecopytrace config with copytrace (BC)
Pulkit Goyal <7895pulkit@gmail.com>
parents:
33880
diff
changeset
|
854 # copytrace='off' skips this line, but not the entire function because |
26013
38f92d12357c
copy: add flag for disabling copy tracing
Durham Goode <durham@fb.com>
parents:
25924
diff
changeset
|
855 # the line below is O(size of the repo) during a rebase, while the rest |
38f92d12357c
copy: add flag for disabling copy tracing
Durham Goode <durham@fb.com>
parents:
25924
diff
changeset
|
856 # of the function is much faster (and is required for carrying copy |
38f92d12357c
copy: add flag for disabling copy tracing
Durham Goode <durham@fb.com>
parents:
25924
diff
changeset
|
857 # metadata across the rebase anyway). |
22901
722117c8e023
duplicatecopies: move from cmdutil to copies
Matt Mackall <mpm@selenic.com>
parents:
20990
diff
changeset
|
858 exclude = pathcopies(repo[fromrev], repo[skiprev]) |
43106
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43077
diff
changeset
|
859 for dst, src in pycompat.iteritems(pathcopies(repo[fromrev], repo[rev])): |
22901
722117c8e023
duplicatecopies: move from cmdutil to copies
Matt Mackall <mpm@selenic.com>
parents:
20990
diff
changeset
|
860 if dst in exclude: |
722117c8e023
duplicatecopies: move from cmdutil to copies
Matt Mackall <mpm@selenic.com>
parents:
20990
diff
changeset
|
861 continue |
42318
313812cbf4ca
copies: fix duplicatecopies() with overlay context
Martin von Zweigbergk <martinvonz@google.com>
parents:
42259
diff
changeset
|
862 if dst in wctx: |
313812cbf4ca
copies: fix duplicatecopies() with overlay context
Martin von Zweigbergk <martinvonz@google.com>
parents:
42259
diff
changeset
|
863 wctx[dst].markcopied(src) |
42707
3cffc7bbec26
copies: extract an explicit `computechangesetcopie` method from context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42645
diff
changeset
|
864 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
865 |
43147
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
866 def computechangesetfilesadded(ctx): |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
867 """return the list of files added in a changeset |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
868 """ |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
869 added = [] |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
870 for f in ctx.files(): |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
871 if not any(f in p for p in ctx.parents()): |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
872 added.append(f) |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
873 return added |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
874 |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
875 |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
876 def computechangesetfilesremoved(ctx): |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
877 """return the list of files removed in a changeset |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
878 """ |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
879 removed = [] |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
880 for f in ctx.files(): |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
881 if f not in ctx: |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
882 removed.append(f) |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
883 return removed |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
884 |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
885 |
42707
3cffc7bbec26
copies: extract an explicit `computechangesetcopie` method from context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42645
diff
changeset
|
886 def computechangesetcopies(ctx): |
3cffc7bbec26
copies: extract an explicit `computechangesetcopie` method from context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42645
diff
changeset
|
887 """return the copies data for a changeset |
3cffc7bbec26
copies: extract an explicit `computechangesetcopie` method from context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42645
diff
changeset
|
888 |
3cffc7bbec26
copies: extract an explicit `computechangesetcopie` method from context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42645
diff
changeset
|
889 The copies data are returned as a pair of dictionnary (p1copies, p2copies). |
3cffc7bbec26
copies: extract an explicit `computechangesetcopie` method from context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42645
diff
changeset
|
890 |
3cffc7bbec26
copies: extract an explicit `computechangesetcopie` method from context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42645
diff
changeset
|
891 Each dictionnary are in the form: `{newname: oldname}` |
3cffc7bbec26
copies: extract an explicit `computechangesetcopie` method from context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42645
diff
changeset
|
892 """ |
3cffc7bbec26
copies: extract an explicit `computechangesetcopie` method from context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42645
diff
changeset
|
893 p1copies = {} |
3cffc7bbec26
copies: extract an explicit `computechangesetcopie` method from context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42645
diff
changeset
|
894 p2copies = {} |
3cffc7bbec26
copies: extract an explicit `computechangesetcopie` method from context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42645
diff
changeset
|
895 p1 = ctx.p1() |
3cffc7bbec26
copies: extract an explicit `computechangesetcopie` method from context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42645
diff
changeset
|
896 p2 = ctx.p2() |
3cffc7bbec26
copies: extract an explicit `computechangesetcopie` method from context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42645
diff
changeset
|
897 narrowmatch = ctx._repo.narrowmatch() |
3cffc7bbec26
copies: extract an explicit `computechangesetcopie` method from context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42645
diff
changeset
|
898 for dst in ctx.files(): |
3cffc7bbec26
copies: extract an explicit `computechangesetcopie` method from context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42645
diff
changeset
|
899 if not narrowmatch(dst) or dst not in ctx: |
3cffc7bbec26
copies: extract an explicit `computechangesetcopie` method from context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42645
diff
changeset
|
900 continue |
3cffc7bbec26
copies: extract an explicit `computechangesetcopie` method from context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42645
diff
changeset
|
901 copied = ctx[dst].renamed() |
3cffc7bbec26
copies: extract an explicit `computechangesetcopie` method from context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42645
diff
changeset
|
902 if not copied: |
3cffc7bbec26
copies: extract an explicit `computechangesetcopie` method from context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42645
diff
changeset
|
903 continue |
3cffc7bbec26
copies: extract an explicit `computechangesetcopie` method from context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42645
diff
changeset
|
904 src, srcnode = copied |
3cffc7bbec26
copies: extract an explicit `computechangesetcopie` method from context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42645
diff
changeset
|
905 if src in p1 and p1[src].filenode() == srcnode: |
3cffc7bbec26
copies: extract an explicit `computechangesetcopie` method from context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42645
diff
changeset
|
906 p1copies[dst] = src |
3cffc7bbec26
copies: extract an explicit `computechangesetcopie` method from context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42645
diff
changeset
|
907 elif src in p2 and p2[src].filenode() == srcnode: |
3cffc7bbec26
copies: extract an explicit `computechangesetcopie` method from context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42645
diff
changeset
|
908 p2copies[dst] = src |
3cffc7bbec26
copies: extract an explicit `computechangesetcopie` method from context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
42645
diff
changeset
|
909 return p1copies, p2copies |
43147
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
910 |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
911 |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
912 def encodecopies(files, copies): |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
913 items = [] |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
914 for i, dst in enumerate(files): |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
915 if dst in copies: |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
916 items.append(b'%d\0%s' % (i, copies[dst])) |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
917 if len(items) != len(copies): |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
918 raise error.ProgrammingError( |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
919 b'some copy targets missing from file list' |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
920 ) |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
921 return b"\n".join(items) |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
922 |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
923 |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
924 def decodecopies(files, data): |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
925 try: |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
926 copies = {} |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
927 if not data: |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
928 return copies |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
929 for l in data.split(b'\n'): |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
930 strindex, src = l.split(b'\0') |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
931 i = int(strindex) |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
932 dst = files[i] |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
933 copies[dst] = src |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
934 return copies |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
935 except (ValueError, IndexError): |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
936 # Perhaps someone had chosen the same key name (e.g. "p1copies") and |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
937 # used different syntax for the value. |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
938 return None |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
939 |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
940 |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
941 def encodefileindices(files, subset): |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
942 subset = set(subset) |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
943 indices = [] |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
944 for i, f in enumerate(files): |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
945 if f in subset: |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
946 indices.append(b'%d' % i) |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
947 return b'\n'.join(indices) |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
948 |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
949 |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
950 def decodefileindices(files, data): |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
951 try: |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
952 subset = [] |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
953 if not data: |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
954 return subset |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
955 for strindex in data.split(b'\n'): |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
956 i = int(strindex) |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
957 if i < 0 or i >= len(files): |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
958 return None |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
959 subset.append(files[i]) |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
960 return subset |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
961 except (ValueError, IndexError): |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
962 # Perhaps someone had chosen the same key name (e.g. "added") and |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
963 # used different syntax for the value. |
54e943b28101
sidedatacopies: move various copies related function to the copies modules
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43146
diff
changeset
|
964 return None |
43148
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
965 |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
966 |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
967 def _getsidedata(srcrepo, rev): |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
968 ctx = srcrepo[rev] |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
969 filescopies = computechangesetcopies(ctx) |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
970 filesadded = computechangesetfilesadded(ctx) |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
971 filesremoved = computechangesetfilesremoved(ctx) |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
972 sidedata = {} |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
973 if any([filescopies, filesadded, filesremoved]): |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
974 sortedfiles = sorted(ctx.files()) |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
975 p1copies, p2copies = filescopies |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
976 p1copies = encodecopies(sortedfiles, p1copies) |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
977 p2copies = encodecopies(sortedfiles, p2copies) |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
978 filesadded = encodefileindices(sortedfiles, filesadded) |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
979 filesremoved = encodefileindices(sortedfiles, filesremoved) |
43231
30570a056fa8
sidedatacopies: only store an entry if it has values
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43199
diff
changeset
|
980 if p1copies: |
30570a056fa8
sidedatacopies: only store an entry if it has values
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43199
diff
changeset
|
981 sidedata[sidedatamod.SD_P1COPIES] = p1copies |
30570a056fa8
sidedatacopies: only store an entry if it has values
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43199
diff
changeset
|
982 if p2copies: |
30570a056fa8
sidedatacopies: only store an entry if it has values
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43199
diff
changeset
|
983 sidedata[sidedatamod.SD_P2COPIES] = p2copies |
30570a056fa8
sidedatacopies: only store an entry if it has values
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43199
diff
changeset
|
984 if filesadded: |
30570a056fa8
sidedatacopies: only store an entry if it has values
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43199
diff
changeset
|
985 sidedata[sidedatamod.SD_FILESADDED] = filesadded |
30570a056fa8
sidedatacopies: only store an entry if it has values
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43199
diff
changeset
|
986 if filesremoved: |
30570a056fa8
sidedatacopies: only store an entry if it has values
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43199
diff
changeset
|
987 sidedata[sidedatamod.SD_FILESREMOVED] = filesremoved |
43148
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
988 return sidedata |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
989 |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
990 |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
991 def getsidedataadder(srcrepo, destrepo): |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
992 def sidedatacompanion(revlog, rev): |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
993 sidedata = {} |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
994 if util.safehasattr(revlog, 'filteredrevs'): # this is a changelog |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
995 sidedata = _getsidedata(srcrepo, rev) |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
996 return False, (), sidedata |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
997 |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
998 return sidedatacompanion |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
999 |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
1000 |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
1001 def getsidedataremover(srcrepo, destrepo): |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
1002 def sidedatacompanion(revlog, rev): |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
1003 f = () |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
1004 if util.safehasattr(revlog, 'filteredrevs'): # this is a changelog |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
1005 if revlog.flags(rev) & REVIDX_SIDEDATA: |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
1006 f = ( |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
1007 sidedatamod.SD_P1COPIES, |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
1008 sidedatamod.SD_P2COPIES, |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
1009 sidedatamod.SD_FILESADDED, |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
1010 sidedatamod.SD_FILESREMOVED, |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
1011 ) |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
1012 return False, f, {} |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
1013 |
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
1014 return sidedatacompanion |