Mercurial > hg
annotate mercurial/copies.py @ 46149:294d5aca4ff5
copies: iterate over children directly (instead of parents)
Before this change we would gather all parent → child edges and iterate on
all parent, gathering copy information for children and aggregating them from
there.
They are not strict requirement for edges to be processed in that specific
order. We could also simply iterate over all "children" revision and aggregate
data from both parents at the same time. This patch does that.
It make various things simpler:
* since both parents are processed at the same time, we no longer need to
cache data for merge (see next changeset for details),
* we no longer need nested loop to process data,
* we no longer need to store partial merge data for a rev from distinct loop
interaction to another when processing merges,
* we no longer need to build a full parent -> children mapping (we only rely on
a simpler "parent -> number of children" map (for memory efficiency),
* the data access pattern is now simpler (from lower revisions to higher
revisions) and entirely predicable. That predictability open the way to
prefetching and parallel processing.
So that new iterations order requires simpler code and open the way to
interesting optimisation.
The effect on performance is quite good. In the worse case, we don't see any
significant negative impact. And in the best case, the reduction of roundtrip
to Python provide us with a significant speed. Some example below:
Repo Case Source-Rev Dest-Rev # of revisions old time new time Difference Factor time per rev
---------------------------------------------------------------------------------------------------------------------------------------------------------------
mozilla-try x00000_revs_x00000_added_0_copies dc8a3ca7010e d16fde900c9c : 34414 revs, 0.962867 s, 0.502584 s, -0.460283 s, × 0.5220, 14 µs/rev
mozilla-try x0000_revs_xx000_added_x_copies 156f6e2674f2 4d0f2c178e66 : 8598 revs, 0.110717 s, 0.076323 s, -0.034394 s, × 0.6894, 8 µs/rev
# full comparison between the previous changeset and this one
Repo Case Source-Rev Dest-Rev # of revisions old time new time Difference Factor time per rev
---------------------------------------------------------------------------------------------------------------------------------------------------------------
mercurial x_revs_x_added_0_copies ad6b123de1c7 39cfcef4f463 : 1 revs, 0.000048 s, 0.000041 s, -0.000007 s, × 0.8542, 41 µs/rev
mercurial x_revs_x_added_x_copies 2b1c78674230 0c1d10351869 : 6 revs, 0.000153 s, 0.000102 s, -0.000051 s, × 0.6667, 17 µs/rev
mercurial x000_revs_x000_added_x_copies 81f8ff2a9bf2 dd3267698d84 : 1032 revs, 0.004209 s, 0.004254 s, +0.000045 s, × 1.0107, 4 µs/rev
pypy x_revs_x_added_0_copies aed021ee8ae8 099ed31b181b : 9 revs, 0.000203 s, 0.000282 s, +0.000079 s, × 1.3892, 31 µs/rev
pypy x_revs_x000_added_0_copies 4aa4e1f8e19a 359343b9ac0e : 1 revs, 0.000059 s, 0.000048 s, -0.000011 s, × 0.8136, 48 µs/rev
pypy x_revs_x_added_x_copies ac52eb7bbbb0 72e022663155 : 7 revs, 0.000194 s, 0.000211 s, +0.000017 s, × 1.0876, 30 µs/rev
pypy x_revs_x00_added_x_copies c3b14617fbd7 ace7255d9a26 : 1 revs, 0.000380 s, 0.000375 s, -0.000005 s, × 0.9868, 375 µs/rev
pypy x_revs_x000_added_x000_copies df6f7a526b60 a83dc6a2d56f : 6 revs, 0.010588 s, 0.010574 s, -0.000014 s, × 0.9987, 1762 µs/rev
pypy x000_revs_xx00_added_0_copies 89a76aede314 2f22446ff07e : 4785 revs, 0.048961 s, 0.049974 s, +0.001013 s, × 1.0207, 10 µs/rev
pypy x000_revs_x000_added_x_copies 8a3b5bfd266e 2c68e87c3efe : 6780 revs, 0.083612 s, 0.084300 s, +0.000688 s, × 1.0082, 12 µs/rev
pypy x000_revs_x000_added_x000_copies 89a76aede314 7b3dda341c84 : 5441 revs, 0.058579 s, 0.060128 s, +0.001549 s, × 1.0264, 11 µs/rev
pypy x0000_revs_x_added_0_copies d1defd0dc478 c9cb1334cc78 : 43645 revs, 0.736783 s, 0.686542 s, -0.050241 s, × 0.9318, 15 µs/rev
pypy x0000_revs_xx000_added_0_copies bf2c629d0071 4ffed77c095c : 2 revs, 0.022050 s, 0.009277 s, -0.012773 s, × 0.4207, 4638 µs/rev
pypy x0000_revs_xx000_added_x000_copies 08ea3258278e d9fa043f30c0 : 11316 revs, 0.120800 s, 0.114733 s, -0.006067 s, × 0.9498, 10 µs/rev
netbeans x_revs_x_added_0_copies fb0955ffcbcd a01e9239f9e7 : 2 revs, 0.000140 s, 0.000081 s, -0.000059 s, × 0.5786, 40 µs/rev
netbeans x_revs_x000_added_0_copies 6f360122949f 20eb231cc7d0 : 2 revs, 0.000114 s, 0.000107 s, -0.000007 s, × 0.9386, 53 µs/rev
netbeans x_revs_x_added_x_copies 1ada3faf6fb6 5a39d12eecf4 : 3 revs, 0.000224 s, 0.000173 s, -0.000051 s, × 0.7723, 57 µs/rev
netbeans x_revs_x00_added_x_copies 35be93ba1e2c 9eec5e90c05f : 9 revs, 0.000723 s, 0.000698 s, -0.000025 s, × 0.9654, 77 µs/rev
netbeans x000_revs_xx00_added_0_copies eac3045b4fdd 51d4ae7f1290 : 1421 revs, 0.009665 s, 0.009248 s, -0.000417 s, × 0.9569, 6 µs/rev
netbeans x000_revs_x000_added_x_copies e2063d266acd 6081d72689dc : 1533 revs, 0.014820 s, 0.015446 s, +0.000626 s, × 1.0422, 10 µs/rev
netbeans x000_revs_x000_added_x000_copies ff453e9fee32 411350406ec2 : 5750 revs, 0.076049 s, 0.074373 s, -0.001676 s, × 0.9780, 12 µs/rev
netbeans x0000_revs_xx000_added_x000_copies 588c2d1ced70 1aad62e59ddd : 66949 revs, 0.683603 s, 0.639870 s, -0.043733 s, × 0.9360, 9 µs/rev
mozilla-central x_revs_x_added_0_copies 3697f962bb7b 7015fcdd43a2 : 2 revs, 0.000161 s, 0.000088 s, -0.000073 s, × 0.5466, 44 µs/rev
mozilla-central x_revs_x000_added_0_copies dd390860c6c9 40d0c5bed75d : 8 revs, 0.000234 s, 0.000199 s, -0.000035 s, × 0.8504, 24 µs/rev
mozilla-central x_revs_x_added_x_copies 8d198483ae3b 14207ffc2b2f : 9 revs, 0.000247 s, 0.000171 s, -0.000076 s, × 0.6923, 19 µs/rev
mozilla-central x_revs_x00_added_x_copies 98cbc58cc6bc 446a150332c3 : 7 revs, 0.000630 s, 0.000592 s, -0.000038 s, × 0.9397, 84 µs/rev
mozilla-central x_revs_x000_added_x000_copies 3c684b4b8f68 0a5e72d1b479 : 3 revs, 0.003286 s, 0.003151 s, -0.000135 s, × 0.9589, 1050 µs/rev
mozilla-central x_revs_x0000_added_x0000_copies effb563bb7e5 c07a39dc4e80 : 6 revs, 0.062441 s, 0.061612 s, -0.000829 s, × 0.9867, 10268 µs/rev
mozilla-central x000_revs_xx00_added_0_copies 6100d773079a 04a55431795e : 1593 revs, 0.005423 s, 0.005381 s, -0.000042 s, × 0.9923, 3 µs/rev
mozilla-central x000_revs_x000_added_x_copies 9f17a6fc04f9 2d37b966abed : 41 revs, 0.005919 s, 0.003742 s, -0.002177 s, × 0.6322, 91 µs/rev
mozilla-central x000_revs_x000_added_x000_copies 7c97034feb78 4407bd0c6330 : 7839 revs, 0.062597 s, 0.061983 s, -0.000614 s, × 0.9902, 7 µs/rev
mozilla-central x0000_revs_xx000_added_0_copies 9eec5917337d 67118cc6dcad : 615 revs, 0.043551 s, 0.019861 s, -0.023690 s, × 0.4560, 32 µs/rev
mozilla-central x0000_revs_xx000_added_x000_copies f78c615a656c 96a38b690156 : 30263 revs, 0.192475 s, 0.188101 s, -0.004374 s, × 0.9773, 6 µs/rev
mozilla-central x00000_revs_x0000_added_x0000_copies 6832ae71433c 4c222a1d9a00 : 153721 revs, 1.955575 s, 1.806696 s, -0.148879 s, × 0.9239, 11 µs/rev
mozilla-central x00000_revs_x00000_added_x000_copies 76caed42cf7c 1daa622bbe42 : 204976 revs, 2.886501 s, 2.682987 s, -0.203514 s, × 0.9295, 13 µs/rev
mozilla-try x_revs_x_added_0_copies aaf6dde0deb8 9790f499805a : 2 revs, 0.001181 s, 0.000852 s, -0.000329 s, × 0.7214, 426 µs/rev
mozilla-try x_revs_x000_added_0_copies d8d0222927b4 5bb8ce8c7450 : 2 revs, 0.001189 s, 0.000859 s, -0.000330 s, × 0.7225, 429 µs/rev
mozilla-try x_revs_x_added_x_copies 092fcca11bdb 936255a0384a : 4 revs, 0.000563 s, 0.000150 s, -0.000413 s, × 0.2664, 37 µs/rev
mozilla-try x_revs_x00_added_x_copies b53d2fadbdb5 017afae788ec : 2 revs, 0.001548 s, 0.001158 s, -0.000390 s, × 0.7481, 579 µs/rev
mozilla-try x_revs_x000_added_x000_copies 20408ad61ce5 6f0ee96e21ad : 1 revs, 0.027782 s, 0.027240 s, -0.000542 s, × 0.9805, 27240 µs/rev
mozilla-try x_revs_x0000_added_x0000_copies effb563bb7e5 c07a39dc4e80 : 6 revs, 0.062781 s, 0.062824 s, +0.000043 s, × 1.0007, 10470 µs/rev
mozilla-try x000_revs_xx00_added_0_copies 6100d773079a 04a55431795e : 1593 revs, 0.005778 s, 0.005463 s, -0.000315 s, × 0.9455, 3 µs/rev
mozilla-try x000_revs_x000_added_x_copies 9f17a6fc04f9 2d37b966abed : 41 revs, 0.006192 s, 0.004238 s, -0.001954 s, × 0.6844, 103 µs/rev
mozilla-try x000_revs_x000_added_x000_copies 1346fd0130e4 4c65cbdabc1f : 6657 revs, 0.065391 s, 0.064113 s, -0.001278 s, × 0.9805, 9 µs/rev
mozilla-try x0000_revs_x_added_0_copies 63519bfd42ee a36a2a865d92 : 40314 revs, 0.317216 s, 0.294063 s, -0.023153 s, × 0.9270, 7 µs/rev
mozilla-try x0000_revs_x_added_x_copies 9fe69ff0762d bcabf2a78927 : 38690 revs, 0.303119 s, 0.281493 s, -0.021626 s, × 0.9287, 7 µs/rev
mozilla-try x0000_revs_xx000_added_x_copies 156f6e2674f2 4d0f2c178e66 : 8598 revs, 0.110717 s, 0.076323 s, -0.034394 s, × 0.6894, 8 µs/rev
mozilla-try x0000_revs_xx000_added_0_copies 9eec5917337d 67118cc6dcad : 615 revs, 0.045739 s, 0.020390 s, -0.025349 s, × 0.4458, 33 µs/rev
mozilla-try x0000_revs_xx000_added_x000_copies 89294cd501d9 7ccb2fc7ccb5 : 97052 revs, 3.098021 s, 3.023879 s, -0.074142 s, × 0.9761, 31 µs/rev
mozilla-try x0000_revs_x0000_added_x0000_copies e928c65095ed e951f4ad123a : 52031 revs, 0.771480 s, 0.735549 s, -0.035931 s, × 0.9534, 14 µs/rev
mozilla-try x00000_revs_x_added_0_copies 6a320851d377 1ebb79acd503 : 363753 revs, 18.813422 s, 18.568900 s, -0.244522 s, × 0.9870, 51 µs/rev
mozilla-try x00000_revs_x00000_added_0_copies dc8a3ca7010e d16fde900c9c : 34414 revs, 0.962867 s, 0.502584 s, -0.460283 s, × 0.5220, 14 µs/rev
mozilla-try x00000_revs_x_added_x_copies 5173c4b6f97c 95d83ee7242d : 362229 revs, 18.684923 s, 18.356645 s, -0.328278 s, × 0.9824, 50 µs/rev
mozilla-try x00000_revs_x000_added_x_copies 9126823d0e9c ca82787bb23c : 359344 revs, 18.296305 s, 18.250393 s, -0.045912 s, × 0.9975, 50 µs/rev
mozilla-try x00000_revs_x0000_added_x0000_copies 8d3fafa80d4b eb884023b810 : 192665 revs, 3.061887 s, 2.792459 s, -0.269428 s, × 0.9120, 14 µs/rev
mozilla-try x00000_revs_x00000_added_x0000_copies 1b661134e2ca 1ae03d022d6d : 228985 revs, 103.869641 s, 107.697264 s, +3.827623 s, × 1.0369, 470 µs/rev
mozilla-try x00000_revs_x00000_added_x000_copies 9b2a99adc05e 8e29777b48e6 : 382065 revs, 64.262957 s, 63.961040 s, -0.301917 s, × 0.9953, 167 µs/rev
Differential Revision: https://phab.mercurial-scm.org/D9422
author | Pierre-Yves David <pierre-yves.david@octobus.net> |
---|---|
date | Mon, 14 Dec 2020 11:32:24 +0100 |
parents | 70a9eb899637 |
children | a132aa5979ec |
rev | line source |
---|---|
46148
70a9eb899637
copies: document the current algorithm step
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46113
diff
changeset
|
1 # coding: utf8 |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
2 # copies.py - copy detection for Mercurial |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
3 # |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
4 # Copyright 2008 Matt Mackall <mpm@selenic.com> |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
5 # |
8225
46293a0c7e9f
updated license to be explicit about GPL version 2
Martin Geisler <mg@lazybytes.net>
parents:
8209
diff
changeset
|
6 # This software may be used and distributed according to the terms of the |
10263 | 7 # 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
|
8 |
25924
cfc24c22454e
copies: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25289
diff
changeset
|
9 from __future__ import absolute_import |
cfc24c22454e
copies: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25289
diff
changeset
|
10 |
34179
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
11 import collections |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
12 import os |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
13 |
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
|
14 from .i18n import _ |
46113
59fa3890d40a
node: import symbols explicitly
Joerg Sonnenberger <joerg@bec.de>
parents:
46109
diff
changeset
|
15 from .node import ( |
59fa3890d40a
node: import symbols explicitly
Joerg Sonnenberger <joerg@bec.de>
parents:
46109
diff
changeset
|
16 nullid, |
59fa3890d40a
node: import symbols explicitly
Joerg Sonnenberger <joerg@bec.de>
parents:
46109
diff
changeset
|
17 nullrev, |
59fa3890d40a
node: import symbols explicitly
Joerg Sonnenberger <joerg@bec.de>
parents:
46109
diff
changeset
|
18 ) |
43148
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
19 |
25924
cfc24c22454e
copies: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25289
diff
changeset
|
20 from . import ( |
33867
252fb66ee5bb
copies: use intersectmatchers() in non-merge p1 optimization
Yuya Nishihara <yuya@tcha.org>
parents:
33822
diff
changeset
|
21 match as matchmod, |
25924
cfc24c22454e
copies: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25289
diff
changeset
|
22 pathutil, |
45962
a66568f20ddc
copies: use the rust code for `combine_changeset_copies`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45942
diff
changeset
|
23 policy, |
43106
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43077
diff
changeset
|
24 pycompat, |
25924
cfc24c22454e
copies: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25289
diff
changeset
|
25 util, |
cfc24c22454e
copies: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25289
diff
changeset
|
26 ) |
43148
843da18386d5
sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43147
diff
changeset
|
27 |
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 |
46057
e0313b0a6f7e
copies-rust: parse the changed-file sidedata directly in rust
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46036
diff
changeset
|
31 from .revlogutils import ( |
e0313b0a6f7e
copies-rust: parse the changed-file sidedata directly in rust
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46036
diff
changeset
|
32 flagutil, |
e0313b0a6f7e
copies-rust: parse the changed-file sidedata directly in rust
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46036
diff
changeset
|
33 sidedata as sidedatamod, |
e0313b0a6f7e
copies-rust: parse the changed-file sidedata directly in rust
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46036
diff
changeset
|
34 ) |
45672
f877b3628015
copies: return None instead of ChangingFiles when relevant
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45670
diff
changeset
|
35 |
45962
a66568f20ddc
copies: use the rust code for `combine_changeset_copies`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45942
diff
changeset
|
36 rustmod = policy.importrust("copy_tracing") |
a66568f20ddc
copies: use the rust code for `combine_changeset_copies`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45942
diff
changeset
|
37 |
25924
cfc24c22454e
copies: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25289
diff
changeset
|
38 |
42593
11ceb1b8fd74
copies: inline _chainandfilter() to prepare for next patch
Martin von Zweigbergk <martinvonz@google.com>
parents:
42592
diff
changeset
|
39 def _filter(src, dst, t): |
11ceb1b8fd74
copies: inline _chainandfilter() to prepare for next patch
Martin von Zweigbergk <martinvonz@google.com>
parents:
42592
diff
changeset
|
40 """filters out invalid copies after chaining""" |
42227
d1c2688eda80
copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42226
diff
changeset
|
41 |
42593
11ceb1b8fd74
copies: inline _chainandfilter() to prepare for next patch
Martin von Zweigbergk <martinvonz@google.com>
parents:
42592
diff
changeset
|
42 # 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
|
43 # 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
|
44 # 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
|
45 # 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
|
46 # then was renamed between 'mid' and 'dst'. |
d1c2688eda80
copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42226
diff
changeset
|
47 # |
d1c2688eda80
copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42226
diff
changeset
|
48 # case src mid dst result |
d1c2688eda80
copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42226
diff
changeset
|
49 # 1 x y - - |
d1c2688eda80
copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42226
diff
changeset
|
50 # 2 x y y x->y |
d1c2688eda80
copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42226
diff
changeset
|
51 # 3 x y x - |
d1c2688eda80
copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42226
diff
changeset
|
52 # 4 x y z x->z |
d1c2688eda80
copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42226
diff
changeset
|
53 # 5 - x y - |
d1c2688eda80
copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42226
diff
changeset
|
54 # 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
|
55 # |
f3d06d37e194
copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents:
42344
diff
changeset
|
56 # _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
|
57 # 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
|
58 # 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
|
59 # 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
|
60 |
42373
f3d06d37e194
copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents:
42344
diff
changeset
|
61 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
|
62 # 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
|
63 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
|
64 del t[k] |
f3d06d37e194
copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents:
42344
diff
changeset
|
65 # 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
|
66 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
|
67 del t[k] |
f3d06d37e194
copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents:
42344
diff
changeset
|
68 # 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
|
69 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
|
70 del t[k] |
f3d06d37e194
copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents:
42344
diff
changeset
|
71 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
72 |
43784
995066c41bb2
copies: expand `_chain` variable name to make the function easier to read
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43783
diff
changeset
|
73 def _chain(prefix, suffix): |
995066c41bb2
copies: expand `_chain` variable name to make the function easier to read
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43783
diff
changeset
|
74 """chain two sets of copies 'prefix' and 'suffix'""" |
995066c41bb2
copies: expand `_chain` variable name to make the function easier to read
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43783
diff
changeset
|
75 result = prefix.copy() |
995066c41bb2
copies: expand `_chain` variable name to make the function easier to read
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43783
diff
changeset
|
76 for key, value in pycompat.iteritems(suffix): |
995066c41bb2
copies: expand `_chain` variable name to make the function easier to read
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43783
diff
changeset
|
77 result[key] = prefix.get(value, value) |
995066c41bb2
copies: expand `_chain` variable name to make the function easier to read
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43783
diff
changeset
|
78 return result |
15775
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
79 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
80 |
43199
069cbbb53cdf
copies: drop the findlimit logic
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43198
diff
changeset
|
81 def _tracefile(fctx, am, basemf): |
35421
9cf37d111acb
copies: consistently use """ for docstrings
Martin von Zweigbergk <martinvonz@google.com>
parents:
35420
diff
changeset
|
82 """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
|
83 manifest am |
c16fe77e340a
pathcopies: give up any optimization based on `introrev`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43148
diff
changeset
|
84 |
c16fe77e340a
pathcopies: give up any optimization based on `introrev`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43148
diff
changeset
|
85 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
|
86 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
|
87 disabling that feature.""" |
15775
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
88 |
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
89 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
|
90 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
|
91 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
|
92 return path |
42595
819712deac69
copies: follow copies across merge base without source file (issue6163)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42594
diff
changeset
|
93 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
|
94 return path |
15775
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
95 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
96 |
41752
012f695546aa
copies: respect narrowmatcher in "parent -> working dir" case
Martin von Zweigbergk <martinvonz@google.com>
parents:
41724
diff
changeset
|
97 def _dirstatecopies(repo, match=None): |
012f695546aa
copies: respect narrowmatcher in "parent -> working dir" case
Martin von Zweigbergk <martinvonz@google.com>
parents:
41724
diff
changeset
|
98 ds = repo.dirstate |
15775
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
99 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
|
100 for k in list(c): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
101 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
|
102 del c[k] |
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
103 return c |
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
104 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
105 |
24782
4906dc0e038c
copies: add matcher parameter to copy logic
Durham Goode <durham@fb.com>
parents:
24625
diff
changeset
|
106 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
|
107 """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
|
108 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
|
109 files _forwardcopies is about to process. |
d7d08337b3f6
copy: move _forwardcopies file logic to a function
Durham Goode <durham@fb.com>
parents:
24010
diff
changeset
|
110 """ |
24782
4906dc0e038c
copies: add matcher parameter to copy logic
Durham Goode <durham@fb.com>
parents:
24625
diff
changeset
|
111 ma = a.manifest() |
4906dc0e038c
copies: add matcher parameter to copy logic
Durham Goode <durham@fb.com>
parents:
24625
diff
changeset
|
112 mb = b.manifest() |
31256
5a909a8098a1
copies: remove use of manifest.matches
Durham Goode <durham@fb.com>
parents:
30581
diff
changeset
|
113 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
|
114 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
115 |
42115
27475ae67676
copies: extract function for deciding whether to use changeset-centric algos
Martin von Zweigbergk <martinvonz@google.com>
parents:
41936
diff
changeset
|
116 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
|
117 """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
|
118 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
|
119 return True |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
120 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
|
121 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
|
122 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
|
123 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
124 |
42595
819712deac69
copies: follow copies across merge base without source file (issue6163)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42594
diff
changeset
|
125 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
|
126 """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
|
127 # 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
|
128 # 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
|
129 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
|
130 |
42115
27475ae67676
copies: extract function for deciding whether to use changeset-centric algos
Martin von Zweigbergk <martinvonz@google.com>
parents:
41936
diff
changeset
|
131 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
|
132 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
|
133 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
134 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
|
135 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
|
136 if debug: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
137 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
|
138 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
|
139 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
|
140 |
15775
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
141 # find where new files came from |
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
142 # 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
|
143 # 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
|
144 cm = {} |
28000
d4247c306d82
copies: optimize forward copy detection logic for rebases
Durham Goode <durham@fb.com>
parents:
27876
diff
changeset
|
145 |
d4247c306d82
copies: optimize forward copy detection logic for rebases
Durham Goode <durham@fb.com>
parents:
27876
diff
changeset
|
146 # 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
|
147 # 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
|
148 # 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
|
149 # 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
|
150 # 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
|
151 # this comparison. |
d4247c306d82
copies: optimize forward copy detection logic for rebases
Durham Goode <durham@fb.com>
parents:
27876
diff
changeset
|
152 forwardmissingmatch = match |
46113
59fa3890d40a
node: import symbols explicitly
Joerg Sonnenberger <joerg@bec.de>
parents:
46109
diff
changeset
|
153 if b.p1() == a and b.p2().node() == nullid: |
41936
a791623458ef
copies: remove dependency on scmutil by directly using match.exact()
Martin von Zweigbergk <martinvonz@google.com>
parents:
41932
diff
changeset
|
154 filesmatcher = matchmod.exact(b.files()) |
33867
252fb66ee5bb
copies: use intersectmatchers() in non-merge p1 optimization
Yuya Nishihara <yuya@tcha.org>
parents:
33822
diff
changeset
|
155 forwardmissingmatch = matchmod.intersectmatchers(match, filesmatcher) |
28000
d4247c306d82
copies: optimize forward copy detection logic for rebases
Durham Goode <durham@fb.com>
parents:
27876
diff
changeset
|
156 missing = _computeforwardmissing(a, b, match=forwardmissingmatch) |
d4247c306d82
copies: optimize forward copy detection logic for rebases
Durham Goode <durham@fb.com>
parents:
27876
diff
changeset
|
157 |
23980
c1ce5442453f
_adjustlinkrev: reuse ancestors set during rename detection (issue4514)
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23139
diff
changeset
|
158 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
|
159 |
25b2868206e2
copies: add a devel debug mode to trace what copy tracing does
Boris Feld <boris.feld@octobus.net>
parents:
39966
diff
changeset
|
160 if debug: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
161 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
|
162 |
42210
390ec72b8ea4
copies: process files in deterministic order for stable tests
Martin von Zweigbergk <martinvonz@google.com>
parents:
42169
diff
changeset
|
163 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
|
164 if debug: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
165 dbg(b'debug.copies: 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
|
166 fctx = b[f] |
c1ce5442453f
_adjustlinkrev: reuse ancestors set during rename detection (issue4514)
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23139
diff
changeset
|
167 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
|
168 |
40058
cf01616f8d96
copies: add time information to the debug information
Boris Feld <boris.feld@octobus.net>
parents:
40057
diff
changeset
|
169 if debug: |
cf01616f8d96
copies: add time information to the debug information
Boris Feld <boris.feld@octobus.net>
parents:
40057
diff
changeset
|
170 start = util.timer() |
43199
069cbbb53cdf
copies: drop the findlimit logic
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43198
diff
changeset
|
171 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
|
172 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
|
173 if debug: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
174 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
|
175 cm[f] = opath |
40058
cf01616f8d96
copies: add time information to the debug information
Boris Feld <boris.feld@octobus.net>
parents:
40057
diff
changeset
|
176 if debug: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
177 dbg( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
178 b'debug.copies: time: %f seconds\n' |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
179 % (util.timer() - start) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
180 ) |
35422
8801cdcea01f
copies: extract method for getting non-wdir forward copies
Martin von Zweigbergk <martinvonz@google.com>
parents:
35421
diff
changeset
|
181 return cm |
8801cdcea01f
copies: extract method for getting non-wdir forward copies
Martin von Zweigbergk <martinvonz@google.com>
parents:
35421
diff
changeset
|
182 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
183 |
46057
e0313b0a6f7e
copies-rust: parse the changed-file sidedata directly in rust
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46036
diff
changeset
|
184 def _revinfo_getter(repo, match): |
45640
2693659c2b34
copies: directly pass a changes object to the copy tracing code
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45639
diff
changeset
|
185 """returns a function that returns the following data given a <rev>" |
43255
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
186 |
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
187 * 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
|
188 * p2: revision number of first parent |
45640
2693659c2b34
copies: directly pass a changes object to the copy tracing code
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45639
diff
changeset
|
189 * changes: a ChangingFiles object |
43255
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
190 """ |
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
191 cl = repo.changelog |
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
192 parents = cl.parentrevs |
45672
f877b3628015
copies: return None instead of ChangingFiles when relevant
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45670
diff
changeset
|
193 flags = cl.flags |
f877b3628015
copies: return None instead of ChangingFiles when relevant
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45670
diff
changeset
|
194 |
f877b3628015
copies: return None instead of ChangingFiles when relevant
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45670
diff
changeset
|
195 HASCOPIESINFO = flagutil.REVIDX_HASCOPIESINFO |
43255
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
196 |
45638
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
197 changelogrevision = cl.changelogrevision |
43257
675c776fbcd1
sidedatacopies: directly fetch copies information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43256
diff
changeset
|
198 |
45638
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
199 # A small cache to avoid doing the work twice for merges |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
200 # |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
201 # In the vast majority of cases, if we ask information for a revision |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
202 # about 1 parent, we'll later ask it for the other. So it make sense to |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
203 # keep the information around when reaching the first parent of a merge |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
204 # and dropping it after it was provided for the second parents. |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
205 # |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
206 # It exists cases were only one parent of the merge will be walked. It |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
207 # happens when the "destination" the copy tracing is descendant from a |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
208 # new root, not common with the "source". In that case, we will only walk |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
209 # through merge parents that are descendant of changesets common |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
210 # between "source" and "destination". |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
211 # |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
212 # With the current case implementation if such changesets have a copy |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
213 # information, we'll keep them in memory until the end of |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
214 # _changesetforwardcopies. We don't expect the case to be frequent |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
215 # enough to matters. |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
216 # |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
217 # In addition, it would be possible to reach pathological case, were |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
218 # many first parent are met before any second parent is reached. In |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
219 # that case the cache could grow. If this even become an issue one can |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
220 # safely introduce a maximum cache size. This would trade extra CPU/IO |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
221 # time to save memory. |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
222 merge_caches = {} |
43301
90213d027154
sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43300
diff
changeset
|
223 |
46057
e0313b0a6f7e
copies-rust: parse the changed-file sidedata directly in rust
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46036
diff
changeset
|
224 alwaysmatch = match.always() |
e0313b0a6f7e
copies-rust: parse the changed-file sidedata directly in rust
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46036
diff
changeset
|
225 |
e0313b0a6f7e
copies-rust: parse the changed-file sidedata directly in rust
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46036
diff
changeset
|
226 if rustmod is not None and alwaysmatch: |
e0313b0a6f7e
copies-rust: parse the changed-file sidedata directly in rust
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46036
diff
changeset
|
227 |
e0313b0a6f7e
copies-rust: parse the changed-file sidedata directly in rust
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46036
diff
changeset
|
228 def revinfo(rev): |
e0313b0a6f7e
copies-rust: parse the changed-file sidedata directly in rust
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46036
diff
changeset
|
229 p1, p2 = parents(rev) |
e0313b0a6f7e
copies-rust: parse the changed-file sidedata directly in rust
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46036
diff
changeset
|
230 value = None |
e0313b0a6f7e
copies-rust: parse the changed-file sidedata directly in rust
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46036
diff
changeset
|
231 e = merge_caches.pop(rev, None) |
e0313b0a6f7e
copies-rust: parse the changed-file sidedata directly in rust
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46036
diff
changeset
|
232 if e is not None: |
e0313b0a6f7e
copies-rust: parse the changed-file sidedata directly in rust
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46036
diff
changeset
|
233 return e |
e0313b0a6f7e
copies-rust: parse the changed-file sidedata directly in rust
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46036
diff
changeset
|
234 if flags(rev) & HASCOPIESINFO: |
e0313b0a6f7e
copies-rust: parse the changed-file sidedata directly in rust
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46036
diff
changeset
|
235 raw = changelogrevision(rev)._sidedata.get(sidedatamod.SD_FILES) |
e0313b0a6f7e
copies-rust: parse the changed-file sidedata directly in rust
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46036
diff
changeset
|
236 else: |
e0313b0a6f7e
copies-rust: parse the changed-file sidedata directly in rust
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46036
diff
changeset
|
237 raw = None |
e0313b0a6f7e
copies-rust: parse the changed-file sidedata directly in rust
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46036
diff
changeset
|
238 value = (p1, p2, raw) |
46113
59fa3890d40a
node: import symbols explicitly
Joerg Sonnenberger <joerg@bec.de>
parents:
46109
diff
changeset
|
239 if p1 != nullrev and p2 != nullrev: |
46057
e0313b0a6f7e
copies-rust: parse the changed-file sidedata directly in rust
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46036
diff
changeset
|
240 # XXX some case we over cache, IGNORE |
e0313b0a6f7e
copies-rust: parse the changed-file sidedata directly in rust
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46036
diff
changeset
|
241 merge_caches[rev] = value |
e0313b0a6f7e
copies-rust: parse the changed-file sidedata directly in rust
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46036
diff
changeset
|
242 return value |
e0313b0a6f7e
copies-rust: parse the changed-file sidedata directly in rust
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46036
diff
changeset
|
243 |
e0313b0a6f7e
copies-rust: parse the changed-file sidedata directly in rust
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46036
diff
changeset
|
244 else: |
e0313b0a6f7e
copies-rust: parse the changed-file sidedata directly in rust
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46036
diff
changeset
|
245 |
e0313b0a6f7e
copies-rust: parse the changed-file sidedata directly in rust
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46036
diff
changeset
|
246 def revinfo(rev): |
e0313b0a6f7e
copies-rust: parse the changed-file sidedata directly in rust
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46036
diff
changeset
|
247 p1, p2 = parents(rev) |
e0313b0a6f7e
copies-rust: parse the changed-file sidedata directly in rust
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46036
diff
changeset
|
248 value = None |
e0313b0a6f7e
copies-rust: parse the changed-file sidedata directly in rust
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46036
diff
changeset
|
249 e = merge_caches.pop(rev, None) |
e0313b0a6f7e
copies-rust: parse the changed-file sidedata directly in rust
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46036
diff
changeset
|
250 if e is not None: |
e0313b0a6f7e
copies-rust: parse the changed-file sidedata directly in rust
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46036
diff
changeset
|
251 return e |
e0313b0a6f7e
copies-rust: parse the changed-file sidedata directly in rust
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46036
diff
changeset
|
252 changes = None |
e0313b0a6f7e
copies-rust: parse the changed-file sidedata directly in rust
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46036
diff
changeset
|
253 if flags(rev) & HASCOPIESINFO: |
e0313b0a6f7e
copies-rust: parse the changed-file sidedata directly in rust
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46036
diff
changeset
|
254 changes = changelogrevision(rev).changes |
e0313b0a6f7e
copies-rust: parse the changed-file sidedata directly in rust
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46036
diff
changeset
|
255 value = (p1, p2, changes) |
46113
59fa3890d40a
node: import symbols explicitly
Joerg Sonnenberger <joerg@bec.de>
parents:
46109
diff
changeset
|
256 if p1 != nullrev and p2 != nullrev: |
46057
e0313b0a6f7e
copies-rust: parse the changed-file sidedata directly in rust
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46036
diff
changeset
|
257 # XXX some case we over cache, IGNORE |
e0313b0a6f7e
copies-rust: parse the changed-file sidedata directly in rust
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46036
diff
changeset
|
258 merge_caches[rev] = value |
e0313b0a6f7e
copies-rust: parse the changed-file sidedata directly in rust
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46036
diff
changeset
|
259 return value |
43255
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
260 |
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
261 return revinfo |
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
262 |
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
263 |
45892
06b64fabf91c
copies: cache the ancestor checking call when tracing copy
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45798
diff
changeset
|
264 def cached_is_ancestor(is_ancestor): |
06b64fabf91c
copies: cache the ancestor checking call when tracing copy
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45798
diff
changeset
|
265 """return a cached version of is_ancestor""" |
06b64fabf91c
copies: cache the ancestor checking call when tracing copy
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45798
diff
changeset
|
266 cache = {} |
06b64fabf91c
copies: cache the ancestor checking call when tracing copy
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45798
diff
changeset
|
267 |
06b64fabf91c
copies: cache the ancestor checking call when tracing copy
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45798
diff
changeset
|
268 def _is_ancestor(anc, desc): |
06b64fabf91c
copies: cache the ancestor checking call when tracing copy
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45798
diff
changeset
|
269 if anc > desc: |
06b64fabf91c
copies: cache the ancestor checking call when tracing copy
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45798
diff
changeset
|
270 return False |
06b64fabf91c
copies: cache the ancestor checking call when tracing copy
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45798
diff
changeset
|
271 elif anc == desc: |
06b64fabf91c
copies: cache the ancestor checking call when tracing copy
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45798
diff
changeset
|
272 return True |
06b64fabf91c
copies: cache the ancestor checking call when tracing copy
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45798
diff
changeset
|
273 key = (anc, desc) |
06b64fabf91c
copies: cache the ancestor checking call when tracing copy
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45798
diff
changeset
|
274 ret = cache.get(key) |
06b64fabf91c
copies: cache the ancestor checking call when tracing copy
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45798
diff
changeset
|
275 if ret is None: |
06b64fabf91c
copies: cache the ancestor checking call when tracing copy
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45798
diff
changeset
|
276 ret = cache[key] = is_ancestor(anc, desc) |
06b64fabf91c
copies: cache the ancestor checking call when tracing copy
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45798
diff
changeset
|
277 return ret |
06b64fabf91c
copies: cache the ancestor checking call when tracing copy
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45798
diff
changeset
|
278 |
06b64fabf91c
copies: cache the ancestor checking call when tracing copy
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45798
diff
changeset
|
279 return _is_ancestor |
06b64fabf91c
copies: cache the ancestor checking call when tracing copy
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45798
diff
changeset
|
280 |
06b64fabf91c
copies: cache the ancestor checking call when tracing copy
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45798
diff
changeset
|
281 |
41756
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41754
diff
changeset
|
282 def _changesetforwardcopies(a, b, match): |
46113
59fa3890d40a
node: import symbols explicitly
Joerg Sonnenberger <joerg@bec.de>
parents:
46109
diff
changeset
|
283 if a.rev() in (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
|
284 return {} |
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41754
diff
changeset
|
285 |
43256
00de32aa834e
copies: use an unfiltered repository for the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43255
diff
changeset
|
286 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
|
287 children = {} |
43255
b8d60845fa5d
copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43254
diff
changeset
|
288 |
41756
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41754
diff
changeset
|
289 cl = repo.changelog |
45972
8b99c473aae2
copies-rust: move is_ancestor caching within the rust code
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45962
diff
changeset
|
290 isancestor = cl.isancestorrev |
46149
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
291 |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
292 # To track rename from "A" to B, we need to gather all parent → children |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
293 # edges that are contains in `::B` but not in `::A`. |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
294 # |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
295 # |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
296 # To do so, we need to gather all revisions exclusive¹ to "B" (ie¹: `::b - |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
297 # ::a`) and also all the "roots point", ie the parents of the exclusive set |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
298 # that belong to ::a. These are exactly all the revisions needed to express |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
299 # the parent → children we need to combine. |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
300 # |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
301 # [1] actually, we need to gather all the edges within `(::a)::b`, ie: |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
302 # excluding paths that leads to roots that are not ancestors of `a`. We |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
303 # keep this out of the explanation because it is hard enough without this special case.. |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
304 |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
305 parents = cl._uncheckedparentrevs |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
306 graph_roots = (nullrev, nullrev) |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
307 |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
308 ancestors = cl.ancestors([a.rev()], inclusive=True) |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
309 revs = 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
|
310 roots = set() |
46149
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
311 has_graph_roots = False |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
312 |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
313 # iterate over `only(B, A)` |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
314 for r in revs: |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
315 ps = parents(r) |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
316 if ps == graph_roots: |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
317 has_graph_roots = True |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
318 else: |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
319 p1, p2 = ps |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
320 |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
321 # find all the "root points" (see larger comment above) |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
322 if p1 != nullrev and p1 in ancestors: |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
323 roots.add(p1) |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
324 if p2 != nullrev and p2 in ancestors: |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
325 roots.add(p2) |
43299
83bb1e89ab9b
copies: compute the exact set of revision to walk
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43297
diff
changeset
|
326 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
|
327 # 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
|
328 return {} |
46149
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
329 if has_graph_roots: |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
330 # this deal with the special case mentionned in the [1] footnotes. We |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
331 # must filter out revisions that leads to non-common graphroots. |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
332 roots = list(roots) |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
333 m = min(roots) |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
334 h = [b.rev()] |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
335 roots_to_head = cl.reachableroots(m, h, roots, includepath=True) |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
336 roots_to_head = set(roots_to_head) |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
337 revs = [r for r in revs if r in roots_to_head] |
45637
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
338 |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
339 if repo.filecopiesmode == b'changeset-sidedata': |
46149
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
340 # When using side-data, we will process the edges "from" the children. |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
341 # We iterate over the childre, gathering previous collected data for |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
342 # the parents. Do know when the parents data is no longer necessary, we |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
343 # keep a counter of how many children each revision has. |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
344 # |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
345 # An interresting property of `children_count` is that it only contains |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
346 # revision that will be relevant for a edge of the graph. So if a |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
347 # children has parent not in `children_count`, that edges should not be |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
348 # processed. |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
349 children_count = dict((r, 0) for r in roots) |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
350 for r in revs: |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
351 for p in cl.parentrevs(r): |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
352 if p == nullrev: |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
353 continue |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
354 children_count[r] = 0 |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
355 if p in children_count: |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
356 children_count[p] += 1 |
46057
e0313b0a6f7e
copies-rust: parse the changed-file sidedata directly in rust
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46036
diff
changeset
|
357 revinfo = _revinfo_getter(repo, match) |
45637
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
358 return _combine_changeset_copies( |
46149
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
359 revs, children_count, b.rev(), revinfo, match, isancestor |
45637
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
360 ) |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
361 else: |
46149
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
362 # When not using side-data, we will process the edges "from" the parent. |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
363 # so we need a full mapping of the parent -> children relation. |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
364 children = dict((r, []) for r in roots) |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
365 for r in revs: |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
366 for p in cl.parentrevs(r): |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
367 if p == nullrev: |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
368 continue |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
369 children[r] = [] |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
370 if p in children: |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
371 children[p].append(r) |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
372 x = revs.pop() |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
373 assert x == b.rev() |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
374 revs.extend(roots) |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
375 revs.sort() |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
376 |
45638
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
377 revinfo = _revinfo_getter_extra(repo) |
45637
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
378 return _combine_changeset_copies_extra( |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
379 revs, children, b.rev(), revinfo, match, isancestor |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
380 ) |
43786
421ea5772039
copies: split the combination of the copies mapping in its own function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43785
diff
changeset
|
381 |
421ea5772039
copies: split the combination of the copies mapping in its own function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43785
diff
changeset
|
382 |
45624
fb000408bca5
copies: rename some function to the new naming scheme
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44994
diff
changeset
|
383 def _combine_changeset_copies( |
46149
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
384 revs, children_count, targetrev, revinfo, match, isancestor |
44758
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44276
diff
changeset
|
385 ): |
43786
421ea5772039
copies: split the combination of the copies mapping in its own function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43785
diff
changeset
|
386 """combine the copies information for each item of iterrevs |
421ea5772039
copies: split the combination of the copies mapping in its own function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43785
diff
changeset
|
387 |
421ea5772039
copies: split the combination of the copies mapping in its own function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43785
diff
changeset
|
388 revs: sorted iterable of revision to visit |
46149
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
389 children_count: a {parent: <number-of-relevant-children>} mapping. |
43786
421ea5772039
copies: split the combination of the copies mapping in its own function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43785
diff
changeset
|
390 targetrev: the final copies destination revision (not in iterrevs) |
421ea5772039
copies: split the combination of the copies mapping in its own function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43785
diff
changeset
|
391 revinfo(rev): a function that return (p1, p2, p1copies, p2copies, removed) |
421ea5772039
copies: split the combination of the copies mapping in its own function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43785
diff
changeset
|
392 match: a matcher |
421ea5772039
copies: split the combination of the copies mapping in its own function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43785
diff
changeset
|
393 |
421ea5772039
copies: split the combination of the copies mapping in its own function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43785
diff
changeset
|
394 It returns the aggregated copies information for `targetrev`. |
421ea5772039
copies: split the combination of the copies mapping in its own function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43785
diff
changeset
|
395 """ |
45962
a66568f20ddc
copies: use the rust code for `combine_changeset_copies`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45942
diff
changeset
|
396 |
a66568f20ddc
copies: use the rust code for `combine_changeset_copies`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45942
diff
changeset
|
397 alwaysmatch = match.always() |
a66568f20ddc
copies: use the rust code for `combine_changeset_copies`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45942
diff
changeset
|
398 |
a66568f20ddc
copies: use the rust code for `combine_changeset_copies`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45942
diff
changeset
|
399 if rustmod is not None and alwaysmatch: |
a66568f20ddc
copies: use the rust code for `combine_changeset_copies`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45942
diff
changeset
|
400 return rustmod.combine_changeset_copies( |
46149
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
401 list(revs), children_count, targetrev, revinfo, isancestor |
45962
a66568f20ddc
copies: use the rust code for `combine_changeset_copies`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45942
diff
changeset
|
402 ) |
a66568f20ddc
copies: use the rust code for `combine_changeset_copies`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45942
diff
changeset
|
403 |
45972
8b99c473aae2
copies-rust: move is_ancestor caching within the rust code
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45962
diff
changeset
|
404 isancestor = cached_is_ancestor(isancestor) |
8b99c473aae2
copies-rust: move is_ancestor caching within the rust code
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45962
diff
changeset
|
405 |
43785
3b039e43a1e6
copies: do not initialize the dictionary with root in changeset copies
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43784
diff
changeset
|
406 all_copies = {} |
46149
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
407 # iterate over all the "children" side of copy tracing "edge" |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
408 for current_rev in revs: |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
409 p1, p2, changes = revinfo(current_rev) |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
410 current_copies = None |
46148
70a9eb899637
copies: document the current algorithm step
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46113
diff
changeset
|
411 |
46149
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
412 # iterate over all parents to chain the existing data with the |
46148
70a9eb899637
copies: document the current algorithm step
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46113
diff
changeset
|
413 # data from the parent → child edge. |
46149
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
414 for parent, parent_rev in ((1, p1), (2, p2)): |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
415 if parent_rev == nullrev: |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
416 continue |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
417 remaining_children = children_count.get(parent_rev) |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
418 if remaining_children is None: |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
419 continue |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
420 remaining_children -= 1 |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
421 children_count[parent_rev] = remaining_children |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
422 if remaining_children: |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
423 copies = all_copies.get(parent_rev, None) |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
424 else: |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
425 copies = all_copies.pop(parent_rev, None) |
46148
70a9eb899637
copies: document the current algorithm step
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46113
diff
changeset
|
426 |
46149
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
427 if copies is None: |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
428 # this is a root |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
429 copies = {} |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
430 |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
431 newcopies = copies |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
432 # chain the data in the edge with the existing data |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
433 if changes is not None: |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
434 childcopies = {} |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
435 if parent == 1: |
45672
f877b3628015
copies: return None instead of ChangingFiles when relevant
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45670
diff
changeset
|
436 childcopies = changes.copied_from_p1 |
46149
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
437 elif parent == 2: |
45672
f877b3628015
copies: return None instead of ChangingFiles when relevant
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45670
diff
changeset
|
438 childcopies = changes.copied_from_p2 |
46148
70a9eb899637
copies: document the current algorithm step
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46113
diff
changeset
|
439 |
46149
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
440 if not alwaysmatch: |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
441 childcopies = { |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
442 dst: src |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
443 for dst, src in childcopies.items() |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
444 if match(dst) |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
445 } |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
446 if childcopies: |
45985
b6b7626d3e06
copies: avoid unwanted side effect from one branch to another
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45977
diff
changeset
|
447 newcopies = copies.copy() |
46149
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
448 for dest, source in pycompat.iteritems(childcopies): |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
449 prev = copies.get(source) |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
450 if prev is not None and prev[1] is not None: |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
451 source = prev[1] |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
452 newcopies[dest] = (current_rev, source) |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
453 assert newcopies is not copies |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
454 if changes.removed: |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
455 if newcopies is copies: |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
456 newcopies = copies.copy() |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
457 for f in changes.removed: |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
458 if f in newcopies: |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
459 if newcopies is copies: |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
460 # copy on write to avoid affecting potential other |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
461 # branches. when there are no other branches, this |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
462 # could be avoided. |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
463 newcopies = copies.copy() |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
464 newcopies[f] = (current_rev, None) |
46148
70a9eb899637
copies: document the current algorithm step
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46113
diff
changeset
|
465 |
70a9eb899637
copies: document the current algorithm step
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46113
diff
changeset
|
466 # check potential need to combine the data from another parent (for |
70a9eb899637
copies: document the current algorithm step
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46113
diff
changeset
|
467 # that child). See comment below for details. |
46149
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
468 if current_copies is None: |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
469 current_copies = newcopies |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
470 elif current_copies is newcopies: |
45976
cf04af3a5ef1
copies: fast path no-op merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45972
diff
changeset
|
471 # nothing to merge: |
cf04af3a5ef1
copies: fast path no-op merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45972
diff
changeset
|
472 pass |
43252
32187ae9eeb3
copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43231
diff
changeset
|
473 else: |
32187ae9eeb3
copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43231
diff
changeset
|
474 # 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
|
475 # work with the other. |
32187ae9eeb3
copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43231
diff
changeset
|
476 # |
32187ae9eeb3
copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
43231
diff
changeset
|
477 # 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
|
478 # 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
|
479 # 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
|
480 # potential filelog related behavior. |
46149
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
481 assert parent == 2 |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
482 current_copies = _merge_copies_dict( |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
483 newcopies, current_copies, isancestor, changes |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
484 ) |
294d5aca4ff5
copies: iterate over children directly (instead of parents)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46148
diff
changeset
|
485 all_copies[current_rev] = current_copies |
44758
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44276
diff
changeset
|
486 |
46148
70a9eb899637
copies: document the current algorithm step
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46113
diff
changeset
|
487 # filter out internal details and return a {dest: source mapping} |
44758
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44276
diff
changeset
|
488 final_copies = {} |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44276
diff
changeset
|
489 for dest, (tt, source) in all_copies[targetrev].items(): |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44276
diff
changeset
|
490 if source is not None: |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44276
diff
changeset
|
491 final_copies[dest] = source |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44276
diff
changeset
|
492 return final_copies |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44276
diff
changeset
|
493 |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44276
diff
changeset
|
494 |
45640
2693659c2b34
copies: directly pass a changes object to the copy tracing code
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45639
diff
changeset
|
495 def _merge_copies_dict(minor, major, isancestor, changes): |
44758
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44276
diff
changeset
|
496 """merge two copies-mapping together, minor and major |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44276
diff
changeset
|
497 |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44276
diff
changeset
|
498 In case of conflict, value from "major" will be picked. |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44276
diff
changeset
|
499 |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44276
diff
changeset
|
500 - `isancestors(low_rev, high_rev)`: callable return True if `low_rev` is an |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44276
diff
changeset
|
501 ancestors of `high_rev`, |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44276
diff
changeset
|
502 |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44276
diff
changeset
|
503 - `ismerged(path)`: callable return True if `path` have been merged in the |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44276
diff
changeset
|
504 current revision, |
45986
f9f8d8aa9a92
copies: clarify the return of _merge_copies_dict
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45985
diff
changeset
|
505 |
f9f8d8aa9a92
copies: clarify the return of _merge_copies_dict
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45985
diff
changeset
|
506 return the resulting dict (in practice, the "minor" object, updated) |
44758
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44276
diff
changeset
|
507 """ |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44276
diff
changeset
|
508 for dest, value in major.items(): |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44276
diff
changeset
|
509 other = minor.get(dest) |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44276
diff
changeset
|
510 if other is None: |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44276
diff
changeset
|
511 minor[dest] = value |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44276
diff
changeset
|
512 else: |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44276
diff
changeset
|
513 new_tt = value[0] |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44276
diff
changeset
|
514 other_tt = other[0] |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44276
diff
changeset
|
515 if value[1] == other[1]: |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44276
diff
changeset
|
516 continue |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44276
diff
changeset
|
517 # content from "major" wins, unless it is older |
45f3f35cefe7
copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44276
diff
changeset
|
518 # than the branch point or there is a merge |
45670
a8fb29b05f92
salvaged: properly deal with salvaged file during copy tracing
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45640
diff
changeset
|
519 if new_tt == other_tt: |
a8fb29b05f92
salvaged: properly deal with salvaged file during copy tracing
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45640
diff
changeset
|
520 minor[dest] = value |
45672
f877b3628015
copies: return None instead of ChangingFiles when relevant
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45670
diff
changeset
|
521 elif ( |
f877b3628015
copies: return None instead of ChangingFiles when relevant
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45670
diff
changeset
|
522 changes is not None |
f877b3628015
copies: return None instead of ChangingFiles when relevant
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45670
diff
changeset
|
523 and value[1] is None |
f877b3628015
copies: return None instead of ChangingFiles when relevant
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45670
diff
changeset
|
524 and dest in changes.salvaged |
f877b3628015
copies: return None instead of ChangingFiles when relevant
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45670
diff
changeset
|
525 ): |
45670
a8fb29b05f92
salvaged: properly deal with salvaged file during copy tracing
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45640
diff
changeset
|
526 pass |
45672
f877b3628015
copies: return None instead of ChangingFiles when relevant
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45670
diff
changeset
|
527 elif ( |
f877b3628015
copies: return None instead of ChangingFiles when relevant
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45670
diff
changeset
|
528 changes is not None |
f877b3628015
copies: return None instead of ChangingFiles when relevant
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45670
diff
changeset
|
529 and other[1] is None |
f877b3628015
copies: return None instead of ChangingFiles when relevant
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45670
diff
changeset
|
530 and dest in changes.salvaged |
f877b3628015
copies: return None instead of ChangingFiles when relevant
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45670
diff
changeset
|
531 ): |
45670
a8fb29b05f92
salvaged: properly deal with salvaged file during copy tracing
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45640
diff
changeset
|
532 minor[dest] = value |
45673
7990e7d957b0
copies: move `merged` testing sooner
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45672
diff
changeset
|
533 elif changes is not None and dest in changes.merged: |
45670
a8fb29b05f92
salvaged: properly deal with salvaged file during copy tracing
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45640
diff
changeset
|
534 minor[dest] = value |
45673
7990e7d957b0
copies: move `merged` testing sooner
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45672
diff
changeset
|
535 elif not isancestor(new_tt, other_tt): |
45798
ff7e0ca666e8
copies: make sure deleted copy info do not overwriting unrelated ones
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45673
diff
changeset
|
536 if value[1] is not None: |
ff7e0ca666e8
copies: make sure deleted copy info do not overwriting unrelated ones
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45673
diff
changeset
|
537 minor[dest] = value |
ff7e0ca666e8
copies: make sure deleted copy info do not overwriting unrelated ones
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45673
diff
changeset
|
538 elif isancestor(other_tt, new_tt): |
ff7e0ca666e8
copies: make sure deleted copy info do not overwriting unrelated ones
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45673
diff
changeset
|
539 minor[dest] = value |
45986
f9f8d8aa9a92
copies: clarify the return of _merge_copies_dict
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45985
diff
changeset
|
540 return minor |
41756
49ad315b39ee
copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents:
41754
diff
changeset
|
541 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
542 |
45638
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
543 def _revinfo_getter_extra(repo): |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
544 """return a function that return multiple data given a <rev>"i |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
545 |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
546 * p1: revision number of first parent |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
547 * p2: revision number of first parent |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
548 * p1copies: mapping of copies from p1 |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
549 * p2copies: mapping of copies from p2 |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
550 * removed: a list of removed files |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
551 * ismerged: a callback to know if file was merged in that revision |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
552 """ |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
553 cl = repo.changelog |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
554 parents = cl.parentrevs |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
555 |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
556 def get_ismerged(rev): |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
557 ctx = repo[rev] |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
558 |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
559 def ismerged(path): |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
560 if path not in ctx.files(): |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
561 return False |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
562 fctx = ctx[path] |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
563 parents = fctx._filelog.parents(fctx._filenode) |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
564 nb_parents = 0 |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
565 for n in parents: |
46113
59fa3890d40a
node: import symbols explicitly
Joerg Sonnenberger <joerg@bec.de>
parents:
46109
diff
changeset
|
566 if n != nullid: |
45638
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
567 nb_parents += 1 |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
568 return nb_parents >= 2 |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
569 |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
570 return ismerged |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
571 |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
572 def revinfo(rev): |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
573 p1, p2 = parents(rev) |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
574 ctx = repo[rev] |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
575 p1copies, p2copies = ctx._copies |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
576 removed = ctx.filesremoved() |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
577 return p1, p2, p1copies, p2copies, removed, get_ismerged(rev) |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
578 |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
579 return revinfo |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
580 |
4f876e6b30fa
copies: use dedicated `_revinfo_getter` function and call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45637
diff
changeset
|
581 |
45637
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
582 def _combine_changeset_copies_extra( |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
583 revs, children, targetrev, revinfo, match, isancestor |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
584 ): |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
585 """version of `_combine_changeset_copies` that works with the Google |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
586 specific "extra" based storage for copy information""" |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
587 all_copies = {} |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
588 alwaysmatch = match.always() |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
589 for r in revs: |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
590 copies = all_copies.pop(r, None) |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
591 if copies is None: |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
592 # this is a root |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
593 copies = {} |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
594 for i, c in enumerate(children[r]): |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
595 p1, p2, p1copies, p2copies, removed, ismerged = revinfo(c) |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
596 if r == p1: |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
597 parent = 1 |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
598 childcopies = p1copies |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
599 else: |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
600 assert r == p2 |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
601 parent = 2 |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
602 childcopies = p2copies |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
603 if not alwaysmatch: |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
604 childcopies = { |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
605 dst: src for dst, src in childcopies.items() if match(dst) |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
606 } |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
607 newcopies = copies |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
608 if childcopies: |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
609 newcopies = copies.copy() |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
610 for dest, source in pycompat.iteritems(childcopies): |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
611 prev = copies.get(source) |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
612 if prev is not None and prev[1] is not None: |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
613 source = prev[1] |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
614 newcopies[dest] = (c, source) |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
615 assert newcopies is not copies |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
616 for f in removed: |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
617 if f in newcopies: |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
618 if newcopies is copies: |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
619 # copy on write to avoid affecting potential other |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
620 # branches. when there are no other branches, this |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
621 # could be avoided. |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
622 newcopies = copies.copy() |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
623 newcopies[f] = (c, None) |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
624 othercopies = all_copies.get(c) |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
625 if othercopies is None: |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
626 all_copies[c] = newcopies |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
627 else: |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
628 # we are the second parent to work on c, we need to merge our |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
629 # work with the other. |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
630 # |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
631 # In case of conflict, parent 1 take precedence over parent 2. |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
632 # This is an arbitrary choice made anew when implementing |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
633 # changeset based copies. It was made without regards with |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
634 # potential filelog related behavior. |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
635 if parent == 1: |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
636 _merge_copies_dict_extra( |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
637 othercopies, newcopies, isancestor, ismerged |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
638 ) |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
639 else: |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
640 _merge_copies_dict_extra( |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
641 newcopies, othercopies, isancestor, ismerged |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
642 ) |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
643 all_copies[c] = newcopies |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
644 |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
645 final_copies = {} |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
646 for dest, (tt, source) in all_copies[targetrev].items(): |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
647 if source is not None: |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
648 final_copies[dest] = source |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
649 return final_copies |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
650 |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
651 |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
652 def _merge_copies_dict_extra(minor, major, isancestor, ismerged): |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
653 """version of `_merge_copies_dict` that works with the Google |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
654 specific "extra" based storage for copy information""" |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
655 for dest, value in major.items(): |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
656 other = minor.get(dest) |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
657 if other is None: |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
658 minor[dest] = value |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
659 else: |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
660 new_tt = value[0] |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
661 other_tt = other[0] |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
662 if value[1] == other[1]: |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
663 continue |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
664 # content from "major" wins, unless it is older |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
665 # than the branch point or there is a merge |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
666 if ( |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
667 new_tt == other_tt |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
668 or not isancestor(new_tt, other_tt) |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
669 or ismerged(dest) |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
670 ): |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
671 minor[dest] = value |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
672 |
ad6ebb6f0dfe
copies: make two version of the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
45624
diff
changeset
|
673 |
42595
819712deac69
copies: follow copies across merge base without source file (issue6163)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42594
diff
changeset
|
674 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
|
675 """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
|
676 |
42595
819712deac69
copies: follow copies across merge base without source file (issue6163)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42594
diff
changeset
|
677 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
|
678 base = a |
40448
873f3682c8af
narrow: make copies.pathcopies() filter with narrowspec again
Martin von Zweigbergk <martinvonz@google.com>
parents:
40076
diff
changeset
|
679 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
|
680 # check for working copy |
8801cdcea01f
copies: extract method for getting non-wdir forward copies
Martin von Zweigbergk <martinvonz@google.com>
parents:
35421
diff
changeset
|
681 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
|
682 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
|
683 # 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
|
684 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
|
685 else: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
686 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
|
687 return copies |
15775
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
688 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
689 |
41753
3158cb74fbca
copies: make _backwardrenames() filter out copies by destination
Martin von Zweigbergk <martinvonz@google.com>
parents:
41752
diff
changeset
|
690 def _backwardrenames(a, b, match): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
691 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
|
692 return {} |
38f92d12357c
copy: add flag for disabling copy tracing
Durham Goode <durham@fb.com>
parents:
25924
diff
changeset
|
693 |
18136
f23dea2b296e
copies: do not track backward copies, only renames (issue3739)
Siddharth Agarwal <sid0@fb.com>
parents:
18135
diff
changeset
|
694 # 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
|
695 # 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
|
696 # 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
|
697 # 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
|
698 # 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
|
699 # to filter the source instead. |
15775
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
700 f = _forwardcopies(b, a) |
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
701 r = {} |
43106
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43077
diff
changeset
|
702 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
|
703 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
|
704 continue |
18136
f23dea2b296e
copies: do not track backward copies, only renames (issue3739)
Siddharth Agarwal <sid0@fb.com>
parents:
18135
diff
changeset
|
705 # remove copies |
f23dea2b296e
copies: do not track backward copies, only renames (issue3739)
Siddharth Agarwal <sid0@fb.com>
parents:
18135
diff
changeset
|
706 if v in a: |
f23dea2b296e
copies: do not track backward copies, only renames (issue3739)
Siddharth Agarwal <sid0@fb.com>
parents:
18135
diff
changeset
|
707 continue |
15775
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
708 r[v] = k |
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
709 return r |
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
710 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
711 |
24782
4906dc0e038c
copies: add matcher parameter to copy logic
Durham Goode <durham@fb.com>
parents:
24625
diff
changeset
|
712 def pathcopies(x, y, match=None): |
35421
9cf37d111acb
copies: consistently use """ for docstrings
Martin von Zweigbergk <martinvonz@google.com>
parents:
35420
diff
changeset
|
713 """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
|
714 repo = x._repo |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
715 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
|
716 if debug: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
717 repo.ui.debug( |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
718 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
|
719 ) |
15775
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
720 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
|
721 return {} |
44276
30862e226339
copies: avoid filtering by short-circuit dirstate-only copies earlier
Martin von Zweigbergk <martinvonz@google.com>
parents:
44237
diff
changeset
|
722 if y.rev() is None and x == y.p1(): |
30862e226339
copies: avoid filtering by short-circuit dirstate-only copies earlier
Martin von Zweigbergk <martinvonz@google.com>
parents:
44237
diff
changeset
|
723 if debug: |
30862e226339
copies: avoid filtering by short-circuit dirstate-only copies earlier
Martin von Zweigbergk <martinvonz@google.com>
parents:
44237
diff
changeset
|
724 repo.ui.debug(b'debug.copies: search mode: dirstate\n') |
30862e226339
copies: avoid filtering by short-circuit dirstate-only copies earlier
Martin von Zweigbergk <martinvonz@google.com>
parents:
44237
diff
changeset
|
725 # short-circuit to avoid issues with merge states |
30862e226339
copies: avoid filtering by short-circuit dirstate-only copies earlier
Martin von Zweigbergk <martinvonz@google.com>
parents:
44237
diff
changeset
|
726 return _dirstatecopies(repo, match) |
15775
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
727 a = y.ancestor(x) |
91eb4512edd0
copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents:
15774
diff
changeset
|
728 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
|
729 if debug: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
730 repo.ui.debug(b'debug.copies: search mode: forward\n') |
42592
a48f6f18dc6d
copies: remove most early returns from pathcopies() and _forwardcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42591
diff
changeset
|
731 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
|
732 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
|
733 if debug: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
734 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
|
735 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
|
736 else: |
a48f6f18dc6d
copies: remove most early returns from pathcopies() and _forwardcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42591
diff
changeset
|
737 if debug: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
738 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
|
739 base = None |
46113
59fa3890d40a
node: import symbols explicitly
Joerg Sonnenberger <joerg@bec.de>
parents:
46109
diff
changeset
|
740 if a.rev() != nullrev: |
42595
819712deac69
copies: follow copies across merge base without source file (issue6163)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42594
diff
changeset
|
741 base = x |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
742 copies = _chain( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
743 _backwardrenames(x, a, match=match), |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
744 _forwardcopies(a, y, base, match=match), |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
745 ) |
42594
d013099c551b
copies: filter invalid copies only at end of pathcopies() (issue6163)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42593
diff
changeset
|
746 _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
|
747 return copies |
15774
0bd17a4bed88
copies: split the copies api for "normal" and merge cases (API)
Matt Mackall <mpm@selenic.com>
parents:
14494
diff
changeset
|
748 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
749 |
30186
f7ed5af31242
mergecopies: rename 'ca' to 'base'
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30185
diff
changeset
|
750 def mergecopies(repo, c1, c2, base): |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
751 """ |
42118
967c098eed33
copies: move comment about implementation of mergecopies() to end
Martin von Zweigbergk <martinvonz@google.com>
parents:
42115
diff
changeset
|
752 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
|
753 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
|
754 |
b4b196092cc3
copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34077
diff
changeset
|
755 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
|
756 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
|
757 For example: |
33822
42ad7cc645a4
copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32640
diff
changeset
|
758 |
42ad7cc645a4
copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32640
diff
changeset
|
759 o ---> 4 another commit |
42ad7cc645a4
copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32640
diff
changeset
|
760 | |
42ad7cc645a4
copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32640
diff
changeset
|
761 | 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
|
762 | / |
42ad7cc645a4
copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32640
diff
changeset
|
763 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
|
764 |/ |
42ad7cc645a4
copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32640
diff
changeset
|
765 o ---> 1 merge base |
42ad7cc645a4
copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32640
diff
changeset
|
766 |
42ad7cc645a4
copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32640
diff
changeset
|
767 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
|
768 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
|
769 message: |
42ad7cc645a4
copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32640
diff
changeset
|
770 |
42ad7cc645a4
copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents:
32640
diff
changeset
|
771 ```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
|
772 |
44199
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44197
diff
changeset
|
773 Returns a tuple where: |
16168
7bbabfe25321
copies: add docstring for mergecopies
Matt Mackall <mpm@selenic.com>
parents:
15994
diff
changeset
|
774 |
44199
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44197
diff
changeset
|
775 "branch_copies" an instance of branch_copies. |
18134
6c35b53cd28b
copies: separate moves via directory renames from explicit copies
Siddharth Agarwal <sid0@fb.com>
parents:
17055
diff
changeset
|
776 |
16168
7bbabfe25321
copies: add docstring for mergecopies
Matt Mackall <mpm@selenic.com>
parents:
15994
diff
changeset
|
777 "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
|
778 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
|
779 |
42118
967c098eed33
copies: move comment about implementation of mergecopies() to end
Martin von Zweigbergk <martinvonz@google.com>
parents:
42115
diff
changeset
|
780 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
|
781 """ |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
782 # 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
|
783 if not c1 or not c2 or c1 == c2: |
44200
fa9ad1da2e77
merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents:
44199
diff
changeset
|
784 return branch_copies(), branch_copies(), {} |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
785 |
41752
012f695546aa
copies: respect narrowmatcher in "parent -> working dir" case
Martin von Zweigbergk <martinvonz@google.com>
parents:
41724
diff
changeset
|
786 narrowmatch = c1.repo().narrowmatch() |
012f695546aa
copies: respect narrowmatcher in "parent -> working dir" case
Martin von Zweigbergk <martinvonz@google.com>
parents:
41724
diff
changeset
|
787 |
6646
9eb274d773d9
copies: teach copies about dirstate.copies
Matt Mackall <mpm@selenic.com>
parents:
6431
diff
changeset
|
788 # avoid silly behavior for parent -> working dir |
13878
a8d13ee0ce68
misc: replace .parents()[0] with p1()
Matt Mackall <mpm@selenic.com>
parents:
12683
diff
changeset
|
789 if c2.node() is None and c1.node() == repo.dirstate.p1(): |
44200
fa9ad1da2e77
merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents:
44199
diff
changeset
|
790 return ( |
fa9ad1da2e77
merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents:
44199
diff
changeset
|
791 branch_copies(_dirstatecopies(repo, narrowmatch)), |
fa9ad1da2e77
merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents:
44199
diff
changeset
|
792 branch_copies(), |
fa9ad1da2e77
merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents:
44199
diff
changeset
|
793 {}, |
fa9ad1da2e77
merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents:
44199
diff
changeset
|
794 ) |
6646
9eb274d773d9
copies: teach copies about dirstate.copies
Matt Mackall <mpm@selenic.com>
parents:
6431
diff
changeset
|
795 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
796 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
|
797 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
|
798 # 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
|
799 # value, so we should rely on making sure copytracing is on such cases |
44200
fa9ad1da2e77
merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents:
44199
diff
changeset
|
800 return branch_copies(), branch_copies(), {} |
34078
b4b196092cc3
copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34077
diff
changeset
|
801 |
42226
a6be3af3a397
copies: ignore heuristics copytracing when using changeset-centric algos
Martin von Zweigbergk <martinvonz@google.com>
parents:
42225
diff
changeset
|
802 if usechangesetcentricalgo(repo): |
a6be3af3a397
copies: ignore heuristics copytracing when using changeset-centric algos
Martin von Zweigbergk <martinvonz@google.com>
parents:
42225
diff
changeset
|
803 # 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
|
804 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
|
805 |
26013
38f92d12357c
copy: add flag for disabling copy tracing
Durham Goode <durham@fb.com>
parents:
25924
diff
changeset
|
806 # 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
|
807 # 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
|
808 # rebase. |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
809 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
|
810 # 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
|
811 # 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
|
812 # 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
|
813 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
|
814 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
|
815 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
|
816 else: |
b4b196092cc3
copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34077
diff
changeset
|
817 return _fullcopytracing(repo, c1, c2, base) |
26013
38f92d12357c
copy: add flag for disabling copy tracing
Durham Goode <durham@fb.com>
parents:
25924
diff
changeset
|
818 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
819 |
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
|
820 def _isfullcopytraceable(repo, c1, base): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45892
diff
changeset
|
821 """Checks that if base, source and destination are all no-public branches, |
34366
d00910b286cd
copytrace: use ctx.mutable() instead of adhoc constant of non-public phases
Yuya Nishihara <yuya@tcha.org>
parents:
34348
diff
changeset
|
822 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
|
823 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
|
824 |
e79b3611223b
copies: add docs for config `experimental.copytrace.sourcecommitlimit`
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34366
diff
changeset
|
825 `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
|
826 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
|
827 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
|
828 """ |
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
|
829 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
|
830 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
|
831 if c1.mutable() and base.mutable(): |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
832 sourcecommitlimit = repo.ui.configint( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
833 b'experimental', b'copytrace.sourcecommitlimit' |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
834 ) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
835 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
|
836 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
|
837 return False |
fc3b8483c6cb
copytrace: use the full copytracing method if only drafts are involved
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34179
diff
changeset
|
838 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
839 |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
840 def _checksinglesidecopies( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
841 src, dsts1, m1, m2, mb, c2, base, copy, renamedelete |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
842 ): |
42222
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
843 if src not in m2: |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
844 # deleted on side 2 |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
845 if src not in m1: |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
846 # 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
|
847 renamedelete[src] = dsts1 |
44210
d0c3eead515a
copies: fix crash when copy source is not in graft base
Martin von Zweigbergk <martinvonz@google.com>
parents:
44200
diff
changeset
|
848 elif src not in mb: |
d0c3eead515a
copies: fix crash when copy source is not in graft base
Martin von Zweigbergk <martinvonz@google.com>
parents:
44200
diff
changeset
|
849 # Work around the "short-circuit to avoid issues with merge states" |
d0c3eead515a
copies: fix crash when copy source is not in graft base
Martin von Zweigbergk <martinvonz@google.com>
parents:
44200
diff
changeset
|
850 # thing in pathcopies(): pathcopies(x, y) can return a copy where the |
d0c3eead515a
copies: fix crash when copy source is not in graft base
Martin von Zweigbergk <martinvonz@google.com>
parents:
44200
diff
changeset
|
851 # destination doesn't exist in y. |
d0c3eead515a
copies: fix crash when copy source is not in graft base
Martin von Zweigbergk <martinvonz@google.com>
parents:
44200
diff
changeset
|
852 pass |
44909
d452acc8cce8
flags: account for flag change when tracking rename relevant to merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44276
diff
changeset
|
853 elif mb[src] != m2[src] and not _related(c2[src], base[src]): |
d452acc8cce8
flags: account for flag change when tracking rename relevant to merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44276
diff
changeset
|
854 return |
d452acc8cce8
flags: account for flag change when tracking rename relevant to merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44276
diff
changeset
|
855 elif mb[src] != m2[src] or mb.flags(src) != m2.flags(src): |
42222
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
856 # modified on side 2 |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
857 for dst in dsts1: |
44237
b4057d001760
merge: when rename was made on both sides, use ancestor as merge base
Martin von Zweigbergk <martinvonz@google.com>
parents:
44210
diff
changeset
|
858 copy[dst] = src |
42222
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
859 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
860 |
44199
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44197
diff
changeset
|
861 class branch_copies(object): |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44197
diff
changeset
|
862 """Information about copies made on one side of a merge/graft. |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44197
diff
changeset
|
863 |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44197
diff
changeset
|
864 "copy" is a mapping from destination name -> source name, |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44197
diff
changeset
|
865 where source is in c1 and destination is in c2 or vice-versa. |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44197
diff
changeset
|
866 |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44197
diff
changeset
|
867 "movewithdir" is a mapping from source name -> destination name, |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44197
diff
changeset
|
868 where the file at source present in one context but not the other |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44197
diff
changeset
|
869 needs to be moved to destination by the merge process, because the |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44197
diff
changeset
|
870 other context moved the directory it is in. |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44197
diff
changeset
|
871 |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44197
diff
changeset
|
872 "renamedelete" is a mapping of source name -> list of destination |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44197
diff
changeset
|
873 names for files deleted in c1 that were renamed in c2 or vice-versa. |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44197
diff
changeset
|
874 |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44197
diff
changeset
|
875 "dirmove" is a mapping of detected source dir -> destination dir renames. |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44197
diff
changeset
|
876 This is needed for handling changes to new files previously grafted into |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44197
diff
changeset
|
877 renamed directories. |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44197
diff
changeset
|
878 """ |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44197
diff
changeset
|
879 |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44197
diff
changeset
|
880 def __init__( |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44197
diff
changeset
|
881 self, copy=None, renamedelete=None, dirmove=None, movewithdir=None |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44197
diff
changeset
|
882 ): |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44197
diff
changeset
|
883 self.copy = {} if copy is None else copy |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44197
diff
changeset
|
884 self.renamedelete = {} if renamedelete is None else renamedelete |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44197
diff
changeset
|
885 self.dirmove = {} if dirmove is None else dirmove |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44197
diff
changeset
|
886 self.movewithdir = {} if movewithdir is None else movewithdir |
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44197
diff
changeset
|
887 |
44994
cfd06649a1b8
copies: implement __repr__ on branch_copies for debugging
Martin von Zweigbergk <martinvonz@google.com>
parents:
44940
diff
changeset
|
888 def __repr__(self): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45892
diff
changeset
|
889 return '<branch_copies\n copy=%r\n renamedelete=%r\n dirmove=%r\n movewithdir=%r\n>' % ( |
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45892
diff
changeset
|
890 self.copy, |
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45892
diff
changeset
|
891 self.renamedelete, |
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45892
diff
changeset
|
892 self.dirmove, |
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45892
diff
changeset
|
893 self.movewithdir, |
44994
cfd06649a1b8
copies: implement __repr__ on branch_copies for debugging
Martin von Zweigbergk <martinvonz@google.com>
parents:
44940
diff
changeset
|
894 ) |
cfd06649a1b8
copies: implement __repr__ on branch_copies for debugging
Martin von Zweigbergk <martinvonz@google.com>
parents:
44940
diff
changeset
|
895 |
44199
7f8bdee0034e
copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
44197
diff
changeset
|
896 |
34078
b4b196092cc3
copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34077
diff
changeset
|
897 def _fullcopytracing(repo, c1, c2, base): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45892
diff
changeset
|
898 """The full copytracing algorithm which finds all the new files that were |
34078
b4b196092cc3
copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34077
diff
changeset
|
899 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
|
900 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
|
901 |
b4b196092cc3
copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34077
diff
changeset
|
902 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
|
903 the copies. |
b4b196092cc3
copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34077
diff
changeset
|
904 """ |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
905 m1 = c1.manifest() |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
906 m2 = c2.manifest() |
30186
f7ed5af31242
mergecopies: rename 'ca' to 'base'
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30185
diff
changeset
|
907 mb = base.manifest() |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
908 |
42222
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
909 copies1 = pathcopies(base, c1) |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
910 copies2 = pathcopies(base, c2) |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
911 |
44162
baf3fe2977cc
copies: move early return in mergecopies() earlier
Martin von Zweigbergk <martinvonz@google.com>
parents:
44093
diff
changeset
|
912 if not (copies1 or copies2): |
44200
fa9ad1da2e77
merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents:
44199
diff
changeset
|
913 return branch_copies(), branch_copies(), {} |
44162
baf3fe2977cc
copies: move early return in mergecopies() earlier
Martin von Zweigbergk <martinvonz@google.com>
parents:
44093
diff
changeset
|
914 |
42222
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
915 inversecopies1 = {} |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
916 inversecopies2 = {} |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
917 for dst, src in copies1.items(): |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
918 inversecopies1.setdefault(src, []).append(dst) |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
919 for dst, src in copies2.items(): |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
920 inversecopies2.setdefault(src, []).append(dst) |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
921 |
44196
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44164
diff
changeset
|
922 copy1 = {} |
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44164
diff
changeset
|
923 copy2 = {} |
42222
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
924 diverge = {} |
44196
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44164
diff
changeset
|
925 renamedelete1 = {} |
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44164
diff
changeset
|
926 renamedelete2 = {} |
42222
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
927 allsources = set(inversecopies1) | set(inversecopies2) |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
928 for src in allsources: |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
929 dsts1 = inversecopies1.get(src) |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
930 dsts2 = inversecopies2.get(src) |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
931 if dsts1 and dsts2: |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
932 # copied/renamed on both sides |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
933 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
|
934 # renamed on both sides |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
935 dsts1 = set(dsts1) |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
936 dsts2 = set(dsts2) |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
937 # 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
|
938 # 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
|
939 # 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
|
940 # and 'd' and deletes 'a'. |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
941 if dsts1 & dsts2: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
942 for dst in dsts1 & dsts2: |
44196
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44164
diff
changeset
|
943 copy1[dst] = src |
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44164
diff
changeset
|
944 copy2[dst] = src |
42222
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
945 else: |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
946 diverge[src] = sorted(dsts1 | dsts2) |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
947 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
|
948 # copied on both sides |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
949 dsts1 = set(dsts1) |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
950 dsts2 = set(dsts2) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
951 for dst in dsts1 & dsts2: |
44196
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44164
diff
changeset
|
952 copy1[dst] = src |
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44164
diff
changeset
|
953 copy2[dst] = src |
42222
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
954 # 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
|
955 # on the other side |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
956 elif dsts1: |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
957 # copied/renamed only on side 1 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
958 _checksinglesidecopies( |
44196
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44164
diff
changeset
|
959 src, dsts1, m1, m2, mb, c2, base, copy1, renamedelete1 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
960 ) |
42222
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
961 elif dsts2: |
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
962 # copied/renamed only on side 2 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
963 _checksinglesidecopies( |
44196
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44164
diff
changeset
|
964 src, dsts2, m2, m1, mb, c1, base, copy2, renamedelete2 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
965 ) |
42222
57203e0210f8
copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42210
diff
changeset
|
966 |
26659
df66736a128e
copies: group bothnew with other sets
Matt Mackall <mpm@selenic.com>
parents:
26658
diff
changeset
|
967 # find interesting file sets from manifests |
46109
2f357d053df2
copies: make calculating lazy for dir move detection's "addedfiles"
Kyle Lippincott <spectral@google.com>
parents:
46057
diff
changeset
|
968 cache = [] |
2f357d053df2
copies: make calculating lazy for dir move detection's "addedfiles"
Kyle Lippincott <spectral@google.com>
parents:
46057
diff
changeset
|
969 |
2f357d053df2
copies: make calculating lazy for dir move detection's "addedfiles"
Kyle Lippincott <spectral@google.com>
parents:
46057
diff
changeset
|
970 def _get_addedfiles(idx): |
2f357d053df2
copies: make calculating lazy for dir move detection's "addedfiles"
Kyle Lippincott <spectral@google.com>
parents:
46057
diff
changeset
|
971 if not cache: |
2f357d053df2
copies: make calculating lazy for dir move detection's "addedfiles"
Kyle Lippincott <spectral@google.com>
parents:
46057
diff
changeset
|
972 addedinm1 = m1.filesnotin(mb, repo.narrowmatch()) |
2f357d053df2
copies: make calculating lazy for dir move detection's "addedfiles"
Kyle Lippincott <spectral@google.com>
parents:
46057
diff
changeset
|
973 addedinm2 = m2.filesnotin(mb, repo.narrowmatch()) |
2f357d053df2
copies: make calculating lazy for dir move detection's "addedfiles"
Kyle Lippincott <spectral@google.com>
parents:
46057
diff
changeset
|
974 u1 = sorted(addedinm1 - addedinm2) |
2f357d053df2
copies: make calculating lazy for dir move detection's "addedfiles"
Kyle Lippincott <spectral@google.com>
parents:
46057
diff
changeset
|
975 u2 = sorted(addedinm2 - addedinm1) |
2f357d053df2
copies: make calculating lazy for dir move detection's "addedfiles"
Kyle Lippincott <spectral@google.com>
parents:
46057
diff
changeset
|
976 cache.extend((u1, u2)) |
2f357d053df2
copies: make calculating lazy for dir move detection's "addedfiles"
Kyle Lippincott <spectral@google.com>
parents:
46057
diff
changeset
|
977 return cache[idx] |
42223
d69bc8ffbe6f
copies: inline _computenonoverlap() in mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents:
42222
diff
changeset
|
978 |
46109
2f357d053df2
copies: make calculating lazy for dir move detection's "addedfiles"
Kyle Lippincott <spectral@google.com>
parents:
46057
diff
changeset
|
979 u1fn = lambda: _get_addedfiles(0) |
2f357d053df2
copies: make calculating lazy for dir move detection's "addedfiles"
Kyle Lippincott <spectral@google.com>
parents:
46057
diff
changeset
|
980 u2fn = lambda: _get_addedfiles(1) |
2f357d053df2
copies: make calculating lazy for dir move detection's "addedfiles"
Kyle Lippincott <spectral@google.com>
parents:
46057
diff
changeset
|
981 if repo.ui.debugflag: |
2f357d053df2
copies: make calculating lazy for dir move detection's "addedfiles"
Kyle Lippincott <spectral@google.com>
parents:
46057
diff
changeset
|
982 u1 = u1fn() |
2f357d053df2
copies: make calculating lazy for dir move detection's "addedfiles"
Kyle Lippincott <spectral@google.com>
parents:
46057
diff
changeset
|
983 u2 = u2fn() |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
984 |
46109
2f357d053df2
copies: make calculating lazy for dir move detection's "addedfiles"
Kyle Lippincott <spectral@google.com>
parents:
46057
diff
changeset
|
985 header = b" unmatched files in %s" |
2f357d053df2
copies: make calculating lazy for dir move detection's "addedfiles"
Kyle Lippincott <spectral@google.com>
parents:
46057
diff
changeset
|
986 if u1: |
2f357d053df2
copies: make calculating lazy for dir move detection's "addedfiles"
Kyle Lippincott <spectral@google.com>
parents:
46057
diff
changeset
|
987 repo.ui.debug( |
2f357d053df2
copies: make calculating lazy for dir move detection's "addedfiles"
Kyle Lippincott <spectral@google.com>
parents:
46057
diff
changeset
|
988 b"%s:\n %s\n" % (header % b'local', b"\n ".join(u1)) |
2f357d053df2
copies: make calculating lazy for dir move detection's "addedfiles"
Kyle Lippincott <spectral@google.com>
parents:
46057
diff
changeset
|
989 ) |
2f357d053df2
copies: make calculating lazy for dir move detection's "addedfiles"
Kyle Lippincott <spectral@google.com>
parents:
46057
diff
changeset
|
990 if u2: |
2f357d053df2
copies: make calculating lazy for dir move detection's "addedfiles"
Kyle Lippincott <spectral@google.com>
parents:
46057
diff
changeset
|
991 repo.ui.debug( |
2f357d053df2
copies: make calculating lazy for dir move detection's "addedfiles"
Kyle Lippincott <spectral@google.com>
parents:
46057
diff
changeset
|
992 b"%s:\n %s\n" % (header % b'other', b"\n ".join(u2)) |
2f357d053df2
copies: make calculating lazy for dir move detection's "addedfiles"
Kyle Lippincott <spectral@google.com>
parents:
46057
diff
changeset
|
993 ) |
2f357d053df2
copies: make calculating lazy for dir move detection's "addedfiles"
Kyle Lippincott <spectral@google.com>
parents:
46057
diff
changeset
|
994 |
44163
782e0d9c3b74
copies: avoid calculating debug-only stuff without --debug
Martin von Zweigbergk <martinvonz@google.com>
parents:
44162
diff
changeset
|
995 renamedeleteset = set() |
782e0d9c3b74
copies: avoid calculating debug-only stuff without --debug
Martin von Zweigbergk <martinvonz@google.com>
parents:
44162
diff
changeset
|
996 divergeset = set() |
782e0d9c3b74
copies: avoid calculating debug-only stuff without --debug
Martin von Zweigbergk <martinvonz@google.com>
parents:
44162
diff
changeset
|
997 for dsts in diverge.values(): |
782e0d9c3b74
copies: avoid calculating debug-only stuff without --debug
Martin von Zweigbergk <martinvonz@google.com>
parents:
44162
diff
changeset
|
998 divergeset.update(dsts) |
44196
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44164
diff
changeset
|
999 for dsts in renamedelete1.values(): |
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44164
diff
changeset
|
1000 renamedeleteset.update(dsts) |
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44164
diff
changeset
|
1001 for dsts in renamedelete2.values(): |
44163
782e0d9c3b74
copies: avoid calculating debug-only stuff without --debug
Martin von Zweigbergk <martinvonz@google.com>
parents:
44162
diff
changeset
|
1002 renamedeleteset.update(dsts) |
782e0d9c3b74
copies: avoid calculating debug-only stuff without --debug
Martin von Zweigbergk <martinvonz@google.com>
parents:
44162
diff
changeset
|
1003 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
1004 repo.ui.debug( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1005 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
|
1006 b"% = renamed and deleted):\n" |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
1007 ) |
44197
17e12938f8e7
copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents:
44196
diff
changeset
|
1008 for side, copies in ((b"local", copies1), (b"remote", copies2)): |
17e12938f8e7
copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents:
44196
diff
changeset
|
1009 if not copies: |
17e12938f8e7
copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents:
44196
diff
changeset
|
1010 continue |
17e12938f8e7
copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents:
44196
diff
changeset
|
1011 repo.ui.debug(b" on %s side:\n" % side) |
17e12938f8e7
copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents:
44196
diff
changeset
|
1012 for f in sorted(copies): |
17e12938f8e7
copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents:
44196
diff
changeset
|
1013 note = b"" |
17e12938f8e7
copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents:
44196
diff
changeset
|
1014 if f in copy1 or f in copy2: |
17e12938f8e7
copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents:
44196
diff
changeset
|
1015 note += b"*" |
17e12938f8e7
copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents:
44196
diff
changeset
|
1016 if f in divergeset: |
17e12938f8e7
copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents:
44196
diff
changeset
|
1017 note += b"!" |
17e12938f8e7
copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents:
44196
diff
changeset
|
1018 if f in renamedeleteset: |
17e12938f8e7
copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents:
44196
diff
changeset
|
1019 note += b"%" |
17e12938f8e7
copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents:
44196
diff
changeset
|
1020 repo.ui.debug( |
17e12938f8e7
copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents:
44196
diff
changeset
|
1021 b" src: '%s' -> dst: '%s' %s\n" % (copies[f], f, note) |
17e12938f8e7
copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents:
44196
diff
changeset
|
1022 ) |
44163
782e0d9c3b74
copies: avoid calculating debug-only stuff without --debug
Martin von Zweigbergk <martinvonz@google.com>
parents:
44162
diff
changeset
|
1023 del renamedeleteset |
782e0d9c3b74
copies: avoid calculating debug-only stuff without --debug
Martin von Zweigbergk <martinvonz@google.com>
parents:
44162
diff
changeset
|
1024 del divergeset |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
1025 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1026 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
|
1027 |
46109
2f357d053df2
copies: make calculating lazy for dir move detection's "addedfiles"
Kyle Lippincott <spectral@google.com>
parents:
46057
diff
changeset
|
1028 dirmove1, movewithdir2 = _dir_renames(repo, c1, copy1, copies1, u2fn) |
2f357d053df2
copies: make calculating lazy for dir move detection's "addedfiles"
Kyle Lippincott <spectral@google.com>
parents:
46057
diff
changeset
|
1029 dirmove2, movewithdir1 = _dir_renames(repo, c2, copy2, copies2, u1fn) |
44164
45192589555c
copies: extract function for finding directory renames
Martin von Zweigbergk <martinvonz@google.com>
parents:
44163
diff
changeset
|
1030 |
44200
fa9ad1da2e77
merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents:
44199
diff
changeset
|
1031 branch_copies1 = branch_copies(copy1, renamedelete1, dirmove1, movewithdir1) |
fa9ad1da2e77
merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents:
44199
diff
changeset
|
1032 branch_copies2 = branch_copies(copy2, renamedelete2, dirmove2, movewithdir2) |
44196
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44164
diff
changeset
|
1033 |
44200
fa9ad1da2e77
merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents:
44199
diff
changeset
|
1034 return branch_copies1, branch_copies2, diverge |
44164
45192589555c
copies: extract function for finding directory renames
Martin von Zweigbergk <martinvonz@google.com>
parents:
44163
diff
changeset
|
1035 |
45192589555c
copies: extract function for finding directory renames
Martin von Zweigbergk <martinvonz@google.com>
parents:
44163
diff
changeset
|
1036 |
46109
2f357d053df2
copies: make calculating lazy for dir move detection's "addedfiles"
Kyle Lippincott <spectral@google.com>
parents:
46057
diff
changeset
|
1037 def _dir_renames(repo, ctx, copy, fullcopy, addedfilesfn): |
44196
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44164
diff
changeset
|
1038 """Finds moved directories and files that should move with them. |
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44164
diff
changeset
|
1039 |
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44164
diff
changeset
|
1040 ctx: the context for one of the sides |
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44164
diff
changeset
|
1041 copy: files copied on the same side (as ctx) |
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44164
diff
changeset
|
1042 fullcopy: files copied on the same side (as ctx), including those that |
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44164
diff
changeset
|
1043 merge.manifestmerge() won't care about |
46109
2f357d053df2
copies: make calculating lazy for dir move detection's "addedfiles"
Kyle Lippincott <spectral@google.com>
parents:
46057
diff
changeset
|
1044 addedfilesfn: function returning added files on the other side (compared to |
2f357d053df2
copies: make calculating lazy for dir move detection's "addedfiles"
Kyle Lippincott <spectral@google.com>
parents:
46057
diff
changeset
|
1045 ctx) |
44196
6ca9f45b32b0
copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents:
44164
diff
changeset
|
1046 """ |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
1047 # generate a directory move map |
17055
8b7cd9a998f0
copies: re-include root directory in directory rename detection (issue3511)
Matt Mackall <mpm@selenic.com>
parents:
16795
diff
changeset
|
1048 invalid = set() |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
1049 dirmove = {} |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
1050 |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
1051 # 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
|
1052 # 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
|
1053 for dst, src in pycompat.iteritems(fullcopy): |
25282
0f28815ef066
copies: switch to using pathutil.dirname
Durham Goode <durham@fb.com>
parents:
24782
diff
changeset
|
1054 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
|
1055 if dsrc in invalid: |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
1056 # already seen to be uninteresting |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
1057 continue |
46011
b9588ff9b66a
copies: avoid materializing a full directory map during copy tracing
Kyle Lippincott <spectral@google.com>
parents:
45986
diff
changeset
|
1058 elif ctx.hasdir(dsrc) and ctx.hasdir(ddst): |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
1059 # 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
|
1060 invalid.add(dsrc) |
eebd591803ab
copies: correctly skip directories that have already been considered
Kyle Lippincott <spectral@google.com>
parents:
38670
diff
changeset
|
1061 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
|
1062 # 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
|
1063 invalid.add(dsrc) |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
1064 else: |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
1065 # looks good so far |
39263
eebd591803ab
copies: correctly skip directories that have already been considered
Kyle Lippincott <spectral@google.com>
parents:
38670
diff
changeset
|
1066 dirmove[dsrc] = ddst |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
1067 |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
1068 for i in invalid: |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
1069 if i in dirmove: |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
1070 del dirmove[i] |
46011
b9588ff9b66a
copies: avoid materializing a full directory map during copy tracing
Kyle Lippincott <spectral@google.com>
parents:
45986
diff
changeset
|
1071 del invalid |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
1072 |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
1073 if not dirmove: |
44164
45192589555c
copies: extract function for finding directory renames
Martin von Zweigbergk <martinvonz@google.com>
parents:
44163
diff
changeset
|
1074 return {}, {} |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
1075 |
43106
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43077
diff
changeset
|
1076 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
|
1077 |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
1078 for d in dirmove: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
1079 repo.ui.debug( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1080 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
|
1081 ) |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
1082 |
30183
0106f93ca1d5
checkcopies: move 'movewithdir' initialisation right before its usage
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30138
diff
changeset
|
1083 movewithdir = {} |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
1084 # check unaccounted nonoverlapping files against directory moves |
46109
2f357d053df2
copies: make calculating lazy for dir move detection's "addedfiles"
Kyle Lippincott <spectral@google.com>
parents:
46057
diff
changeset
|
1085 for f in addedfilesfn(): |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
1086 if f not in fullcopy: |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
1087 for d in dirmove: |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
1088 if f.startswith(d): |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
1089 # 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
|
1090 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
|
1091 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
|
1092 movewithdir[f] = df |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
1093 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
|
1094 b" pending file src: '%s' -> dst: '%s'\n" |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
1095 % (f, df) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
1096 ) |
6274
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
1097 break |
f3f383efbeae
copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff
changeset
|
1098 |
44164
45192589555c
copies: extract function for finding directory renames
Martin von Zweigbergk <martinvonz@google.com>
parents:
44163
diff
changeset
|
1099 return dirmove, movewithdir |
19178
4327687ca757
copies: refactor checkcopies() into a top level method
Durham Goode <durham@fb.com>
parents:
18899
diff
changeset
|
1100 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
1101 |
34179
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1102 def _heuristicscopytracing(repo, c1, c2, base): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45892
diff
changeset
|
1103 """Fast copytracing using filename heuristics |
34179
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1104 |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1105 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
|
1106 |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1107 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
|
1108 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
|
1109 (same filenames but different directory names) |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1110 |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1111 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
|
1112 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
|
1113 |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1114 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
|
1115 |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1116 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
|
1117 |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1118 [experimental] |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1119 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
|
1120 |
f05a6e015ecc
copies: add a config to limit the number of candidates to check in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34787
diff
changeset
|
1121 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
|
1122 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
|
1123 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
|
1124 `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
|
1125 """ |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1126 |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1127 if c1.rev() is None: |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1128 c1 = c1.p1() |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1129 if c2.rev() is None: |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1130 c2 = c2.p1() |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1131 |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1132 changedfiles = set() |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1133 m1 = c1.manifest() |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1134 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
|
1135 # 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
|
1136 repo.ui.debug( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1137 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
|
1138 b"an ancestor of c2\n" |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
1139 ) |
34179
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1140 return _fullcopytracing(repo, c1, c2, base) |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1141 |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1142 ctx = c2 |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1143 while ctx != base: |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1144 if len(ctx.parents()) == 2: |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1145 # 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
|
1146 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
|
1147 return _fullcopytracing(repo, c1, c2, base) |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1148 changedfiles.update(ctx.files()) |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1149 ctx = ctx.p1() |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1150 |
44200
fa9ad1da2e77
merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents:
44199
diff
changeset
|
1151 copies2 = {} |
34179
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1152 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
|
1153 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
|
1154 if src in m1: |
44200
fa9ad1da2e77
merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents:
44199
diff
changeset
|
1155 copies2[dst] = src |
34179
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1156 |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1157 # 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
|
1158 # 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
|
1159 # 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
|
1160 # 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
|
1161 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
|
1162 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
|
1163 |
44200
fa9ad1da2e77
merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents:
44199
diff
changeset
|
1164 copies1 = {} |
34179
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1165 if missingfiles: |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1166 basenametofilename = collections.defaultdict(list) |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1167 dirnametofilename = collections.defaultdict(list) |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1168 |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1169 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
|
1170 basename = os.path.basename(f) |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1171 dirname = os.path.dirname(f) |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1172 basenametofilename[basename].append(f) |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1173 dirnametofilename[dirname].append(f) |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1174 |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1175 for f in missingfiles: |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1176 basename = os.path.basename(f) |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1177 dirname = os.path.dirname(f) |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1178 samebasename = basenametofilename[basename] |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1179 samedirname = dirnametofilename[dirname] |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1180 movecandidates = samebasename + samedirname |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1181 # 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
|
1182 # c2.filectx(f) won't fail |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1183 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
|
1184 # 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
|
1185 # 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
|
1186 maxcandidates = repo.ui.configint( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1187 b'experimental', b'copytrace.movecandidateslimit' |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
1188 ) |
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
|
1189 |
f05a6e015ecc
copies: add a config to limit the number of candidates to check in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34787
diff
changeset
|
1190 if len(movecandidates) > maxcandidates: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
1191 repo.ui.status( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
1192 _( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1193 b"skipping copytracing for '%s', more " |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1194 b"candidates than the limit: %d\n" |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
1195 ) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
1196 % (f, len(movecandidates)) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
1197 ) |
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
|
1198 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
|
1199 |
34179
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1200 for candidate in movecandidates: |
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1201 f1 = c1.filectx(candidate) |
37392
a4f02a17420d
copies: clean up _related logic
Gábor Stefanik <gabor.stefanik@nng.com>
parents:
36346
diff
changeset
|
1202 if _related(f1, f2): |
34179
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1203 # 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
|
1204 # 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
|
1205 # of upstream copytracing |
44200
fa9ad1da2e77
merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents:
44199
diff
changeset
|
1206 copies1[candidate] = f |
34179
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1207 |
44200
fa9ad1da2e77
merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents:
44199
diff
changeset
|
1208 return branch_copies(copies1), branch_copies(copies2), {} |
34179
036d47d7cf39
copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents:
34078
diff
changeset
|
1209 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
1210 |
37392
a4f02a17420d
copies: clean up _related logic
Gábor Stefanik <gabor.stefanik@nng.com>
parents:
36346
diff
changeset
|
1211 def _related(f1, f2): |
30138
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
1212 """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
|
1213 |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
1214 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
|
1215 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
|
1216 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
|
1217 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
|
1218 """ |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
1219 |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
1220 if f1 == f2: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
1221 return True # a match |
30138
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
1222 |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
1223 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
|
1224 try: |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
1225 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
|
1226 |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
1227 if f1r is None: |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
1228 f1 = next(g1) |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
1229 if f2r is None: |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
1230 f2 = next(g2) |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
1231 |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
1232 while True: |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
1233 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
|
1234 if f1r > f2r: |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
1235 f1 = next(g1) |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
1236 elif f2r > f1r: |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
1237 f2 = next(g2) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
1238 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
|
1239 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
|
1240 except StopIteration: |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
1241 return False |
733fb9f7bc92
checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
30137
diff
changeset
|
1242 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
43020
diff
changeset
|
1243 |
44092
833210fbd900
graftcopies: remove `skip` and `repo` arguments
Martin von Zweigbergk <martinvonz@google.com>
parents:
44091
diff
changeset
|
1244 def graftcopies(wctx, ctx, base): |
44093
06e7e7652ac0
graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents:
44092
diff
changeset
|
1245 """reproduce copies between base and ctx in the wctx |
06e7e7652ac0
graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents:
44092
diff
changeset
|
1246 |
06e7e7652ac0
graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents:
44092
diff
changeset
|
1247 Unlike mergecopies(), this function will only consider copies between base |
06e7e7652ac0
graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents:
44092
diff
changeset
|
1248 and ctx; it will ignore copies between base and wctx. Also unlike |
06e7e7652ac0
graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents:
44092
diff
changeset
|
1249 mergecopies(), this function will apply copies to the working copy (instead |
06e7e7652ac0
graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents:
44092
diff
changeset
|
1250 of just returning information about the copies). That makes it cheaper |
06e7e7652ac0
graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents:
44092
diff
changeset
|
1251 (especially in the common case of base==ctx.p1()) and useful also when |
06e7e7652ac0
graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents:
44092
diff
changeset
|
1252 experimental.copytrace=off. |
06e7e7652ac0
graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents:
44092
diff
changeset
|
1253 |
06e7e7652ac0
graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents:
44092
diff
changeset
|
1254 merge.update() will have already marked most copies, but it will only |
06e7e7652ac0
graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents:
44092
diff
changeset
|
1255 mark copies if it thinks the source files are related (see |
06e7e7652ac0
graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents:
44092
diff
changeset
|
1256 merge._related()). It will also not mark copies if the file wasn't modified |
06e7e7652ac0
graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents:
44092
diff
changeset
|
1257 on the local side. This function adds the copies that were "missed" |
06e7e7652ac0
graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents:
44092
diff
changeset
|
1258 by merge.update(). |
06e7e7652ac0
graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents:
44092
diff
changeset
|
1259 """ |
44091
3df0bd706c40
graftcopies: use _filter() for filtering out invalid copies
Martin von Zweigbergk <martinvonz@google.com>
parents:
44090
diff
changeset
|
1260 new_copies = pathcopies(base, ctx) |
3df0bd706c40
graftcopies: use _filter() for filtering out invalid copies
Martin von Zweigbergk <martinvonz@google.com>
parents:
44090
diff
changeset
|
1261 _filter(wctx.p1(), wctx, new_copies) |
3df0bd706c40
graftcopies: use _filter() for filtering out invalid copies
Martin von Zweigbergk <martinvonz@google.com>
parents:
44090
diff
changeset
|
1262 for dst, src in pycompat.iteritems(new_copies): |
3df0bd706c40
graftcopies: use _filter() for filtering out invalid copies
Martin von Zweigbergk <martinvonz@google.com>
parents:
44090
diff
changeset
|
1263 wctx[dst].markcopied(src) |