Mercurial > hg
annotate mercurial/dirstate.py @ 48140:98b3eb6c1479
dirstate: align the dirstatemap's API to the data change
We are passing different data, so lets simplify the dirstatemap API too.
Differential Revision: https://phab.mercurial-scm.org/D11583
author | Pierre-Yves David <pierre-yves.david@octobus.net> |
---|---|
date | Fri, 01 Oct 2021 01:27:53 +0200 |
parents | 5fc2dfb073d6 |
children | 42ab0bcb6ded |
rev | line source |
---|---|
8226
8b2cd04a6e97
put license and copyright info into comment blocks
Martin Geisler <mg@lazybytes.net>
parents:
8225
diff
changeset
|
1 # dirstate.py - working directory tracking for mercurial |
8b2cd04a6e97
put license and copyright info into comment blocks
Martin Geisler <mg@lazybytes.net>
parents:
8225
diff
changeset
|
2 # |
46819
d4ba4d51f85f
contributor: change mentions of mpm to olivia
Raphaël Gomès <rgomes@octobus.net>
parents:
46794
diff
changeset
|
3 # Copyright 2005-2007 Olivia Mackall <olivia@selenic.com> |
8226
8b2cd04a6e97
put license and copyright info into comment blocks
Martin Geisler <mg@lazybytes.net>
parents:
8225
diff
changeset
|
4 # |
8b2cd04a6e97
put license and copyright info into comment blocks
Martin Geisler <mg@lazybytes.net>
parents:
8225
diff
changeset
|
5 # This software may be used and distributed according to the terms of the |
10263 | 6 # GNU General Public License version 2 or any later version. |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
7 |
27503
0f4596622273
dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27399
diff
changeset
|
8 from __future__ import absolute_import |
0f4596622273
dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27399
diff
changeset
|
9 |
27670
4374f039d269
dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents:
27594
diff
changeset
|
10 import collections |
32346
73e67c4386ec
dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents:
32208
diff
changeset
|
11 import contextlib |
27503
0f4596622273
dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27399
diff
changeset
|
12 import errno |
0f4596622273
dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27399
diff
changeset
|
13 import os |
0f4596622273
dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27399
diff
changeset
|
14 import stat |
0f4596622273
dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27399
diff
changeset
|
15 |
0f4596622273
dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27399
diff
changeset
|
16 from .i18n import _ |
43090
1f339b503a40
py3: manually import pycompat.delattr where it is needed
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43077
diff
changeset
|
17 from .pycompat import delattr |
43239
6fcdcea2b03a
dirstate: add some traces on listdir calls
Augie Fackler <augie@google.com>
parents:
43117
diff
changeset
|
18 |
6fcdcea2b03a
dirstate: add some traces on listdir calls
Augie Fackler <augie@google.com>
parents:
43117
diff
changeset
|
19 from hgdemandimport import tracing |
6fcdcea2b03a
dirstate: add some traces on listdir calls
Augie Fackler <augie@google.com>
parents:
43117
diff
changeset
|
20 |
27503
0f4596622273
dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27399
diff
changeset
|
21 from . import ( |
47501
8b7e47802deb
dirstate: split dirstatemap in its own file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47489
diff
changeset
|
22 dirstatemap, |
27503
0f4596622273
dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27399
diff
changeset
|
23 encoding, |
0f4596622273
dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27399
diff
changeset
|
24 error, |
0f4596622273
dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27399
diff
changeset
|
25 match as matchmod, |
0f4596622273
dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27399
diff
changeset
|
26 pathutil, |
32372
df448de7cf3b
parsers: switch to policy importer
Yuya Nishihara <yuya@tcha.org>
parents:
32352
diff
changeset
|
27 policy, |
30304
ba2c04059317
py3: use pycompat.ossep at certain places
Pulkit Goyal <7895pulkit@gmail.com>
parents:
30224
diff
changeset
|
28 pycompat, |
27503
0f4596622273
dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27399
diff
changeset
|
29 scmutil, |
44530
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
30 sparse, |
27503
0f4596622273
dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27399
diff
changeset
|
31 util, |
0f4596622273
dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27399
diff
changeset
|
32 ) |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
33 |
42927
d459cd8ea42d
interfaces: introduce an interface for dirstate implementations
Augie Fackler <augie@google.com>
parents:
42755
diff
changeset
|
34 from .interfaces import ( |
d459cd8ea42d
interfaces: introduce an interface for dirstate implementations
Augie Fackler <augie@google.com>
parents:
42755
diff
changeset
|
35 dirstate as intdirstate, |
d459cd8ea42d
interfaces: introduce an interface for dirstate implementations
Augie Fackler <augie@google.com>
parents:
42755
diff
changeset
|
36 util as interfaceutil, |
d459cd8ea42d
interfaces: introduce an interface for dirstate implementations
Augie Fackler <augie@google.com>
parents:
42755
diff
changeset
|
37 ) |
d459cd8ea42d
interfaces: introduce an interface for dirstate implementations
Augie Fackler <augie@google.com>
parents:
42755
diff
changeset
|
38 |
43506
9f70512ae2cf
cleanup: remove pointless r-prefixes on single-quoted strings
Augie Fackler <augie@google.com>
parents:
43505
diff
changeset
|
39 parsers = policy.importmod('parsers') |
9f70512ae2cf
cleanup: remove pointless r-prefixes on single-quoted strings
Augie Fackler <augie@google.com>
parents:
43505
diff
changeset
|
40 rustmod = policy.importrust('dirstate') |
32372
df448de7cf3b
parsers: switch to policy importer
Yuya Nishihara <yuya@tcha.org>
parents:
32352
diff
changeset
|
41 |
47277
ed0d54b20c5b
dirstate-v2: Add a new experimental `exp-dirstate-v2` repository requirement
Simon Sapin <simon.sapin@octobus.net>
parents:
47122
diff
changeset
|
42 SUPPORTS_DIRSTATE_V2 = rustmod is not None |
ed0d54b20c5b
dirstate-v2: Add a new experimental `exp-dirstate-v2` repository requirement
Simon Sapin <simon.sapin@octobus.net>
parents:
47122
diff
changeset
|
43 |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
44 propertycache = util.propertycache |
16201
fb7c4c14223f
dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents:
16200
diff
changeset
|
45 filecache = scmutil.filecache |
47521
abed645b8e96
dirstate: move the handling of special case within the dirstatemap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47517
diff
changeset
|
46 _rangemask = dirstatemap.rangemask |
16201
fb7c4c14223f
dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents:
16200
diff
changeset
|
47 |
48044
d5528ac9b4f2
dirstate: Use the Rust implementation of DirstateItem when Rust is enabled
Simon Sapin <simon.sapin@octobus.net>
parents:
48019
diff
changeset
|
48 DirstateItem = dirstatemap.DirstateItem |
21808
7537e57f5dbd
dirstate: add dirstatetuple to create dirstate values
Siddharth Agarwal <sid0@fb.com>
parents:
21116
diff
changeset
|
49 |
47482
cb29484eaade
dirstate: introduce a symbolic constant for the FROM_P2 marker
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47481
diff
changeset
|
50 |
16201
fb7c4c14223f
dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents:
16200
diff
changeset
|
51 class repocache(filecache): |
fb7c4c14223f
dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents:
16200
diff
changeset
|
52 """filecache for files in .hg/""" |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
53 |
16201
fb7c4c14223f
dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents:
16200
diff
changeset
|
54 def join(self, obj, fname): |
fb7c4c14223f
dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents:
16200
diff
changeset
|
55 return obj._opener.join(fname) |
4610 | 56 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
57 |
16202
53e2cd303ecf
dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents:
16201
diff
changeset
|
58 class rootcache(filecache): |
53e2cd303ecf
dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents:
16201
diff
changeset
|
59 """filecache for files in the repository root""" |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
60 |
16202
53e2cd303ecf
dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents:
16201
diff
changeset
|
61 def join(self, obj, fname): |
53e2cd303ecf
dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents:
16201
diff
changeset
|
62 return obj._join(fname) |
53e2cd303ecf
dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents:
16201
diff
changeset
|
63 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
64 |
26634
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
65 def _getfsnow(vfs): |
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
66 '''Get "now" timestamp on filesystem''' |
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
67 tmpfd, tmpname = vfs.mkstemp() |
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
68 try: |
36781
ffa3026d4196
cleanup: use stat_result[stat.ST_MTIME] instead of stat_result.st_mtime
Augie Fackler <augie@google.com>
parents:
36622
diff
changeset
|
69 return os.fstat(tmpfd)[stat.ST_MTIME] |
26634
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
70 finally: |
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
71 os.close(tmpfd) |
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
72 vfs.unlink(tmpname) |
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
73 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
74 |
47592
0f5c203eb5ab
dirstate: add a function to update tracking status while "moving" parents
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47591
diff
changeset
|
75 def requires_parents_change(func): |
0f5c203eb5ab
dirstate: add a function to update tracking status while "moving" parents
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47591
diff
changeset
|
76 def wrap(self, *args, **kwargs): |
0f5c203eb5ab
dirstate: add a function to update tracking status while "moving" parents
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47591
diff
changeset
|
77 if not self.pendingparentchange(): |
0f5c203eb5ab
dirstate: add a function to update tracking status while "moving" parents
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47591
diff
changeset
|
78 msg = 'calling `%s` outside of a parentchange context' |
0f5c203eb5ab
dirstate: add a function to update tracking status while "moving" parents
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47591
diff
changeset
|
79 msg %= func.__name__ |
0f5c203eb5ab
dirstate: add a function to update tracking status while "moving" parents
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47591
diff
changeset
|
80 raise error.ProgrammingError(msg) |
0f5c203eb5ab
dirstate: add a function to update tracking status while "moving" parents
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47591
diff
changeset
|
81 return func(self, *args, **kwargs) |
0f5c203eb5ab
dirstate: add a function to update tracking status while "moving" parents
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47591
diff
changeset
|
82 |
0f5c203eb5ab
dirstate: add a function to update tracking status while "moving" parents
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47591
diff
changeset
|
83 return wrap |
0f5c203eb5ab
dirstate: add a function to update tracking status while "moving" parents
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47591
diff
changeset
|
84 |
0f5c203eb5ab
dirstate: add a function to update tracking status while "moving" parents
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47591
diff
changeset
|
85 |
47593
f927ad5a4e2c
dirstate: add a `set_tracked` method for "hg add"-like usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47592
diff
changeset
|
86 def requires_no_parents_change(func): |
f927ad5a4e2c
dirstate: add a `set_tracked` method for "hg add"-like usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47592
diff
changeset
|
87 def wrap(self, *args, **kwargs): |
47594
0cef28b121a4
context: use `dirstate.set_tracked` in `context.add`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47593
diff
changeset
|
88 if self.pendingparentchange(): |
47593
f927ad5a4e2c
dirstate: add a `set_tracked` method for "hg add"-like usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47592
diff
changeset
|
89 msg = 'calling `%s` inside of a parentchange context' |
f927ad5a4e2c
dirstate: add a `set_tracked` method for "hg add"-like usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47592
diff
changeset
|
90 msg %= func.__name__ |
f927ad5a4e2c
dirstate: add a `set_tracked` method for "hg add"-like usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47592
diff
changeset
|
91 raise error.ProgrammingError(msg) |
f927ad5a4e2c
dirstate: add a `set_tracked` method for "hg add"-like usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47592
diff
changeset
|
92 return func(self, *args, **kwargs) |
f927ad5a4e2c
dirstate: add a `set_tracked` method for "hg add"-like usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47592
diff
changeset
|
93 |
f927ad5a4e2c
dirstate: add a `set_tracked` method for "hg add"-like usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47592
diff
changeset
|
94 return wrap |
f927ad5a4e2c
dirstate: add a `set_tracked` method for "hg add"-like usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47592
diff
changeset
|
95 |
f927ad5a4e2c
dirstate: add a `set_tracked` method for "hg add"-like usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47592
diff
changeset
|
96 |
42927
d459cd8ea42d
interfaces: introduce an interface for dirstate implementations
Augie Fackler <augie@google.com>
parents:
42755
diff
changeset
|
97 @interfaceutil.implementer(intdirstate.idirstate) |
1559
59b3639df0a9
Convert all classes to new-style classes by deriving them from object.
Eric Hopper <hopper@omnifarious.org>
parents:
1541
diff
changeset
|
98 class dirstate(object): |
46780
6266d19556ad
node: introduce nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents:
45942
diff
changeset
|
99 def __init__( |
47280
1766130fe9ba
dirstate-v2: Change the on-disk format when the requirement is enabled
Simon Sapin <simon.sapin@octobus.net>
parents:
47277
diff
changeset
|
100 self, |
1766130fe9ba
dirstate-v2: Change the on-disk format when the requirement is enabled
Simon Sapin <simon.sapin@octobus.net>
parents:
47277
diff
changeset
|
101 opener, |
1766130fe9ba
dirstate-v2: Change the on-disk format when the requirement is enabled
Simon Sapin <simon.sapin@octobus.net>
parents:
47277
diff
changeset
|
102 ui, |
1766130fe9ba
dirstate-v2: Change the on-disk format when the requirement is enabled
Simon Sapin <simon.sapin@octobus.net>
parents:
47277
diff
changeset
|
103 root, |
1766130fe9ba
dirstate-v2: Change the on-disk format when the requirement is enabled
Simon Sapin <simon.sapin@octobus.net>
parents:
47277
diff
changeset
|
104 validate, |
1766130fe9ba
dirstate-v2: Change the on-disk format when the requirement is enabled
Simon Sapin <simon.sapin@octobus.net>
parents:
47277
diff
changeset
|
105 sparsematchfn, |
1766130fe9ba
dirstate-v2: Change the on-disk format when the requirement is enabled
Simon Sapin <simon.sapin@octobus.net>
parents:
47277
diff
changeset
|
106 nodeconstants, |
1766130fe9ba
dirstate-v2: Change the on-disk format when the requirement is enabled
Simon Sapin <simon.sapin@octobus.net>
parents:
47277
diff
changeset
|
107 use_dirstate_v2, |
46780
6266d19556ad
node: introduce nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents:
45942
diff
changeset
|
108 ): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45243
diff
changeset
|
109 """Create a new dirstate object. |
10145
aec936051734
dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents:
9678
diff
changeset
|
110 |
aec936051734
dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents:
9678
diff
changeset
|
111 opener is an open()-like callable that can be used to open the |
aec936051734
dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents:
9678
diff
changeset
|
112 dirstate file; root is the root of the directory tracked by |
aec936051734
dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents:
9678
diff
changeset
|
113 the dirstate. |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45243
diff
changeset
|
114 """ |
47280
1766130fe9ba
dirstate-v2: Change the on-disk format when the requirement is enabled
Simon Sapin <simon.sapin@octobus.net>
parents:
47277
diff
changeset
|
115 self._use_dirstate_v2 = use_dirstate_v2 |
46780
6266d19556ad
node: introduce nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents:
45942
diff
changeset
|
116 self._nodeconstants = nodeconstants |
4614
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
117 self._opener = opener |
13032
e41e2b79883d
dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents:
12907
diff
changeset
|
118 self._validate = validate |
4614
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
119 self._root = root |
33373
fb320398a21c
dirstate: expose a sparse matcher on dirstate (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33215
diff
changeset
|
120 self._sparsematchfn = sparsematchfn |
24198
3cc630be5f09
dirstate: make sure rootdir ends with directory separator (issue4557)
Yuya Nishihara <yuya@tcha.org>
parents:
23866
diff
changeset
|
121 # ntpath.join(root, '') of Python 2.7.9 does not add sep if root is |
3cc630be5f09
dirstate: make sure rootdir ends with directory separator (issue4557)
Yuya Nishihara <yuya@tcha.org>
parents:
23866
diff
changeset
|
122 # UNC path pointing to root share (issue4557) |
24833
cb981009d697
dirstate: use pathutil.normasprefix to ensure os.sep at the end of root
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
24635
diff
changeset
|
123 self._rootdir = pathutil.normasprefix(root) |
4903
81078e177266
dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents:
4677
diff
changeset
|
124 self._dirty = False |
15791
a814f8fcc65a
Use explicit integer division
Martin Geisler <mg@aragost.com>
parents:
15670
diff
changeset
|
125 self._lastnormaltime = 0 |
4614
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
126 self._ui = ui |
16200
9d4a2942a732
dirstate: add filecache support
Idan Kamara <idankk86@gmail.com>
parents:
16143
diff
changeset
|
127 self._filecache = {} |
22404
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
128 self._parentwriters = 0 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
129 self._filename = b'dirstate' |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
130 self._pendingfilename = b'%s.pending' % self._filename |
29772
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29673
diff
changeset
|
131 self._plchangecallbacks = {} |
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29673
diff
changeset
|
132 self._origpl = None |
47501
8b7e47802deb
dirstate: split dirstatemap in its own file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47489
diff
changeset
|
133 self._mapcls = dirstatemap.dirstatemap |
41674
e178b131906a
dirstate: call and cache os.getcwd() in constructor
Martin von Zweigbergk <martinvonz@google.com>
parents:
40424
diff
changeset
|
134 # Access and cache cwd early, so we don't access it for the first time |
e178b131906a
dirstate: call and cache os.getcwd() in constructor
Martin von Zweigbergk <martinvonz@google.com>
parents:
40424
diff
changeset
|
135 # after a working-copy update caused it to not exist (accessing it then |
e178b131906a
dirstate: call and cache os.getcwd() in constructor
Martin von Zweigbergk <martinvonz@google.com>
parents:
40424
diff
changeset
|
136 # raises an exception). |
e178b131906a
dirstate: call and cache os.getcwd() in constructor
Martin von Zweigbergk <martinvonz@google.com>
parents:
40424
diff
changeset
|
137 self._cwd |
22404
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
138 |
44826
35b255e474d9
dirstate: make sure the dirstate is loaded before the changelog (issue6303)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44825
diff
changeset
|
139 def prefetch_parents(self): |
35b255e474d9
dirstate: make sure the dirstate is loaded before the changelog (issue6303)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44825
diff
changeset
|
140 """make sure the parents are loaded |
35b255e474d9
dirstate: make sure the dirstate is loaded before the changelog (issue6303)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44825
diff
changeset
|
141 |
35b255e474d9
dirstate: make sure the dirstate is loaded before the changelog (issue6303)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44825
diff
changeset
|
142 Used to avoid a race condition. |
35b255e474d9
dirstate: make sure the dirstate is loaded before the changelog (issue6303)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44825
diff
changeset
|
143 """ |
35b255e474d9
dirstate: make sure the dirstate is loaded before the changelog (issue6303)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44825
diff
changeset
|
144 self._pl |
35b255e474d9
dirstate: make sure the dirstate is loaded before the changelog (issue6303)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
44825
diff
changeset
|
145 |
32346
73e67c4386ec
dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents:
32208
diff
changeset
|
146 @contextlib.contextmanager |
73e67c4386ec
dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents:
32208
diff
changeset
|
147 def parentchange(self): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45243
diff
changeset
|
148 """Context manager for handling dirstate parents. |
32346
73e67c4386ec
dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents:
32208
diff
changeset
|
149 |
73e67c4386ec
dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents:
32208
diff
changeset
|
150 If an exception occurs in the scope of the context manager, |
73e67c4386ec
dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents:
32208
diff
changeset
|
151 the incoherent dirstate won't be written when wlock is |
73e67c4386ec
dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents:
32208
diff
changeset
|
152 released. |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45243
diff
changeset
|
153 """ |
32346
73e67c4386ec
dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents:
32208
diff
changeset
|
154 self._parentwriters += 1 |
73e67c4386ec
dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents:
32208
diff
changeset
|
155 yield |
73e67c4386ec
dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents:
32208
diff
changeset
|
156 # Typically we want the "undo" step of a context manager in a |
73e67c4386ec
dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents:
32208
diff
changeset
|
157 # finally block so it happens even when an exception |
73e67c4386ec
dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents:
32208
diff
changeset
|
158 # occurs. In this case, however, we only want to decrement |
73e67c4386ec
dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents:
32208
diff
changeset
|
159 # parentwriters if the code in the with statement exits |
73e67c4386ec
dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents:
32208
diff
changeset
|
160 # normally, so we don't have a try/finally here on purpose. |
73e67c4386ec
dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents:
32208
diff
changeset
|
161 self._parentwriters -= 1 |
73e67c4386ec
dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents:
32208
diff
changeset
|
162 |
22404
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
163 def pendingparentchange(self): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45243
diff
changeset
|
164 """Returns true if the dirstate is in the middle of a set of changes |
22404
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
165 that modify the dirstate parent. |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45243
diff
changeset
|
166 """ |
22404
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
167 return self._parentwriters > 0 |
723 | 168 |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
169 @propertycache |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
170 def _map(self): |
35078
a052022639cc
dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents:
35016
diff
changeset
|
171 """Return the dirstate contents (see documentation for dirstatemap).""" |
46780
6266d19556ad
node: introduce nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents:
45942
diff
changeset
|
172 self._map = self._mapcls( |
47280
1766130fe9ba
dirstate-v2: Change the on-disk format when the requirement is enabled
Simon Sapin <simon.sapin@octobus.net>
parents:
47277
diff
changeset
|
173 self._ui, |
1766130fe9ba
dirstate-v2: Change the on-disk format when the requirement is enabled
Simon Sapin <simon.sapin@octobus.net>
parents:
47277
diff
changeset
|
174 self._opener, |
1766130fe9ba
dirstate-v2: Change the on-disk format when the requirement is enabled
Simon Sapin <simon.sapin@octobus.net>
parents:
47277
diff
changeset
|
175 self._root, |
1766130fe9ba
dirstate-v2: Change the on-disk format when the requirement is enabled
Simon Sapin <simon.sapin@octobus.net>
parents:
47277
diff
changeset
|
176 self._nodeconstants, |
1766130fe9ba
dirstate-v2: Change the on-disk format when the requirement is enabled
Simon Sapin <simon.sapin@octobus.net>
parents:
47277
diff
changeset
|
177 self._use_dirstate_v2, |
46780
6266d19556ad
node: introduce nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents:
45942
diff
changeset
|
178 ) |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
179 return self._map |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
180 |
33373
fb320398a21c
dirstate: expose a sparse matcher on dirstate (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33215
diff
changeset
|
181 @property |
fb320398a21c
dirstate: expose a sparse matcher on dirstate (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33215
diff
changeset
|
182 def _sparsematcher(self): |
fb320398a21c
dirstate: expose a sparse matcher on dirstate (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33215
diff
changeset
|
183 """The matcher for the sparse checkout. |
fb320398a21c
dirstate: expose a sparse matcher on dirstate (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33215
diff
changeset
|
184 |
fb320398a21c
dirstate: expose a sparse matcher on dirstate (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33215
diff
changeset
|
185 The working directory may not include every file from a manifest. The |
fb320398a21c
dirstate: expose a sparse matcher on dirstate (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33215
diff
changeset
|
186 matcher obtained by this property will match a path if it is to be |
fb320398a21c
dirstate: expose a sparse matcher on dirstate (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33215
diff
changeset
|
187 included in the working directory. |
fb320398a21c
dirstate: expose a sparse matcher on dirstate (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33215
diff
changeset
|
188 """ |
fb320398a21c
dirstate: expose a sparse matcher on dirstate (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33215
diff
changeset
|
189 # TODO there is potential to cache this property. For now, the matcher |
fb320398a21c
dirstate: expose a sparse matcher on dirstate (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33215
diff
changeset
|
190 # is resolved on every access. (But the called function does use a |
fb320398a21c
dirstate: expose a sparse matcher on dirstate (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33215
diff
changeset
|
191 # cache to keep the lookup fast.) |
fb320398a21c
dirstate: expose a sparse matcher on dirstate (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33215
diff
changeset
|
192 return self._sparsematchfn() |
fb320398a21c
dirstate: expose a sparse matcher on dirstate (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33215
diff
changeset
|
193 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
194 @repocache(b'branch') |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
195 def _branch(self): |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
196 try: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
197 return self._opener.read(b"branch").strip() or b"default" |
25660
328739ea70c3
global: mass rewrite to use modern exception syntax
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25658
diff
changeset
|
198 except IOError as inst: |
15799
e43c140eb08f
dirstate: propagate IOError other than ENOENT when reading branch
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15670
diff
changeset
|
199 if inst.errno != errno.ENOENT: |
e43c140eb08f
dirstate: propagate IOError other than ENOENT when reading branch
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15670
diff
changeset
|
200 raise |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
201 return b"default" |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
202 |
34339
ec769bba34d3
dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents:
34338
diff
changeset
|
203 @property |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
204 def _pl(self): |
34338
0c3e3810cdb6
dirstate: move parent reading to the dirstatemap class
Durham Goode <durham@fb.com>
parents:
34337
diff
changeset
|
205 return self._map.parents() |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
206 |
35084
61888bd0b300
dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents:
35083
diff
changeset
|
207 def hasdir(self, d): |
61888bd0b300
dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents:
35083
diff
changeset
|
208 return self._map.hastrackeddir(d) |
16143
fceb2964fa6c
context: add 'dirs()' to changectx/workingctx for directory patterns
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
15801
diff
changeset
|
209 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
210 @rootcache(b'.hgignore') |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
211 def _ignore(self): |
27594
0921caca7703
dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents:
27593
diff
changeset
|
212 files = self._ignorefiles() |
25216
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25163
diff
changeset
|
213 if not files: |
41676
0531dff73d0b
match: delete unused root and cwd arguments from {always,never,exact}() (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41674
diff
changeset
|
214 return matchmod.never() |
25216
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25163
diff
changeset
|
215 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
216 pats = [b'include:%s' % f for f in files] |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
217 return matchmod.match(self._root, b'', [], pats, warn=self._ui.warn) |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
218 |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
219 @propertycache |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
220 def _slash(self): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
221 return self._ui.configbool(b'ui', b'slash') and pycompat.ossep != b'/' |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
222 |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
223 @propertycache |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
224 def _checklink(self): |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
225 return util.checklink(self._root) |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
226 |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
227 @propertycache |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
228 def _checkexec(self): |
44801
373dd22ae60e
dirstate: force _checkexec to return a bool
Mitchell Plamann <mplamann@janestreet.com>
parents:
44530
diff
changeset
|
229 return bool(util.checkexec(self._root)) |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
230 |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
231 @propertycache |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
232 def _checkcase(self): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
233 return not util.fscasesensitive(self._join(b'.hg')) |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
234 |
4905
fc61495ea9cf
dirstate: make wjoin function private
Matt Mackall <mpm@selenic.com>
parents:
4904
diff
changeset
|
235 def _join(self, f): |
6972
63d1d3e489f8
performance: normalize self._root, avoid calling os.path.join() in dirstate
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
6971
diff
changeset
|
236 # much faster than os.path.join() |
6973
8c136043867b
dirstate: explain why appending instead of os.path.join() is safe
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
6972
diff
changeset
|
237 # it's safe because f is always a relative path |
6972
63d1d3e489f8
performance: normalize self._root, avoid calling os.path.join() in dirstate
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
6971
diff
changeset
|
238 return self._rootdir + f |
723 | 239 |
15337
cf5f9df6406b
windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents:
15057
diff
changeset
|
240 def flagfunc(self, buildfallback): |
cf5f9df6406b
windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents:
15057
diff
changeset
|
241 if self._checklink and self._checkexec: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
242 |
15337
cf5f9df6406b
windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents:
15057
diff
changeset
|
243 def f(x): |
18869
e8b4b139a545
dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents:
18815
diff
changeset
|
244 try: |
e8b4b139a545
dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents:
18815
diff
changeset
|
245 st = os.lstat(self._join(x)) |
e8b4b139a545
dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents:
18815
diff
changeset
|
246 if util.statislink(st): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
247 return b'l' |
18869
e8b4b139a545
dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents:
18815
diff
changeset
|
248 if util.statisexec(st): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
249 return b'x' |
18869
e8b4b139a545
dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents:
18815
diff
changeset
|
250 except OSError: |
e8b4b139a545
dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents:
18815
diff
changeset
|
251 pass |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
252 return b'' |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
253 |
15337
cf5f9df6406b
windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents:
15057
diff
changeset
|
254 return f |
cf5f9df6406b
windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents:
15057
diff
changeset
|
255 |
cf5f9df6406b
windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents:
15057
diff
changeset
|
256 fallback = buildfallback() |
6743 | 257 if self._checklink: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
258 |
6743 | 259 def f(x): |
6972
63d1d3e489f8
performance: normalize self._root, avoid calling os.path.join() in dirstate
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
6971
diff
changeset
|
260 if os.path.islink(self._join(x)): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
261 return b'l' |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
262 if b'x' in fallback(x): |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
263 return b'x' |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
264 return b'' |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
265 |
6743 | 266 return f |
267 if self._checkexec: | |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
268 |
6743 | 269 def f(x): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
270 if b'l' in fallback(x): |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
271 return b'l' |
14273
38af0f514134
rename util.is_exec to isexec
Adrian Buehlmann <adrian@cadifra.com>
parents:
14168
diff
changeset
|
272 if util.isexec(self._join(x)): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
273 return b'x' |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
274 return b'' |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
275 |
6743 | 276 return f |
15337
cf5f9df6406b
windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents:
15057
diff
changeset
|
277 else: |
cf5f9df6406b
windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents:
15057
diff
changeset
|
278 return fallback |
6743 | 279 |
20335
e40520642e64
rebase: do not crash in panic when cwd disapear in the process (issue4121)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
20033
diff
changeset
|
280 @propertycache |
e40520642e64
rebase: do not crash in panic when cwd disapear in the process (issue4121)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
20033
diff
changeset
|
281 def _cwd(self): |
33215
b7f6885cb055
dirstate: centralize _cwd handling into _cwd method
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
32772
diff
changeset
|
282 # internal config: ui.forcecwd |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
283 forcecwd = self._ui.config(b'ui', b'forcecwd') |
33215
b7f6885cb055
dirstate: centralize _cwd handling into _cwd method
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
32772
diff
changeset
|
284 if forcecwd: |
b7f6885cb055
dirstate: centralize _cwd handling into _cwd method
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
32772
diff
changeset
|
285 return forcecwd |
39818
24e493ec2229
py3: rename pycompat.getcwd() to encoding.getcwd() (API)
Matt Harbison <matt_harbison@yahoo.com>
parents:
39452
diff
changeset
|
286 return encoding.getcwd() |
20335
e40520642e64
rebase: do not crash in panic when cwd disapear in the process (issue4121)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
20033
diff
changeset
|
287 |
870
a82eae840447
Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents:
839
diff
changeset
|
288 def getcwd(self): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45243
diff
changeset
|
289 """Return the path from which a canonical path is calculated. |
26293
3d24f31c6b8f
dirstate: state that getcwd() shouldn't be used to get real file path
Yuya Nishihara <yuya@tcha.org>
parents:
25877
diff
changeset
|
290 |
3d24f31c6b8f
dirstate: state that getcwd() shouldn't be used to get real file path
Yuya Nishihara <yuya@tcha.org>
parents:
25877
diff
changeset
|
291 This path should be used to resolve file patterns or to convert |
3d24f31c6b8f
dirstate: state that getcwd() shouldn't be used to get real file path
Yuya Nishihara <yuya@tcha.org>
parents:
25877
diff
changeset
|
292 canonical paths back to file paths for display. It shouldn't be |
3d24f31c6b8f
dirstate: state that getcwd() shouldn't be used to get real file path
Yuya Nishihara <yuya@tcha.org>
parents:
25877
diff
changeset
|
293 used to get real file paths. Use vfs functions instead. |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45243
diff
changeset
|
294 """ |
20335
e40520642e64
rebase: do not crash in panic when cwd disapear in the process (issue4121)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
20033
diff
changeset
|
295 cwd = self._cwd |
10282
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
296 if cwd == self._root: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
297 return b'' |
4614
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
298 # self._root ends with a path separator if self._root is '/' or 'C:\' |
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
299 rootsep = self._root |
5843
83c354c4d529
Add endswithsep() and use it instead of using os.sep and os.altsep directly.
Shun-ichi GOTO <shunichi.goto@gmail.com>
parents:
5842
diff
changeset
|
300 if not util.endswithsep(rootsep): |
30614
cfe66dcf45c0
py3: replace os.sep with pycompat.ossep (part 2 of 4)
Pulkit Goyal <7895pulkit@gmail.com>
parents:
30519
diff
changeset
|
301 rootsep += pycompat.ossep |
4230
c93562fb12cc
Fix handling of paths when run outside the repo.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4229
diff
changeset
|
302 if cwd.startswith(rootsep): |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
303 return cwd[len(rootsep) :] |
4230
c93562fb12cc
Fix handling of paths when run outside the repo.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4229
diff
changeset
|
304 else: |
c93562fb12cc
Fix handling of paths when run outside the repo.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4229
diff
changeset
|
305 # we're outside the repo. return an absolute path. |
c93562fb12cc
Fix handling of paths when run outside the repo.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4229
diff
changeset
|
306 return cwd |
870
a82eae840447
Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents:
839
diff
changeset
|
307 |
4525
78b6add1f966
Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4507
diff
changeset
|
308 def pathto(self, f, cwd=None): |
78b6add1f966
Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4507
diff
changeset
|
309 if cwd is None: |
78b6add1f966
Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4507
diff
changeset
|
310 cwd = self.getcwd() |
4614
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
311 path = util.pathto(self._root, cwd, f) |
4527
b422b558015b
Add ui.slash hgrc setting
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4525
diff
changeset
|
312 if self._slash: |
19210
865beb849720
dirstate: don't overnormalize for ui.slash
Matt Mackall <mpm@selenic.com>
parents:
19128
diff
changeset
|
313 return util.pconvert(path) |
4527
b422b558015b
Add ui.slash hgrc setting
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4525
diff
changeset
|
314 return path |
4525
78b6add1f966
Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4507
diff
changeset
|
315 |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
316 def __getitem__(self, key): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45243
diff
changeset
|
317 """Return the current state of key (a filename) in the dirstate. |
10145
aec936051734
dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents:
9678
diff
changeset
|
318 |
9518
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
319 States are: |
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
320 n normal |
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
321 m needs merging |
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
322 r marked for removal |
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
323 a marked for addition |
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
324 ? not tracked |
47512
769037a279ec
dirstate-entry: add a `state` property (and use it)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47511
diff
changeset
|
325 |
769037a279ec
dirstate-entry: add a `state` property (and use it)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47511
diff
changeset
|
326 XXX The "state" is a bit obscure to be in the "public" API. we should |
769037a279ec
dirstate-entry: add a `state` property (and use it)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47511
diff
changeset
|
327 consider migrating all user of this to going through the dirstate entry |
769037a279ec
dirstate-entry: add a `state` property (and use it)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47511
diff
changeset
|
328 instead. |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45243
diff
changeset
|
329 """ |
48107
dcd97b082b3b
dirstate: deprecate `__getitem__` access
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48089
diff
changeset
|
330 msg = b"don't use dirstate[file], use dirstate.get_entry(file)" |
dcd97b082b3b
dirstate: deprecate `__getitem__` access
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48089
diff
changeset
|
331 util.nouideprecwarn(msg, b'6.1', stacklevel=2) |
47512
769037a279ec
dirstate-entry: add a `state` property (and use it)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47511
diff
changeset
|
332 entry = self._map.get(key) |
769037a279ec
dirstate-entry: add a `state` property (and use it)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47511
diff
changeset
|
333 if entry is not None: |
769037a279ec
dirstate-entry: add a `state` property (and use it)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47511
diff
changeset
|
334 return entry.state |
769037a279ec
dirstate-entry: add a `state` property (and use it)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47511
diff
changeset
|
335 return b'?' |
220 | 336 |
48085
6a78715e56c8
dirstate: add a `get_entry` method to the dirstate
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48059
diff
changeset
|
337 def get_entry(self, path): |
6a78715e56c8
dirstate: add a `get_entry` method to the dirstate
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48059
diff
changeset
|
338 """return a DirstateItem for the associated path""" |
6a78715e56c8
dirstate: add a `get_entry` method to the dirstate
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48059
diff
changeset
|
339 entry = self._map.get(path) |
6a78715e56c8
dirstate: add a `get_entry` method to the dirstate
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48059
diff
changeset
|
340 if entry is None: |
6a78715e56c8
dirstate: add a `get_entry` method to the dirstate
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48059
diff
changeset
|
341 return DirstateItem() |
6a78715e56c8
dirstate: add a `get_entry` method to the dirstate
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48059
diff
changeset
|
342 return entry |
6a78715e56c8
dirstate: add a `get_entry` method to the dirstate
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48059
diff
changeset
|
343 |
220 | 344 def __contains__(self, key): |
4614
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
345 return key in self._map |
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
346 |
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
347 def __iter__(self): |
33707
36d216dcae6a
dirstate: simplify dirstate's __iter__
Alex Gaynor <agaynor@mozilla.com>
parents:
33440
diff
changeset
|
348 return iter(sorted(self._map)) |
220 | 349 |
32550
b98199a5c3e1
cleanup: rename all iteritems methods to items and add iteritems alias
Augie Fackler <raf@durin42.com>
parents:
32372
diff
changeset
|
350 def items(self): |
43106
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43090
diff
changeset
|
351 return pycompat.iteritems(self._map) |
18792
10669e24eb6c
completion: add a debugpathcomplete command
Bryan O'Sullivan <bryano@fb.com>
parents:
18760
diff
changeset
|
352 |
32550
b98199a5c3e1
cleanup: rename all iteritems methods to items and add iteritems alias
Augie Fackler <raf@durin42.com>
parents:
32372
diff
changeset
|
353 iteritems = items |
b98199a5c3e1
cleanup: rename all iteritems methods to items and add iteritems alias
Augie Fackler <raf@durin42.com>
parents:
32372
diff
changeset
|
354 |
227 | 355 def parents(self): |
13032
e41e2b79883d
dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents:
12907
diff
changeset
|
356 return [self._validate(p) for p in self._pl] |
227 | 357 |
13876
10c7d92ac482
dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents:
13763
diff
changeset
|
358 def p1(self): |
10c7d92ac482
dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents:
13763
diff
changeset
|
359 return self._validate(self._pl[0]) |
10c7d92ac482
dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents:
13763
diff
changeset
|
360 |
10c7d92ac482
dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents:
13763
diff
changeset
|
361 def p2(self): |
10c7d92ac482
dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents:
13763
diff
changeset
|
362 return self._validate(self._pl[1]) |
10c7d92ac482
dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents:
13763
diff
changeset
|
363 |
47510
94c58f3aab56
dirstate: add a `in_merge` property
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47501
diff
changeset
|
364 @property |
94c58f3aab56
dirstate: add a `in_merge` property
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47501
diff
changeset
|
365 def in_merge(self): |
94c58f3aab56
dirstate: add a `in_merge` property
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47501
diff
changeset
|
366 """True if a merge is in progress""" |
94c58f3aab56
dirstate: add a `in_merge` property
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47501
diff
changeset
|
367 return self._pl[1] != self._nodeconstants.nullid |
94c58f3aab56
dirstate: add a `in_merge` property
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47501
diff
changeset
|
368 |
4179
7e1c8a565a4f
Move branch read/write to dirstate where it belongs
Matt Mackall <mpm@selenic.com>
parents:
4172
diff
changeset
|
369 def branch(self): |
13047
6c375e07d673
branch: operate on branch names in local string space where possible
Matt Mackall <mpm@selenic.com>
parents:
13032
diff
changeset
|
370 return encoding.tolocal(self._branch) |
4179
7e1c8a565a4f
Move branch read/write to dirstate where it belongs
Matt Mackall <mpm@selenic.com>
parents:
4172
diff
changeset
|
371 |
47012
d55b71393907
node: replace nullid and friends with nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents:
46819
diff
changeset
|
372 def setparents(self, p1, p2=None): |
16551
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16542
diff
changeset
|
373 """Set dirstate parents to p1 and p2. |
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16542
diff
changeset
|
374 |
47513
10e740292dff
dirstate-entry: add a `merged` property
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47512
diff
changeset
|
375 When moving from two parents to one, "merged" entries a |
16551
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16542
diff
changeset
|
376 adjusted to normal and previous copy records discarded and |
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16542
diff
changeset
|
377 returned by the call. |
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16542
diff
changeset
|
378 |
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16542
diff
changeset
|
379 See localrepo.setparents() |
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16542
diff
changeset
|
380 """ |
47012
d55b71393907
node: replace nullid and friends with nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents:
46819
diff
changeset
|
381 if p2 is None: |
d55b71393907
node: replace nullid and friends with nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents:
46819
diff
changeset
|
382 p2 = self._nodeconstants.nullid |
22407
d259322a394b
dirstate: add exception when calling setparent without begin/end (API)
Durham Goode <durham@fb.com>
parents:
22404
diff
changeset
|
383 if self._parentwriters == 0: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
384 raise ValueError( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
385 b"cannot set dirstate parent outside of " |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
386 b"dirstate.parentchange context manager" |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
387 ) |
22407
d259322a394b
dirstate: add exception when calling setparent without begin/end (API)
Durham Goode <durham@fb.com>
parents:
22404
diff
changeset
|
388 |
34339
ec769bba34d3
dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents:
34338
diff
changeset
|
389 self._dirty = True |
16509
eab9119c5dee
rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents:
16472
diff
changeset
|
390 oldp2 = self._pl[1] |
29772
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29673
diff
changeset
|
391 if self._origpl is None: |
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29673
diff
changeset
|
392 self._origpl = self._pl |
47987
dd267f16042f
dirstate: make a conditionnal easier to read in `setparents`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47986
diff
changeset
|
393 nullid = self._nodeconstants.nullid |
48059
5d68c4eedd66
dirstate: move parent state handling in the dirstatemap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48058
diff
changeset
|
394 # True if we need to fold p2 related state back to a linear case |
5d68c4eedd66
dirstate: move parent state handling in the dirstatemap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48058
diff
changeset
|
395 fold_p2 = oldp2 != nullid and p2 == nullid |
5d68c4eedd66
dirstate: move parent state handling in the dirstatemap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48058
diff
changeset
|
396 return self._map.setparents(p1, p2, fold_p2=fold_p2) |
227 | 397 |
4179
7e1c8a565a4f
Move branch read/write to dirstate where it belongs
Matt Mackall <mpm@selenic.com>
parents:
4172
diff
changeset
|
398 def setbranch(self, branch): |
40424
7caf632e30c3
filecache: unimplement __set__() and __delete__() (API)
Yuya Nishihara <yuya@tcha.org>
parents:
39818
diff
changeset
|
399 self.__class__._branch.set(self, encoding.fromlocal(branch)) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
400 f = self._opener(b'branch', b'w', atomictemp=True, checkambig=True) |
16472
14a4e17f0817
dirstate: write branch file atomically
Idan Kamara <idankk86@gmail.com>
parents:
16323
diff
changeset
|
401 try: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
402 f.write(self._branch + b'\n') |
16472
14a4e17f0817
dirstate: write branch file atomically
Idan Kamara <idankk86@gmail.com>
parents:
16323
diff
changeset
|
403 f.close() |
18317
365fecd984c7
dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents:
18078
diff
changeset
|
404 |
365fecd984c7
dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents:
18078
diff
changeset
|
405 # make sure filecache has the correct stat info for _branch after |
365fecd984c7
dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents:
18078
diff
changeset
|
406 # replacing the underlying file |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
407 ce = self._filecache[b'_branch'] |
18317
365fecd984c7
dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents:
18078
diff
changeset
|
408 if ce: |
365fecd984c7
dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents:
18078
diff
changeset
|
409 ce.refresh() |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
410 except: # re-raises |
18076
3bc21f6daac4
dirstate: don't rename branch file if writing it failed
Idan Kamara <idankk86@gmail.com>
parents:
17984
diff
changeset
|
411 f.discard() |
3bc21f6daac4
dirstate: don't rename branch file if writing it failed
Idan Kamara <idankk86@gmail.com>
parents:
17984
diff
changeset
|
412 raise |
4179
7e1c8a565a4f
Move branch read/write to dirstate where it belongs
Matt Mackall <mpm@selenic.com>
parents:
4172
diff
changeset
|
413 |
4613
3a645af7fb76
localrepo and dirstate: rename reload to invalidate
Matt Mackall <mpm@selenic.com>
parents:
4612
diff
changeset
|
414 def invalidate(self): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45243
diff
changeset
|
415 """Causes the next access to reread the dirstate. |
32682
e696f597d02f
dirstate: add docstring for invalidate
Siddharth Agarwal <sid0@fb.com>
parents:
32605
diff
changeset
|
416 |
e696f597d02f
dirstate: add docstring for invalidate
Siddharth Agarwal <sid0@fb.com>
parents:
32605
diff
changeset
|
417 This is different from localrepo.invalidatedirstate() because it always |
e696f597d02f
dirstate: add docstring for invalidate
Siddharth Agarwal <sid0@fb.com>
parents:
32605
diff
changeset
|
418 rereads the dirstate. Use localrepo.invalidatedirstate() if you want to |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45243
diff
changeset
|
419 check whether the dirstate has changed before rereading it.""" |
32682
e696f597d02f
dirstate: add docstring for invalidate
Siddharth Agarwal <sid0@fb.com>
parents:
32605
diff
changeset
|
420 |
43503
313e3a279828
cleanup: remove pointless r-prefixes on double-quoted strings
Augie Fackler <augie@google.com>
parents:
43456
diff
changeset
|
421 for a in ("_map", "_branch", "_ignore"): |
4953
6b3ed43f77ba
dirstate.invalidate: avoid rebuilding _map
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4952
diff
changeset
|
422 if a in self.__dict__: |
6b3ed43f77ba
dirstate.invalidate: avoid rebuilding _map
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4952
diff
changeset
|
423 delattr(self, a) |
15791
a814f8fcc65a
Use explicit integer division
Martin Geisler <mg@aragost.com>
parents:
15670
diff
changeset
|
424 self._lastnormaltime = 0 |
4903
81078e177266
dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents:
4677
diff
changeset
|
425 self._dirty = False |
22404
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
426 self._parentwriters = 0 |
29772
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29673
diff
changeset
|
427 self._origpl = None |
4375
109077e7048d
When reloading the dirstate, recompute ignore information if needed.
Bryan O'Sullivan <bos@serpentine.com>
parents:
4374
diff
changeset
|
428 |
363 | 429 def copy(self, source, dest): |
10145
aec936051734
dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents:
9678
diff
changeset
|
430 """Mark dest as a copy of source. Unmark dest if source is None.""" |
6680
deda205a00e1
Ignore dummy copies in dirstate and localrepo.filecommit()
Patrick Mezard <pmezard@gmail.com>
parents:
6479
diff
changeset
|
431 if source == dest: |
deda205a00e1
Ignore dummy copies in dirstate and localrepo.filecommit()
Patrick Mezard <pmezard@gmail.com>
parents:
6479
diff
changeset
|
432 return |
4903
81078e177266
dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents:
4677
diff
changeset
|
433 self._dirty = True |
7566
5f7e3f17aece
mq: drop copy records when refreshing regular patches (issue1441)
Patrick Mezard <pmezard@gmail.com>
parents:
7280
diff
changeset
|
434 if source is not None: |
34336
0865d25e8a8a
dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34335
diff
changeset
|
435 self._map.copymap[dest] = source |
48057
62188e4de549
dirstate: drop the `_updatedfiles` set
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48055
diff
changeset
|
436 else: |
62188e4de549
dirstate: drop the `_updatedfiles` set
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48055
diff
changeset
|
437 self._map.copymap.pop(dest, None) |
363 | 438 |
439 def copied(self, file): | |
34336
0865d25e8a8a
dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34335
diff
changeset
|
440 return self._map.copymap.get(file, None) |
3154
b1f10d3223c1
dirstate: add copies function
Matt Mackall <mpm@selenic.com>
parents:
2962
diff
changeset
|
441 |
b1f10d3223c1
dirstate: add copies function
Matt Mackall <mpm@selenic.com>
parents:
2962
diff
changeset
|
442 def copies(self): |
34336
0865d25e8a8a
dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34335
diff
changeset
|
443 return self._map.copymap |
515 | 444 |
47593
f927ad5a4e2c
dirstate: add a `set_tracked` method for "hg add"-like usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47592
diff
changeset
|
445 @requires_no_parents_change |
f927ad5a4e2c
dirstate: add a `set_tracked` method for "hg add"-like usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47592
diff
changeset
|
446 def set_tracked(self, filename): |
f927ad5a4e2c
dirstate: add a `set_tracked` method for "hg add"-like usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47592
diff
changeset
|
447 """a "public" method for generic code to mark a file as tracked |
f927ad5a4e2c
dirstate: add a `set_tracked` method for "hg add"-like usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47592
diff
changeset
|
448 |
f927ad5a4e2c
dirstate: add a `set_tracked` method for "hg add"-like usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47592
diff
changeset
|
449 This function is to be called outside of "update/merge" case. For |
f927ad5a4e2c
dirstate: add a `set_tracked` method for "hg add"-like usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47592
diff
changeset
|
450 example by a command like `hg add X`. |
f927ad5a4e2c
dirstate: add a `set_tracked` method for "hg add"-like usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47592
diff
changeset
|
451 |
f927ad5a4e2c
dirstate: add a `set_tracked` method for "hg add"-like usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47592
diff
changeset
|
452 return True the file was previously untracked, False otherwise. |
f927ad5a4e2c
dirstate: add a `set_tracked` method for "hg add"-like usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47592
diff
changeset
|
453 """ |
47984
6255a0d33c45
dirstate: directly call the right function in `set_tracked`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47983
diff
changeset
|
454 self._dirty = True |
47593
f927ad5a4e2c
dirstate: add a `set_tracked` method for "hg add"-like usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47592
diff
changeset
|
455 entry = self._map.get(filename) |
47990
0d2a404f1932
dirstate: introduce a set_tracked method on "map" and "item"
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47989
diff
changeset
|
456 if entry is None or not entry.tracked: |
47984
6255a0d33c45
dirstate: directly call the right function in `set_tracked`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47983
diff
changeset
|
457 self._check_new_tracked_filename(filename) |
47990
0d2a404f1932
dirstate: introduce a set_tracked method on "map" and "item"
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47989
diff
changeset
|
458 return self._map.set_tracked(filename) |
47593
f927ad5a4e2c
dirstate: add a `set_tracked` method for "hg add"-like usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47592
diff
changeset
|
459 |
47599
cce51119bfe6
dirstate: add a `set_untracked` method for "hg remove"-like usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47594
diff
changeset
|
460 @requires_no_parents_change |
cce51119bfe6
dirstate: add a `set_untracked` method for "hg remove"-like usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47594
diff
changeset
|
461 def set_untracked(self, filename): |
cce51119bfe6
dirstate: add a `set_untracked` method for "hg remove"-like usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47594
diff
changeset
|
462 """a "public" method for generic code to mark a file as untracked |
cce51119bfe6
dirstate: add a `set_untracked` method for "hg remove"-like usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47594
diff
changeset
|
463 |
cce51119bfe6
dirstate: add a `set_untracked` method for "hg remove"-like usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47594
diff
changeset
|
464 This function is to be called outside of "update/merge" case. For |
cce51119bfe6
dirstate: add a `set_untracked` method for "hg remove"-like usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47594
diff
changeset
|
465 example by a command like `hg remove X`. |
cce51119bfe6
dirstate: add a `set_untracked` method for "hg remove"-like usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47594
diff
changeset
|
466 |
cce51119bfe6
dirstate: add a `set_untracked` method for "hg remove"-like usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47594
diff
changeset
|
467 return True the file was previously tracked, False otherwise. |
cce51119bfe6
dirstate: add a `set_untracked` method for "hg remove"-like usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47594
diff
changeset
|
468 """ |
47972
5a6c1ef4bcac
dirstate: make dirstatemap.set_untracked deal with added file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47971
diff
changeset
|
469 ret = self._map.set_untracked(filename) |
5a6c1ef4bcac
dirstate: make dirstatemap.set_untracked deal with added file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47971
diff
changeset
|
470 if ret: |
47861
1c797757f5bb
dirstate: directly call the dirstatemap in `set_untracked`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47778
diff
changeset
|
471 self._dirty = True |
47972
5a6c1ef4bcac
dirstate: make dirstatemap.set_untracked deal with added file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47971
diff
changeset
|
472 return ret |
47599
cce51119bfe6
dirstate: add a `set_untracked` method for "hg remove"-like usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47594
diff
changeset
|
473 |
47704
8a50fb0784a9
dirstate: introduce a `set_clean` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47701
diff
changeset
|
474 @requires_no_parents_change |
8a50fb0784a9
dirstate: introduce a `set_clean` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47701
diff
changeset
|
475 def set_clean(self, filename, parentfiledata=None): |
8a50fb0784a9
dirstate: introduce a `set_clean` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47701
diff
changeset
|
476 """record that the current state of the file on disk is known to be clean""" |
8a50fb0784a9
dirstate: introduce a `set_clean` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47701
diff
changeset
|
477 self._dirty = True |
47917
1b3c753b62c6
dirstate: drop the `_normal` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47916
diff
changeset
|
478 if parentfiledata: |
1b3c753b62c6
dirstate: drop the `_normal` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47916
diff
changeset
|
479 (mode, size, mtime) = parentfiledata |
1b3c753b62c6
dirstate: drop the `_normal` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47916
diff
changeset
|
480 else: |
1b3c753b62c6
dirstate: drop the `_normal` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47916
diff
changeset
|
481 (mode, size, mtime) = self._get_filedata(filename) |
47974
4e6f27230aee
dirstate: introduce a `set_clean` method on dirstate's map and items
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47973
diff
changeset
|
482 if not self._map[filename].tracked: |
4e6f27230aee
dirstate: introduce a `set_clean` method on dirstate's map and items
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47973
diff
changeset
|
483 self._check_new_tracked_filename(filename) |
4e6f27230aee
dirstate: introduce a `set_clean` method on dirstate's map and items
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47973
diff
changeset
|
484 self._map.set_clean(filename, mode, size, mtime) |
47917
1b3c753b62c6
dirstate: drop the `_normal` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47916
diff
changeset
|
485 if mtime > self._lastnormaltime: |
1b3c753b62c6
dirstate: drop the `_normal` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47916
diff
changeset
|
486 # Remember the most recent modification timeslot for status(), |
1b3c753b62c6
dirstate: drop the `_normal` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47916
diff
changeset
|
487 # to make sure we won't miss future size-preserving file content |
1b3c753b62c6
dirstate: drop the `_normal` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47916
diff
changeset
|
488 # modifications that happen within the same timeslot. |
1b3c753b62c6
dirstate: drop the `_normal` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47916
diff
changeset
|
489 self._lastnormaltime = mtime |
47704
8a50fb0784a9
dirstate: introduce a `set_clean` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47701
diff
changeset
|
490 |
47720
b0314d8deee1
dirstate: add a `set_possibly_dirty` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47719
diff
changeset
|
491 @requires_no_parents_change |
b0314d8deee1
dirstate: add a `set_possibly_dirty` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47719
diff
changeset
|
492 def set_possibly_dirty(self, filename): |
b0314d8deee1
dirstate: add a `set_possibly_dirty` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47719
diff
changeset
|
493 """record that the current state of the file on disk is unknown""" |
b0314d8deee1
dirstate: add a `set_possibly_dirty` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47719
diff
changeset
|
494 self._dirty = True |
b0314d8deee1
dirstate: add a `set_possibly_dirty` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47719
diff
changeset
|
495 self._map.set_possibly_dirty(filename) |
b0314d8deee1
dirstate: add a `set_possibly_dirty` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47719
diff
changeset
|
496 |
47592
0f5c203eb5ab
dirstate: add a function to update tracking status while "moving" parents
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47591
diff
changeset
|
497 @requires_parents_change |
47693
46c318b9b9a4
dirstate: rename `update_file_reference` to `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47692
diff
changeset
|
498 def update_file_p1( |
47592
0f5c203eb5ab
dirstate: add a function to update tracking status while "moving" parents
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47591
diff
changeset
|
499 self, |
0f5c203eb5ab
dirstate: add a function to update tracking status while "moving" parents
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47591
diff
changeset
|
500 filename, |
0f5c203eb5ab
dirstate: add a function to update tracking status while "moving" parents
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47591
diff
changeset
|
501 p1_tracked, |
0f5c203eb5ab
dirstate: add a function to update tracking status while "moving" parents
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47591
diff
changeset
|
502 ): |
0f5c203eb5ab
dirstate: add a function to update tracking status while "moving" parents
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47591
diff
changeset
|
503 """Set a file as tracked in the parent (or not) |
0f5c203eb5ab
dirstate: add a function to update tracking status while "moving" parents
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47591
diff
changeset
|
504 |
0f5c203eb5ab
dirstate: add a function to update tracking status while "moving" parents
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47591
diff
changeset
|
505 This is to be called when adjust the dirstate to a new parent after an history |
0f5c203eb5ab
dirstate: add a function to update tracking status while "moving" parents
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47591
diff
changeset
|
506 rewriting operation. |
0f5c203eb5ab
dirstate: add a function to update tracking status while "moving" parents
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47591
diff
changeset
|
507 |
0f5c203eb5ab
dirstate: add a function to update tracking status while "moving" parents
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47591
diff
changeset
|
508 It should not be called during a merge (p2 != nullid) and only within |
0f5c203eb5ab
dirstate: add a function to update tracking status while "moving" parents
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47591
diff
changeset
|
509 a `with dirstate.parentchange():` context. |
0f5c203eb5ab
dirstate: add a function to update tracking status while "moving" parents
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47591
diff
changeset
|
510 """ |
0f5c203eb5ab
dirstate: add a function to update tracking status while "moving" parents
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47591
diff
changeset
|
511 if self.in_merge: |
0f5c203eb5ab
dirstate: add a function to update tracking status while "moving" parents
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47591
diff
changeset
|
512 msg = b'update_file_reference should not be called when merging' |
0f5c203eb5ab
dirstate: add a function to update tracking status while "moving" parents
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47591
diff
changeset
|
513 raise error.ProgrammingError(msg) |
0f5c203eb5ab
dirstate: add a function to update tracking status while "moving" parents
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47591
diff
changeset
|
514 entry = self._map.get(filename) |
0f5c203eb5ab
dirstate: add a function to update tracking status while "moving" parents
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47591
diff
changeset
|
515 if entry is None: |
0f5c203eb5ab
dirstate: add a function to update tracking status while "moving" parents
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47591
diff
changeset
|
516 wc_tracked = False |
0f5c203eb5ab
dirstate: add a function to update tracking status while "moving" parents
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47591
diff
changeset
|
517 else: |
0f5c203eb5ab
dirstate: add a function to update tracking status while "moving" parents
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47591
diff
changeset
|
518 wc_tracked = entry.tracked |
48140
98b3eb6c1479
dirstate: align the dirstatemap's API to the data change
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48121
diff
changeset
|
519 if not (p1_tracked or wc_tracked): |
47592
0f5c203eb5ab
dirstate: add a function to update tracking status while "moving" parents
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47591
diff
changeset
|
520 # the file is no longer relevant to anyone |
47999
bac82c2ce858
dirstate: use `reset_state` to drop file in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47995
diff
changeset
|
521 if self._map.get(filename) is not None: |
bac82c2ce858
dirstate: use `reset_state` to drop file in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47995
diff
changeset
|
522 self._map.reset_state(filename) |
47988
d459c6b84961
dirstate: inline the last two `_drop` usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47987
diff
changeset
|
523 self._dirty = True |
47592
0f5c203eb5ab
dirstate: add a function to update tracking status while "moving" parents
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47591
diff
changeset
|
524 elif (not p1_tracked) and wc_tracked: |
47694
1c06ef8f5ea5
dirstate: use `reset_state` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47693
diff
changeset
|
525 if entry is not None and entry.added: |
1c06ef8f5ea5
dirstate: use `reset_state` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47693
diff
changeset
|
526 return # avoid dropping copy information (maybe?) |
47592
0f5c203eb5ab
dirstate: add a function to update tracking status while "moving" parents
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47591
diff
changeset
|
527 |
47694
1c06ef8f5ea5
dirstate: use `reset_state` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47693
diff
changeset
|
528 # this mean we are doing call for file we do not really care about the |
1c06ef8f5ea5
dirstate: use `reset_state` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47693
diff
changeset
|
529 # data (eg: added or removed), however this should be a minor overhead |
1c06ef8f5ea5
dirstate: use `reset_state` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47693
diff
changeset
|
530 # compared to the overall update process calling this. |
1c06ef8f5ea5
dirstate: use `reset_state` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47693
diff
changeset
|
531 parentfiledata = None |
1c06ef8f5ea5
dirstate: use `reset_state` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47693
diff
changeset
|
532 if wc_tracked: |
1c06ef8f5ea5
dirstate: use `reset_state` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47693
diff
changeset
|
533 parentfiledata = self._get_filedata(filename) |
1c06ef8f5ea5
dirstate: use `reset_state` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47693
diff
changeset
|
534 |
1c06ef8f5ea5
dirstate: use `reset_state` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47693
diff
changeset
|
535 self._map.reset_state( |
1c06ef8f5ea5
dirstate: use `reset_state` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47693
diff
changeset
|
536 filename, |
1c06ef8f5ea5
dirstate: use `reset_state` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47693
diff
changeset
|
537 wc_tracked, |
1c06ef8f5ea5
dirstate: use `reset_state` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47693
diff
changeset
|
538 p1_tracked, |
48140
98b3eb6c1479
dirstate: align the dirstatemap's API to the data change
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48121
diff
changeset
|
539 # the underlying reference might have changed, we will have to |
98b3eb6c1479
dirstate: align the dirstatemap's API to the data change
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48121
diff
changeset
|
540 # check it. |
98b3eb6c1479
dirstate: align the dirstatemap's API to the data change
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48121
diff
changeset
|
541 has_meaningful_mtime=False, |
47694
1c06ef8f5ea5
dirstate: use `reset_state` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47693
diff
changeset
|
542 parentfiledata=parentfiledata, |
1c06ef8f5ea5
dirstate: use `reset_state` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47693
diff
changeset
|
543 ) |
47696
ff481c238496
dirstate: properly update `_lastnormaltime` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47695
diff
changeset
|
544 if ( |
ff481c238496
dirstate: properly update `_lastnormaltime` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47695
diff
changeset
|
545 parentfiledata is not None |
ff481c238496
dirstate: properly update `_lastnormaltime` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47695
diff
changeset
|
546 and parentfiledata[2] > self._lastnormaltime |
ff481c238496
dirstate: properly update `_lastnormaltime` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47695
diff
changeset
|
547 ): |
ff481c238496
dirstate: properly update `_lastnormaltime` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47695
diff
changeset
|
548 # Remember the most recent modification timeslot for status(), |
ff481c238496
dirstate: properly update `_lastnormaltime` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47695
diff
changeset
|
549 # to make sure we won't miss future size-preserving file content |
ff481c238496
dirstate: properly update `_lastnormaltime` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47695
diff
changeset
|
550 # modifications that happen within the same timeslot. |
ff481c238496
dirstate: properly update `_lastnormaltime` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47695
diff
changeset
|
551 self._lastnormaltime = parentfiledata[2] |
47694
1c06ef8f5ea5
dirstate: use `reset_state` in `update_file_p1`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47693
diff
changeset
|
552 |
47611
e2e72daac90b
dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47599
diff
changeset
|
553 @requires_parents_change |
e2e72daac90b
dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47599
diff
changeset
|
554 def update_file( |
e2e72daac90b
dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47599
diff
changeset
|
555 self, |
e2e72daac90b
dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47599
diff
changeset
|
556 filename, |
e2e72daac90b
dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47599
diff
changeset
|
557 wc_tracked, |
e2e72daac90b
dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47599
diff
changeset
|
558 p1_tracked, |
e2e72daac90b
dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47599
diff
changeset
|
559 p2_tracked=False, |
e2e72daac90b
dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47599
diff
changeset
|
560 merged=False, |
e2e72daac90b
dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47599
diff
changeset
|
561 clean_p1=False, |
e2e72daac90b
dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47599
diff
changeset
|
562 clean_p2=False, |
e2e72daac90b
dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47599
diff
changeset
|
563 possibly_dirty=False, |
47691
33beeb32f73a
dirstate: replace `update_parent_file_data` with simpler `update_parent` call
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47690
diff
changeset
|
564 parentfiledata=None, |
47611
e2e72daac90b
dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47599
diff
changeset
|
565 ): |
e2e72daac90b
dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47599
diff
changeset
|
566 """update the information about a file in the dirstate |
e2e72daac90b
dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47599
diff
changeset
|
567 |
e2e72daac90b
dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47599
diff
changeset
|
568 This is to be called when the direstates parent changes to keep track |
e2e72daac90b
dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47599
diff
changeset
|
569 of what is the file situation in regards to the working copy and its parent. |
e2e72daac90b
dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47599
diff
changeset
|
570 |
e2e72daac90b
dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47599
diff
changeset
|
571 This function must be called within a `dirstate.parentchange` context. |
e2e72daac90b
dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47599
diff
changeset
|
572 |
47771
03089463c554
dirstate: fix typo in docstring
Augie Fackler <augie@google.com>
parents:
47757
diff
changeset
|
573 note: the API is at an early stage and we might need to adjust it |
47611
e2e72daac90b
dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47599
diff
changeset
|
574 depending of what information ends up being relevant and useful to |
e2e72daac90b
dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47599
diff
changeset
|
575 other processing. |
e2e72daac90b
dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47599
diff
changeset
|
576 """ |
e2e72daac90b
dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47599
diff
changeset
|
577 if merged and (clean_p1 or clean_p2): |
e2e72daac90b
dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47599
diff
changeset
|
578 msg = b'`merged` argument incompatible with `clean_p1`/`clean_p2`' |
e2e72daac90b
dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47599
diff
changeset
|
579 raise error.ProgrammingError(msg) |
47692
e5fb14a07866
dirstate-map: move most of `dirstate.update_file` logic in the dsmap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47691
diff
changeset
|
580 |
e5fb14a07866
dirstate-map: move most of `dirstate.update_file` logic in the dsmap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47691
diff
changeset
|
581 # note: I do not think we need to double check name clash here since we |
e5fb14a07866
dirstate-map: move most of `dirstate.update_file` logic in the dsmap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47691
diff
changeset
|
582 # are in a update/merge case that should already have taken care of |
e5fb14a07866
dirstate-map: move most of `dirstate.update_file` logic in the dsmap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47691
diff
changeset
|
583 # this. The test agrees |
e5fb14a07866
dirstate-map: move most of `dirstate.update_file` logic in the dsmap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47691
diff
changeset
|
584 |
e5fb14a07866
dirstate-map: move most of `dirstate.update_file` logic in the dsmap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47691
diff
changeset
|
585 self._dirty = True |
e5fb14a07866
dirstate-map: move most of `dirstate.update_file` logic in the dsmap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47691
diff
changeset
|
586 |
e5fb14a07866
dirstate-map: move most of `dirstate.update_file` logic in the dsmap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47691
diff
changeset
|
587 need_parent_file_data = ( |
e5fb14a07866
dirstate-map: move most of `dirstate.update_file` logic in the dsmap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47691
diff
changeset
|
588 not (possibly_dirty or clean_p2 or merged) |
e5fb14a07866
dirstate-map: move most of `dirstate.update_file` logic in the dsmap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47691
diff
changeset
|
589 and wc_tracked |
e5fb14a07866
dirstate-map: move most of `dirstate.update_file` logic in the dsmap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47691
diff
changeset
|
590 and p1_tracked |
e5fb14a07866
dirstate-map: move most of `dirstate.update_file` logic in the dsmap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47691
diff
changeset
|
591 ) |
e5fb14a07866
dirstate-map: move most of `dirstate.update_file` logic in the dsmap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47691
diff
changeset
|
592 |
e5fb14a07866
dirstate-map: move most of `dirstate.update_file` logic in the dsmap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47691
diff
changeset
|
593 # this mean we are doing call for file we do not really care about the |
e5fb14a07866
dirstate-map: move most of `dirstate.update_file` logic in the dsmap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47691
diff
changeset
|
594 # data (eg: added or removed), however this should be a minor overhead |
e5fb14a07866
dirstate-map: move most of `dirstate.update_file` logic in the dsmap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47691
diff
changeset
|
595 # compared to the overall update process calling this. |
e5fb14a07866
dirstate-map: move most of `dirstate.update_file` logic in the dsmap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47691
diff
changeset
|
596 if need_parent_file_data: |
e5fb14a07866
dirstate-map: move most of `dirstate.update_file` logic in the dsmap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47691
diff
changeset
|
597 if parentfiledata is None: |
e5fb14a07866
dirstate-map: move most of `dirstate.update_file` logic in the dsmap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47691
diff
changeset
|
598 parentfiledata = self._get_filedata(filename) |
e5fb14a07866
dirstate-map: move most of `dirstate.update_file` logic in the dsmap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47691
diff
changeset
|
599 mtime = parentfiledata[2] |
e5fb14a07866
dirstate-map: move most of `dirstate.update_file` logic in the dsmap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47691
diff
changeset
|
600 |
e5fb14a07866
dirstate-map: move most of `dirstate.update_file` logic in the dsmap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47691
diff
changeset
|
601 if mtime > self._lastnormaltime: |
e5fb14a07866
dirstate-map: move most of `dirstate.update_file` logic in the dsmap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47691
diff
changeset
|
602 # Remember the most recent modification timeslot for |
e5fb14a07866
dirstate-map: move most of `dirstate.update_file` logic in the dsmap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47691
diff
changeset
|
603 # status(), to make sure we won't miss future |
e5fb14a07866
dirstate-map: move most of `dirstate.update_file` logic in the dsmap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47691
diff
changeset
|
604 # size-preserving file content modifications that happen |
e5fb14a07866
dirstate-map: move most of `dirstate.update_file` logic in the dsmap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47691
diff
changeset
|
605 # within the same timeslot. |
e5fb14a07866
dirstate-map: move most of `dirstate.update_file` logic in the dsmap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47691
diff
changeset
|
606 self._lastnormaltime = mtime |
e5fb14a07866
dirstate-map: move most of `dirstate.update_file` logic in the dsmap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47691
diff
changeset
|
607 |
e5fb14a07866
dirstate-map: move most of `dirstate.update_file` logic in the dsmap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47691
diff
changeset
|
608 self._map.reset_state( |
e5fb14a07866
dirstate-map: move most of `dirstate.update_file` logic in the dsmap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47691
diff
changeset
|
609 filename, |
e5fb14a07866
dirstate-map: move most of `dirstate.update_file` logic in the dsmap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47691
diff
changeset
|
610 wc_tracked, |
e5fb14a07866
dirstate-map: move most of `dirstate.update_file` logic in the dsmap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47691
diff
changeset
|
611 p1_tracked, |
48140
98b3eb6c1479
dirstate: align the dirstatemap's API to the data change
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48121
diff
changeset
|
612 p2_info=merged or clean_p2, |
98b3eb6c1479
dirstate: align the dirstatemap's API to the data change
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48121
diff
changeset
|
613 has_meaningful_mtime=not possibly_dirty, |
47692
e5fb14a07866
dirstate-map: move most of `dirstate.update_file` logic in the dsmap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47691
diff
changeset
|
614 parentfiledata=parentfiledata, |
e5fb14a07866
dirstate-map: move most of `dirstate.update_file` logic in the dsmap
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47691
diff
changeset
|
615 ) |
47695
f98145ce78d7
dirstate: properly update `_lastnormaltime` in `update_file`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47694
diff
changeset
|
616 if ( |
f98145ce78d7
dirstate: properly update `_lastnormaltime` in `update_file`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47694
diff
changeset
|
617 parentfiledata is not None |
f98145ce78d7
dirstate: properly update `_lastnormaltime` in `update_file`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47694
diff
changeset
|
618 and parentfiledata[2] > self._lastnormaltime |
f98145ce78d7
dirstate: properly update `_lastnormaltime` in `update_file`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47694
diff
changeset
|
619 ): |
f98145ce78d7
dirstate: properly update `_lastnormaltime` in `update_file`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47694
diff
changeset
|
620 # Remember the most recent modification timeslot for status(), |
f98145ce78d7
dirstate: properly update `_lastnormaltime` in `update_file`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47694
diff
changeset
|
621 # to make sure we won't miss future size-preserving file content |
f98145ce78d7
dirstate: properly update `_lastnormaltime` in `update_file`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47694
diff
changeset
|
622 # modifications that happen within the same timeslot. |
f98145ce78d7
dirstate: properly update `_lastnormaltime` in `update_file`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47694
diff
changeset
|
623 self._lastnormaltime = parentfiledata[2] |
47611
e2e72daac90b
dirstate: add a `update_file` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47599
diff
changeset
|
624 |
47973
2e0ff3947b05
dirstate: extract the logic to check file/dirname collision when adding a file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47972
diff
changeset
|
625 def _check_new_tracked_filename(self, filename): |
2e0ff3947b05
dirstate: extract the logic to check file/dirname collision when adding a file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47972
diff
changeset
|
626 scmutil.checkfilename(filename) |
2e0ff3947b05
dirstate: extract the logic to check file/dirname collision when adding a file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47972
diff
changeset
|
627 if self._map.hastrackeddir(filename): |
2e0ff3947b05
dirstate: extract the logic to check file/dirname collision when adding a file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47972
diff
changeset
|
628 msg = _(b'directory %r already in dirstate') |
2e0ff3947b05
dirstate: extract the logic to check file/dirname collision when adding a file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47972
diff
changeset
|
629 msg %= pycompat.bytestr(filename) |
2e0ff3947b05
dirstate: extract the logic to check file/dirname collision when adding a file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47972
diff
changeset
|
630 raise error.Abort(msg) |
2e0ff3947b05
dirstate: extract the logic to check file/dirname collision when adding a file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47972
diff
changeset
|
631 # shadows |
2e0ff3947b05
dirstate: extract the logic to check file/dirname collision when adding a file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47972
diff
changeset
|
632 for d in pathutil.finddirs(filename): |
2e0ff3947b05
dirstate: extract the logic to check file/dirname collision when adding a file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47972
diff
changeset
|
633 if self._map.hastrackeddir(d): |
2e0ff3947b05
dirstate: extract the logic to check file/dirname collision when adding a file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47972
diff
changeset
|
634 break |
2e0ff3947b05
dirstate: extract the logic to check file/dirname collision when adding a file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47972
diff
changeset
|
635 entry = self._map.get(d) |
2e0ff3947b05
dirstate: extract the logic to check file/dirname collision when adding a file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47972
diff
changeset
|
636 if entry is not None and not entry.removed: |
2e0ff3947b05
dirstate: extract the logic to check file/dirname collision when adding a file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47972
diff
changeset
|
637 msg = _(b'file %r in dirstate clashes with %r') |
2e0ff3947b05
dirstate: extract the logic to check file/dirname collision when adding a file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47972
diff
changeset
|
638 msg %= (pycompat.bytestr(d), pycompat.bytestr(filename)) |
2e0ff3947b05
dirstate: extract the logic to check file/dirname collision when adding a file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47972
diff
changeset
|
639 raise error.Abort(msg) |
2e0ff3947b05
dirstate: extract the logic to check file/dirname collision when adding a file
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47972
diff
changeset
|
640 |
47690
a685c29ebf54
dirstate: factor out the part retrieve "filedata" out of `normal`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47674
diff
changeset
|
641 def _get_filedata(self, filename): |
a685c29ebf54
dirstate: factor out the part retrieve "filedata" out of `normal`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47674
diff
changeset
|
642 """returns""" |
a685c29ebf54
dirstate: factor out the part retrieve "filedata" out of `normal`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47674
diff
changeset
|
643 s = os.lstat(self._join(filename)) |
a685c29ebf54
dirstate: factor out the part retrieve "filedata" out of `normal`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47674
diff
changeset
|
644 mode = s.st_mode |
a685c29ebf54
dirstate: factor out the part retrieve "filedata" out of `normal`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47674
diff
changeset
|
645 size = s.st_size |
a685c29ebf54
dirstate: factor out the part retrieve "filedata" out of `normal`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47674
diff
changeset
|
646 mtime = s[stat.ST_MTIME] |
a685c29ebf54
dirstate: factor out the part retrieve "filedata" out of `normal`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47674
diff
changeset
|
647 return (mode, size, mtime) |
a685c29ebf54
dirstate: factor out the part retrieve "filedata" out of `normal`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47674
diff
changeset
|
648 |
24538
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
649 def _discoverpath(self, path, normed, ignoremissing, exists, storemap): |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
650 if exists is None: |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
651 exists = os.path.lexists(os.path.join(self._root, path)) |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
652 if not exists: |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
653 # Maybe a path component exists |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
654 if not ignoremissing and b'/' in path: |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
655 d, f = path.rsplit(b'/', 1) |
24538
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
656 d = self._normalize(d, False, ignoremissing, None) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
657 folded = d + b"/" + f |
24538
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
658 else: |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
659 # No path components, preserve original case |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
660 folded = path |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
661 else: |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
662 # recursively normalize leading directory components |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
663 # against dirstate |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
664 if b'/' in normed: |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
665 d, f = normed.rsplit(b'/', 1) |
24538
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
666 d = self._normalize(d, False, ignoremissing, True) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
667 r = self._root + b"/" + d |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
668 folded = d + b"/" + util.fspath(f, r) |
24538
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
669 else: |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
670 folded = util.fspath(normed, self._root) |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
671 storemap[normed] = folded |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
672 |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
673 return folded |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
674 |
24539
3a8eba78803e
dirstate: introduce function to normalize just filenames
Siddharth Agarwal <sid0@fb.com>
parents:
24538
diff
changeset
|
675 def _normalizefile(self, path, isknown, ignoremissing=False, exists=None): |
15488
6eff984d8e76
dirstate: fix case-folding identity for traditional Unix
Matt Mackall <mpm@selenic.com>
parents:
15399
diff
changeset
|
676 normed = util.normcase(path) |
34676
bfddc3d678ae
dirstate: remove _filefoldmap property cache
Durham Goode <durham@fb.com>
parents:
34675
diff
changeset
|
677 folded = self._map.filefoldmap.get(normed, None) |
13717
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
678 if folded is None: |
16542
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
679 if isknown: |
13717
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
680 folded = path |
7068
57377fa7eda2
issue 1286: dirstat regression on case folding systems
Petr Kodl <petrkodl@gmail.com>
parents:
7034
diff
changeset
|
681 else: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
682 folded = self._discoverpath( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
683 path, normed, ignoremissing, exists, self._map.filefoldmap |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
684 ) |
24539
3a8eba78803e
dirstate: introduce function to normalize just filenames
Siddharth Agarwal <sid0@fb.com>
parents:
24538
diff
changeset
|
685 return folded |
16302
49b54f1ae053
dirstate: normalize case of directory components
Matt Mackall <mpm@selenic.com>
parents:
16258
diff
changeset
|
686 |
16542
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
687 def _normalize(self, path, isknown, ignoremissing=False, exists=None): |
15488
6eff984d8e76
dirstate: fix case-folding identity for traditional Unix
Matt Mackall <mpm@selenic.com>
parents:
15399
diff
changeset
|
688 normed = util.normcase(path) |
34676
bfddc3d678ae
dirstate: remove _filefoldmap property cache
Durham Goode <durham@fb.com>
parents:
34675
diff
changeset
|
689 folded = self._map.filefoldmap.get(normed, None) |
24561
6514030dc686
dirstate._normalize: don't construct dirfoldmap if not necessary
Siddharth Agarwal <sid0@fb.com>
parents:
24560
diff
changeset
|
690 if folded is None: |
34678
e8a89ed7ce96
dirstate: move the _dirfoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34677
diff
changeset
|
691 folded = self._map.dirfoldmap.get(normed, None) |
13717
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
692 if folded is None: |
16542
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
693 if isknown: |
13717
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
694 folded = path |
7068
57377fa7eda2
issue 1286: dirstat regression on case folding systems
Petr Kodl <petrkodl@gmail.com>
parents:
7034
diff
changeset
|
695 else: |
24540
25c1d3ca5ff6
dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents:
24539
diff
changeset
|
696 # store discovered result in dirfoldmap so that future |
25c1d3ca5ff6
dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents:
24539
diff
changeset
|
697 # normalizefile calls don't start matching directories |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
698 folded = self._discoverpath( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
699 path, normed, ignoremissing, exists, self._map.dirfoldmap |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
700 ) |
13717
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
701 return folded |
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
702 |
16542
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
703 def normalize(self, path, isknown=False, ignoremissing=False): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45243
diff
changeset
|
704 """ |
13717
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
705 normalize the case of a pathname when on a casefolding filesystem |
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
706 |
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
707 isknown specifies whether the filename came from walking the |
16542
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
708 disk, to avoid extra filesystem access. |
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
709 |
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
710 If ignoremissing is True, missing path are returned |
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
711 unchanged. Otherwise, we try harder to normalize possibly |
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
712 existing path components. |
13717
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
713 |
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
714 The normalized case is determined based on the following precedence: |
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
715 |
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
716 - version of name already stored in the dirstate |
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
717 - version of name stored on disk |
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
718 - version provided via command arguments |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45243
diff
changeset
|
719 """ |
13717
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
720 |
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
721 if self._checkcase: |
16542
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
722 return self._normalize(path, isknown, ignoremissing) |
13717
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
723 return path |
6677
9865e15febd0
Add a normalize() method to dirstate
Paul Moore <p.f.moore@gmail.com>
parents:
6675
diff
changeset
|
724 |
5065
b304c2496f52
dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4953
diff
changeset
|
725 def clear(self): |
34933
0217f75b6e59
dirstate: move clear onto dirstatemap class
Durham Goode <durham@fb.com>
parents:
34678
diff
changeset
|
726 self._map.clear() |
15791
a814f8fcc65a
Use explicit integer division
Martin Geisler <mg@aragost.com>
parents:
15670
diff
changeset
|
727 self._lastnormaltime = 0 |
5123 | 728 self._dirty = True |
5065
b304c2496f52
dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4953
diff
changeset
|
729 |
18760
e74704c33e24
strip: make --keep option not set all dirstate times to 0
Durham Goode <durham@fb.com>
parents:
18663
diff
changeset
|
730 def rebuild(self, parent, allfiles, changedfiles=None): |
25448
2bbfc2042d93
dirstate: avoid invalidating every entries when list is empty
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25275
diff
changeset
|
731 if changedfiles is None: |
27176
54ace3372f84
dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents:
27016
diff
changeset
|
732 # Rebuild entire dirstate |
43891
7eb6a2680ae6
dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents:
43869
diff
changeset
|
733 to_lookup = allfiles |
7eb6a2680ae6
dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents:
43869
diff
changeset
|
734 to_drop = [] |
27176
54ace3372f84
dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents:
27016
diff
changeset
|
735 lastnormaltime = self._lastnormaltime |
54ace3372f84
dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents:
27016
diff
changeset
|
736 self.clear() |
54ace3372f84
dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents:
27016
diff
changeset
|
737 self._lastnormaltime = lastnormaltime |
43891
7eb6a2680ae6
dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents:
43869
diff
changeset
|
738 elif len(changedfiles) < 10: |
7eb6a2680ae6
dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents:
43869
diff
changeset
|
739 # Avoid turning allfiles into a set, which can be expensive if it's |
7eb6a2680ae6
dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents:
43869
diff
changeset
|
740 # large. |
7eb6a2680ae6
dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents:
43869
diff
changeset
|
741 to_lookup = [] |
7eb6a2680ae6
dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents:
43869
diff
changeset
|
742 to_drop = [] |
7eb6a2680ae6
dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents:
43869
diff
changeset
|
743 for f in changedfiles: |
7eb6a2680ae6
dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents:
43869
diff
changeset
|
744 if f in allfiles: |
7eb6a2680ae6
dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents:
43869
diff
changeset
|
745 to_lookup.append(f) |
7eb6a2680ae6
dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents:
43869
diff
changeset
|
746 else: |
7eb6a2680ae6
dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents:
43869
diff
changeset
|
747 to_drop.append(f) |
7eb6a2680ae6
dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents:
43869
diff
changeset
|
748 else: |
7eb6a2680ae6
dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents:
43869
diff
changeset
|
749 changedfilesset = set(changedfiles) |
7eb6a2680ae6
dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents:
43869
diff
changeset
|
750 to_lookup = changedfilesset & set(allfiles) |
7eb6a2680ae6
dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents:
43869
diff
changeset
|
751 to_drop = changedfilesset - to_lookup |
27176
54ace3372f84
dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents:
27016
diff
changeset
|
752 |
29772
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29673
diff
changeset
|
753 if self._origpl is None: |
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29673
diff
changeset
|
754 self._origpl = self._pl |
47012
d55b71393907
node: replace nullid and friends with nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents:
46819
diff
changeset
|
755 self._map.setparents(parent, self._nodeconstants.nullid) |
43891
7eb6a2680ae6
dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents:
43869
diff
changeset
|
756 |
7eb6a2680ae6
dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents:
43869
diff
changeset
|
757 for f in to_lookup: |
47992
14fa2e583422
dirstate: replace the use of `_normallookup` in `rebuild`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47991
diff
changeset
|
758 |
14fa2e583422
dirstate: replace the use of `_normallookup` in `rebuild`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47991
diff
changeset
|
759 if self.in_merge: |
14fa2e583422
dirstate: replace the use of `_normallookup` in `rebuild`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47991
diff
changeset
|
760 self.set_tracked(f) |
14fa2e583422
dirstate: replace the use of `_normallookup` in `rebuild`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47991
diff
changeset
|
761 else: |
14fa2e583422
dirstate: replace the use of `_normallookup` in `rebuild`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47991
diff
changeset
|
762 self._map.reset_state( |
14fa2e583422
dirstate: replace the use of `_normallookup` in `rebuild`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47991
diff
changeset
|
763 f, |
14fa2e583422
dirstate: replace the use of `_normallookup` in `rebuild`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47991
diff
changeset
|
764 wc_tracked=True, |
14fa2e583422
dirstate: replace the use of `_normallookup` in `rebuild`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47991
diff
changeset
|
765 p1_tracked=True, |
14fa2e583422
dirstate: replace the use of `_normallookup` in `rebuild`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47991
diff
changeset
|
766 ) |
43891
7eb6a2680ae6
dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents:
43869
diff
changeset
|
767 for f in to_drop: |
48000
1370d695c258
dirstate: use `reset_state` in `rebuild` instead of `dropfile`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47999
diff
changeset
|
768 self._map.reset_state(f) |
30026
ba06562a06a2
dirstate: rebuild should update dirstate properly
Mateusz Kwapich <mitrandir@fb.com>
parents:
29889
diff
changeset
|
769 |
4903
81078e177266
dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents:
4677
diff
changeset
|
770 self._dirty = True |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
771 |
32750
b698921ee137
dirstate: add identity information to detect simultaneous changing in storage
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
32682
diff
changeset
|
772 def identity(self): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45243
diff
changeset
|
773 """Return identity of dirstate itself to detect changing in storage |
32750
b698921ee137
dirstate: add identity information to detect simultaneous changing in storage
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
32682
diff
changeset
|
774 |
b698921ee137
dirstate: add identity information to detect simultaneous changing in storage
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
32682
diff
changeset
|
775 If identity of previous dirstate is equal to this, writing |
b698921ee137
dirstate: add identity information to detect simultaneous changing in storage
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
32682
diff
changeset
|
776 changes based on the former dirstate out can keep consistency. |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45243
diff
changeset
|
777 """ |
34675
c6ef9a2498a5
dirstate: move identity to dirstatemap
Durham Goode <durham@fb.com>
parents:
34674
diff
changeset
|
778 return self._map.identity |
32750
b698921ee137
dirstate: add identity information to detect simultaneous changing in storage
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
32682
diff
changeset
|
779 |
29673
52ff07e1de91
deprecation: enforce thew 'tr' argument of 'dirstate.write' (API)
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
29351
diff
changeset
|
780 def write(self, tr): |
4612
17ee7407097f
dirstate: simplify dirty handling
Matt Mackall <mpm@selenic.com>
parents:
4611
diff
changeset
|
781 if not self._dirty: |
1794
98b6c1cad58b
only write the dirstate when something changed
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1755
diff
changeset
|
782 return |
21931
89b809fa6cef
dirstate: delay writing out to ensure timestamp of each entries explicitly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
21810
diff
changeset
|
783 |
26634
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
784 filename = self._filename |
29673
52ff07e1de91
deprecation: enforce thew 'tr' argument of 'dirstate.write' (API)
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
29351
diff
changeset
|
785 if tr: |
26634
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
786 # 'dirstate.write()' is not only for writing in-memory |
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
787 # changes out, but also for dropping ambiguous timestamp. |
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
788 # delayed writing re-raise "ambiguous timestamp issue". |
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
789 # See also the wiki page below for detail: |
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
790 # https://www.mercurial-scm.org/wiki/DirstateTransactionPlan |
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
791 |
48055
84e7a86e3a63
dirstate: simplify the ambiguity clearing at write time
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48044
diff
changeset
|
792 # record when mtime start to be ambiguous |
26747
beff0b2481b3
dirstate: remove layering violation around writing dirstate out
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26746
diff
changeset
|
793 now = _getfsnow(self._opener) |
26634
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
794 |
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
795 # delay writing in-memory changes out |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
796 tr.addfilegenerator( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
797 b'dirstate', |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
798 (self._filename,), |
48055
84e7a86e3a63
dirstate: simplify the ambiguity clearing at write time
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48044
diff
changeset
|
799 lambda f: self._writedirstate(tr, f, now=now), |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
800 location=b'plain', |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
801 ) |
26634
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
802 return |
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
803 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
804 st = self._opener(filename, b"w", atomictemp=True, checkambig=True) |
47674
ff97e793ed36
dirstate-v2: Introduce a docket file
Simon Sapin <simon.sapin@octobus.net>
parents:
47673
diff
changeset
|
805 self._writedirstate(tr, st) |
26521
3f41e28a16d8
dirstate: split write to write changes into files other than .hg/dirstate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26492
diff
changeset
|
806 |
29772
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29673
diff
changeset
|
807 def addparentchangecallback(self, category, callback): |
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29673
diff
changeset
|
808 """add a callback to be called when the wd parents are changed |
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29673
diff
changeset
|
809 |
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29673
diff
changeset
|
810 Callback will be called with the following arguments: |
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29673
diff
changeset
|
811 dirstate, (oldp1, oldp2), (newp1, newp2) |
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29673
diff
changeset
|
812 |
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29673
diff
changeset
|
813 Category is a unique identifier to allow overwriting an old callback |
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29673
diff
changeset
|
814 with a newer callback. |
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29673
diff
changeset
|
815 """ |
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29673
diff
changeset
|
816 self._plchangecallbacks[category] = callback |
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29673
diff
changeset
|
817 |
48055
84e7a86e3a63
dirstate: simplify the ambiguity clearing at write time
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48044
diff
changeset
|
818 def _writedirstate(self, tr, st, now=None): |
29772
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29673
diff
changeset
|
819 # notify callbacks about parents change |
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29673
diff
changeset
|
820 if self._origpl is not None and self._origpl != self._pl: |
43106
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43090
diff
changeset
|
821 for c, callback in sorted( |
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43090
diff
changeset
|
822 pycompat.iteritems(self._plchangecallbacks) |
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43090
diff
changeset
|
823 ): |
29772
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29673
diff
changeset
|
824 callback(self, self._origpl, self._pl) |
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29673
diff
changeset
|
825 self._origpl = None |
48055
84e7a86e3a63
dirstate: simplify the ambiguity clearing at write time
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48044
diff
changeset
|
826 |
84e7a86e3a63
dirstate: simplify the ambiguity clearing at write time
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48044
diff
changeset
|
827 if now is None: |
84e7a86e3a63
dirstate: simplify the ambiguity clearing at write time
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48044
diff
changeset
|
828 # use the modification time of the newly created temporary file as the |
84e7a86e3a63
dirstate: simplify the ambiguity clearing at write time
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48044
diff
changeset
|
829 # filesystem's notion of 'now' |
84e7a86e3a63
dirstate: simplify the ambiguity clearing at write time
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48044
diff
changeset
|
830 now = util.fstat(st)[stat.ST_MTIME] & _rangemask |
27397
6c6b48aca328
dirstate: move delaywrite logic from write to _write
Matt Mackall <mpm@selenic.com>
parents:
27176
diff
changeset
|
831 |
6c6b48aca328
dirstate: move delaywrite logic from write to _write
Matt Mackall <mpm@selenic.com>
parents:
27176
diff
changeset
|
832 # enough 'delaywrite' prevents 'pack_dirstate' from dropping |
6c6b48aca328
dirstate: move delaywrite logic from write to _write
Matt Mackall <mpm@selenic.com>
parents:
27176
diff
changeset
|
833 # timestamp of each entries in dirstate, because of 'now > mtime' |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
834 delaywrite = self._ui.configint(b'debug', b'dirstate.delaywrite') |
27397
6c6b48aca328
dirstate: move delaywrite logic from write to _write
Matt Mackall <mpm@selenic.com>
parents:
27176
diff
changeset
|
835 if delaywrite > 0: |
27398
c81675776c95
dirstate: only invoke delaywrite if relevant
Matt Mackall <mpm@selenic.com>
parents:
27397
diff
changeset
|
836 # do we have any files to delay for? |
43425
ed50f2c31a4c
rust-cpython: allow mutation unless leaked reference is borrowed
Yuya Nishihara <yuya@tcha.org>
parents:
43281
diff
changeset
|
837 for f, e in pycompat.iteritems(self._map): |
47532
ccbabaee5c36
dirstate-entry: add a `need_delay` method
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47531
diff
changeset
|
838 if e.need_delay(now): |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
839 import time # to avoid useless import |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
840 |
27399
425dc70037f7
dirstate: make delaywrite sleep until the next multiple of n seconds
Matt Mackall <mpm@selenic.com>
parents:
27398
diff
changeset
|
841 # rather than sleep n seconds, sleep until the next |
425dc70037f7
dirstate: make delaywrite sleep until the next multiple of n seconds
Matt Mackall <mpm@selenic.com>
parents:
27398
diff
changeset
|
842 # multiple of n seconds |
425dc70037f7
dirstate: make delaywrite sleep until the next multiple of n seconds
Matt Mackall <mpm@selenic.com>
parents:
27398
diff
changeset
|
843 clock = time.time() |
425dc70037f7
dirstate: make delaywrite sleep until the next multiple of n seconds
Matt Mackall <mpm@selenic.com>
parents:
27398
diff
changeset
|
844 start = int(clock) - (int(clock) % delaywrite) |
425dc70037f7
dirstate: make delaywrite sleep until the next multiple of n seconds
Matt Mackall <mpm@selenic.com>
parents:
27398
diff
changeset
|
845 end = start + delaywrite |
425dc70037f7
dirstate: make delaywrite sleep until the next multiple of n seconds
Matt Mackall <mpm@selenic.com>
parents:
27398
diff
changeset
|
846 time.sleep(end - clock) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
847 now = end # trust our estimate that the end is near now |
27398
c81675776c95
dirstate: only invoke delaywrite if relevant
Matt Mackall <mpm@selenic.com>
parents:
27397
diff
changeset
|
848 break |
27397
6c6b48aca328
dirstate: move delaywrite logic from write to _write
Matt Mackall <mpm@selenic.com>
parents:
27176
diff
changeset
|
849 |
47674
ff97e793ed36
dirstate-v2: Introduce a docket file
Simon Sapin <simon.sapin@octobus.net>
parents:
47673
diff
changeset
|
850 self._map.write(tr, st, now) |
21026
7ee03e190c1d
dirstate: inline local finish function
Mads Kiilerich <madski@unity3d.com>
parents:
20632
diff
changeset
|
851 self._lastnormaltime = 0 |
34673
e2214632c3a2
dirstate: move write into dirstatemap
Durham Goode <durham@fb.com>
parents:
34672
diff
changeset
|
852 self._dirty = False |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
853 |
6032
b41f0d6a74fc
dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5516
diff
changeset
|
854 def _dirignore(self, f): |
b41f0d6a74fc
dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5516
diff
changeset
|
855 if self._ignore(f): |
b41f0d6a74fc
dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5516
diff
changeset
|
856 return True |
43633
0b7733719d21
utils: move finddirs() to pathutil
Martin von Zweigbergk <martinvonz@google.com>
parents:
43620
diff
changeset
|
857 for p in pathutil.finddirs(f): |
6767
80605a8127e0
dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents:
6762
diff
changeset
|
858 if self._ignore(p): |
6032
b41f0d6a74fc
dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5516
diff
changeset
|
859 return True |
b41f0d6a74fc
dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5516
diff
changeset
|
860 return False |
b41f0d6a74fc
dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5516
diff
changeset
|
861 |
27594
0921caca7703
dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents:
27593
diff
changeset
|
862 def _ignorefiles(self): |
0921caca7703
dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents:
27593
diff
changeset
|
863 files = [] |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
864 if os.path.exists(self._join(b'.hgignore')): |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
865 files.append(self._join(b'.hgignore')) |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
866 for name, path in self._ui.configitems(b"ui"): |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
867 if name == b'ignore' or name.startswith(b'ignore.'): |
27594
0921caca7703
dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents:
27593
diff
changeset
|
868 # we need to use os.path.join here rather than self._join |
0921caca7703
dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents:
27593
diff
changeset
|
869 # because path is arbitrary and user-specified |
0921caca7703
dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents:
27593
diff
changeset
|
870 files.append(os.path.join(self._rootdir, util.expandpath(path))) |
0921caca7703
dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents:
27593
diff
changeset
|
871 return files |
0921caca7703
dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents:
27593
diff
changeset
|
872 |
27670
4374f039d269
dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents:
27594
diff
changeset
|
873 def _ignorefileandline(self, f): |
4374f039d269
dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents:
27594
diff
changeset
|
874 files = collections.deque(self._ignorefiles()) |
4374f039d269
dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents:
27594
diff
changeset
|
875 visited = set() |
4374f039d269
dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents:
27594
diff
changeset
|
876 while files: |
4374f039d269
dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents:
27594
diff
changeset
|
877 i = files.popleft() |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
878 patterns = matchmod.readpatternfile( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
879 i, self._ui.warn, sourceinfo=True |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
880 ) |
27670
4374f039d269
dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents:
27594
diff
changeset
|
881 for pattern, lineno, line in patterns: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
882 kind, p = matchmod._patsplit(pattern, b'glob') |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
883 if kind == b"subinclude": |
27670
4374f039d269
dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents:
27594
diff
changeset
|
884 if p not in visited: |
4374f039d269
dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents:
27594
diff
changeset
|
885 files.append(p) |
4374f039d269
dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents:
27594
diff
changeset
|
886 continue |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
887 m = matchmod.match( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
888 self._root, b'', [], [pattern], warn=self._ui.warn |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
889 ) |
27670
4374f039d269
dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents:
27594
diff
changeset
|
890 if m(f): |
4374f039d269
dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents:
27594
diff
changeset
|
891 return (i, lineno, line) |
4374f039d269
dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents:
27594
diff
changeset
|
892 visited.add(i) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
893 return (None, -1, b"") |
27670
4374f039d269
dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents:
27594
diff
changeset
|
894 |
19173
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
895 def _walkexplicit(self, match, subrepos): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45243
diff
changeset
|
896 """Get stat data about the files explicitly specified by match. |
3529 | 897 |
19174
022256ef47b8
dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents:
19173
diff
changeset
|
898 Return a triple (results, dirsfound, dirsnotfound). |
19173
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
899 - results is a mapping from filename to stat result. It also contains |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
900 listings mapping subrepos and .hg to None. |
19174
022256ef47b8
dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents:
19173
diff
changeset
|
901 - dirsfound is a list of files found to be directories. |
19173
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
902 - dirsnotfound is a list of files that the dirstate thinks are |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45243
diff
changeset
|
903 directories and that were not found.""" |
6578
f242d3684f83
walk: begin refactoring badmatch handling
Matt Mackall <mpm@selenic.com>
parents:
6577
diff
changeset
|
904 |
8681
26f133267cd7
walk: use match.bad callback for filetype messages
Matt Mackall <mpm@selenic.com>
parents:
8680
diff
changeset
|
905 def badtype(mode): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
906 kind = _(b'unknown') |
10282
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
907 if stat.S_ISCHR(mode): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
908 kind = _(b'character device') |
10282
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
909 elif stat.S_ISBLK(mode): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
910 kind = _(b'block device') |
10282
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
911 elif stat.S_ISFIFO(mode): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
912 kind = _(b'fifo') |
10282
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
913 elif stat.S_ISSOCK(mode): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
914 kind = _(b'socket') |
10282
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
915 elif stat.S_ISDIR(mode): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
916 kind = _(b'directory') |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
917 return _(b'unsupported file type (type is %s)') % kind |
6830
2cf4cda64727
dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents:
6829
diff
changeset
|
918 |
8676
acd69fc201a5
walk: we always have a badfn
Matt Mackall <mpm@selenic.com>
parents:
8675
diff
changeset
|
919 badfn = match.bad |
6831
2b663f542bd3
dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents:
6830
diff
changeset
|
920 dmap = self._map |
5000
46facb73ba8b
dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents:
4965
diff
changeset
|
921 lstat = os.lstat |
6830
2cf4cda64727
dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents:
6829
diff
changeset
|
922 getkind = stat.S_IFMT |
6828
55d65a33da52
dirstate.walk: minor cleanups
Matt Mackall <mpm@selenic.com>
parents:
6827
diff
changeset
|
923 dirkind = stat.S_IFDIR |
6830
2cf4cda64727
dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents:
6829
diff
changeset
|
924 regkind = stat.S_IFREG |
2cf4cda64727
dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents:
6829
diff
changeset
|
925 lnkkind = stat.S_IFLNK |
6831
2b663f542bd3
dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents:
6830
diff
changeset
|
926 join = self._join |
19174
022256ef47b8
dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents:
19173
diff
changeset
|
927 dirsfound = [] |
022256ef47b8
dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents:
19173
diff
changeset
|
928 foundadd = dirsfound.append |
19173
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
929 dirsnotfound = [] |
19175
63f7bd2e1a46
dirstate._walkexplicit: inline dirsnotfound.append
Siddharth Agarwal <sid0@fb.com>
parents:
19174
diff
changeset
|
930 notfoundadd = dirsnotfound.append |
6820
639d9cb95509
dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents:
6819
diff
changeset
|
931 |
24448
55c449345b10
match: add isexact() method to hide internals
Martin von Zweigbergk <martinvonz@google.com>
parents:
24212
diff
changeset
|
932 if not match.isexact() and self._checkcase: |
12907
e255a5dc29e6
dirstate: skip optimization on case-folding FS (issue2440)
Matt Mackall <mpm@selenic.com>
parents:
12401
diff
changeset
|
933 normalize = self._normalize |
e255a5dc29e6
dirstate: skip optimization on case-folding FS (issue2440)
Matt Mackall <mpm@selenic.com>
parents:
12401
diff
changeset
|
934 else: |
18032
a9e623bb440e
dirstate: test normalize is truthy instead of using a no-op lambda
Siddharth Agarwal <sid0@fb.com>
parents:
18018
diff
changeset
|
935 normalize = None |
12907
e255a5dc29e6
dirstate: skip optimization on case-folding FS (issue2440)
Matt Mackall <mpm@selenic.com>
parents:
12401
diff
changeset
|
936 |
12211
798d72f3621c
dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12164
diff
changeset
|
937 files = sorted(match.files()) |
798d72f3621c
dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12164
diff
changeset
|
938 subrepos.sort() |
798d72f3621c
dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12164
diff
changeset
|
939 i, j = 0, 0 |
798d72f3621c
dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12164
diff
changeset
|
940 while i < len(files) and j < len(subrepos): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
941 subpath = subrepos[j] + b"/" |
13233
0b30e6148ec5
subrepo: do not report known files inside repositories as unknown
Oleg Stepanov <oleg.stepanov@jetbrains.com>
parents:
12907
diff
changeset
|
942 if files[i] < subpath: |
12211
798d72f3621c
dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12164
diff
changeset
|
943 i += 1 |
798d72f3621c
dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12164
diff
changeset
|
944 continue |
13339
22167be007ed
subrepo: fix pruning of subrepo filenames in dirstate (issue2619)
trbs <trbs@trbs.net>
parents:
13233
diff
changeset
|
945 while i < len(files) and files[i].startswith(subpath): |
12211
798d72f3621c
dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12164
diff
changeset
|
946 del files[i] |
798d72f3621c
dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12164
diff
changeset
|
947 j += 1 |
798d72f3621c
dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12164
diff
changeset
|
948 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
949 if not files or b'' in files: |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
950 files = [b''] |
42340
7ada598941d2
dirstate: move special handling of files==['.'] together
Martin von Zweigbergk <martinvonz@google.com>
parents:
42304
diff
changeset
|
951 # constructing the foldmap is expensive, so don't do it for the |
42341
27d6956d386b
match: use '' instead of '.' for root directory (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42340
diff
changeset
|
952 # common case where files is [''] |
42340
7ada598941d2
dirstate: move special handling of files==['.'] together
Martin von Zweigbergk <martinvonz@google.com>
parents:
42304
diff
changeset
|
953 normalize = None |
10176
24ce8f0c0a39
dirstate: don't check state of subrepo directories
Augie Fackler <durin42@gmail.com>
parents:
10145
diff
changeset
|
954 results = dict.fromkeys(subrepos) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
955 results[b'.hg'] = None |
5000
46facb73ba8b
dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents:
4965
diff
changeset
|
956 |
12211
798d72f3621c
dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12164
diff
changeset
|
957 for ff in files: |
42340
7ada598941d2
dirstate: move special handling of files==['.'] together
Martin von Zweigbergk <martinvonz@google.com>
parents:
42304
diff
changeset
|
958 if normalize: |
24522
18085e46caa9
dirstate._walkexplicit: drop normpath calls
Siddharth Agarwal <sid0@fb.com>
parents:
24521
diff
changeset
|
959 nf = normalize(ff, False, True) |
18032
a9e623bb440e
dirstate: test normalize is truthy instead of using a no-op lambda
Siddharth Agarwal <sid0@fb.com>
parents:
18018
diff
changeset
|
960 else: |
24522
18085e46caa9
dirstate._walkexplicit: drop normpath calls
Siddharth Agarwal <sid0@fb.com>
parents:
24521
diff
changeset
|
961 nf = ff |
6829
fec1da46006e
dirstate.walk: build a dict rather than yield
Matt Mackall <mpm@selenic.com>
parents:
6828
diff
changeset
|
962 if nf in results: |
6820
639d9cb95509
dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents:
6819
diff
changeset
|
963 continue |
639d9cb95509
dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents:
6819
diff
changeset
|
964 |
639d9cb95509
dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents:
6819
diff
changeset
|
965 try: |
6831
2b663f542bd3
dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents:
6830
diff
changeset
|
966 st = lstat(join(nf)) |
6830
2cf4cda64727
dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents:
6829
diff
changeset
|
967 kind = getkind(st.st_mode) |
2cf4cda64727
dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents:
6829
diff
changeset
|
968 if kind == dirkind: |
8588
2624f485b9bc
dirstate: set more states in step 1 of walk
Simon Heimberg <simohe@besonet.ch>
parents:
8521
diff
changeset
|
969 if nf in dmap: |
21115
1b6e37f44250
dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents:
21026
diff
changeset
|
970 # file replaced by dir on disk but still in dirstate |
8588
2624f485b9bc
dirstate: set more states in step 1 of walk
Simon Heimberg <simohe@besonet.ch>
parents:
8521
diff
changeset
|
971 results[nf] = None |
24537
2bb13f2b778c
dirstate: don't require exact case when adding dirs on icasefs (issue4578)
Matt Harbison <matt_harbison@yahoo.com>
parents:
24198
diff
changeset
|
972 foundadd((nf, ff)) |
12401
4cdaf1adafc8
backout most of 4f8067c94729
Matt Mackall <mpm@selenic.com>
parents:
12387
diff
changeset
|
973 elif kind == regkind or kind == lnkkind: |
6830
2cf4cda64727
dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents:
6829
diff
changeset
|
974 results[nf] = st |
6828
55d65a33da52
dirstate.walk: minor cleanups
Matt Mackall <mpm@selenic.com>
parents:
6827
diff
changeset
|
975 else: |
8681
26f133267cd7
walk: use match.bad callback for filetype messages
Matt Mackall <mpm@selenic.com>
parents:
8680
diff
changeset
|
976 badfn(ff, badtype(kind)) |
6830
2cf4cda64727
dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents:
6829
diff
changeset
|
977 if nf in dmap: |
6829
fec1da46006e
dirstate.walk: build a dict rather than yield
Matt Mackall <mpm@selenic.com>
parents:
6828
diff
changeset
|
978 results[nf] = None |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
979 except OSError as inst: # nf not found on disk - it is dirstate only |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
980 if nf in dmap: # does it exactly match a missing file? |
8675
fb74e1e69da0
walk: simplify check for missing file
Matt Mackall <mpm@selenic.com>
parents:
8645
diff
changeset
|
981 results[nf] = None |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
982 else: # does it match a missing directory? |
35084
61888bd0b300
dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents:
35083
diff
changeset
|
983 if self._map.hasdir(nf): |
23375
a179db3db9b9
dirstate: speed up repeated missing directory checks
Martin von Zweigbergk <martinvonz@google.com>
parents:
22915
diff
changeset
|
984 notfoundadd(nf) |
8677
34df078b8b1b
walk: simplify logic for badfn clause
Matt Mackall <mpm@selenic.com>
parents:
8676
diff
changeset
|
985 else: |
34022
d5b2beca16c0
python3: wrap all uses of <exception>.strerror with strtolocal
Augie Fackler <raf@durin42.com>
parents:
33981
diff
changeset
|
986 badfn(ff, encoding.strtolocal(inst.strerror)) |
6820
639d9cb95509
dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents:
6819
diff
changeset
|
987 |
36200
deb851914fd7
dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents:
35895
diff
changeset
|
988 # match.files() may contain explicitly-specified paths that shouldn't |
deb851914fd7
dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents:
35895
diff
changeset
|
989 # be taken; drop them from the list of files found. dirsfound/notfound |
deb851914fd7
dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents:
35895
diff
changeset
|
990 # aren't filtered here because they will be tested later. |
deb851914fd7
dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents:
35895
diff
changeset
|
991 if match.anypats(): |
deb851914fd7
dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents:
35895
diff
changeset
|
992 for f in list(results): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
993 if f == b'.hg' or f in subrepos: |
36200
deb851914fd7
dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents:
35895
diff
changeset
|
994 # keep sentinel to disable further out-of-repo walks |
deb851914fd7
dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents:
35895
diff
changeset
|
995 continue |
deb851914fd7
dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents:
35895
diff
changeset
|
996 if not match(f): |
deb851914fd7
dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents:
35895
diff
changeset
|
997 del results[f] |
deb851914fd7
dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents:
35895
diff
changeset
|
998 |
25877
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
999 # Case insensitive filesystems cannot rely on lstat() failing to detect |
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
1000 # a case-only rename. Prune the stat object for any file that does not |
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
1001 # match the case in the filesystem, if there are multiple files that |
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
1002 # normalize to the same path. |
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
1003 if match.isexact() and self._checkcase: |
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
1004 normed = {} |
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
1005 |
43106
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43090
diff
changeset
|
1006 for f, st in pycompat.iteritems(results): |
25877
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
1007 if st is None: |
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
1008 continue |
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
1009 |
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
1010 nc = util.normcase(f) |
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
1011 paths = normed.get(nc) |
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
1012 |
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
1013 if paths is None: |
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
1014 paths = set() |
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
1015 normed[nc] = paths |
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
1016 |
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
1017 paths.add(f) |
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
1018 |
43106
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43090
diff
changeset
|
1019 for norm, paths in pycompat.iteritems(normed): |
25877
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
1020 if len(paths) > 1: |
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
1021 for path in paths: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1022 folded = self._discoverpath( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1023 path, norm, True, None, self._map.dirfoldmap |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1024 ) |
25877
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
1025 if path != folded: |
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
1026 results[path] = None |
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
1027 |
19174
022256ef47b8
dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents:
19173
diff
changeset
|
1028 return results, dirsfound, dirsnotfound |
19173
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
1029 |
19190
b03952ee634d
dirstate.walk: add a flag to let extensions avoid full walks
Siddharth Agarwal <sid0@fb.com>
parents:
19175
diff
changeset
|
1030 def walk(self, match, subrepos, unknown, ignored, full=True): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45243
diff
changeset
|
1031 """ |
19173
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
1032 Walk recursively through the directory tree, finding all files |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
1033 matched by match. |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
1034 |
19190
b03952ee634d
dirstate.walk: add a flag to let extensions avoid full walks
Siddharth Agarwal <sid0@fb.com>
parents:
19175
diff
changeset
|
1035 If full is False, maybe skip some known-clean files. |
b03952ee634d
dirstate.walk: add a flag to let extensions avoid full walks
Siddharth Agarwal <sid0@fb.com>
parents:
19175
diff
changeset
|
1036 |
19173
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
1037 Return a dict mapping filename to stat-like object (either |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
1038 mercurial.osutil.stat instance or return value of os.stat()). |
19190
b03952ee634d
dirstate.walk: add a flag to let extensions avoid full walks
Siddharth Agarwal <sid0@fb.com>
parents:
19175
diff
changeset
|
1039 |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45243
diff
changeset
|
1040 """ |
19190
b03952ee634d
dirstate.walk: add a flag to let extensions avoid full walks
Siddharth Agarwal <sid0@fb.com>
parents:
19175
diff
changeset
|
1041 # full is a flag that extensions that hook into walk can use -- this |
b03952ee634d
dirstate.walk: add a flag to let extensions avoid full walks
Siddharth Agarwal <sid0@fb.com>
parents:
19175
diff
changeset
|
1042 # implementation doesn't use it at all. This satisfies the contract |
b03952ee634d
dirstate.walk: add a flag to let extensions avoid full walks
Siddharth Agarwal <sid0@fb.com>
parents:
19175
diff
changeset
|
1043 # because we only guarantee a "maybe". |
19173
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
1044 |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
1045 if ignored: |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
1046 ignore = util.never |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
1047 dirignore = util.never |
21115
1b6e37f44250
dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents:
21026
diff
changeset
|
1048 elif unknown: |
1b6e37f44250
dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents:
21026
diff
changeset
|
1049 ignore = self._ignore |
1b6e37f44250
dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents:
21026
diff
changeset
|
1050 dirignore = self._dirignore |
1b6e37f44250
dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents:
21026
diff
changeset
|
1051 else: |
1b6e37f44250
dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents:
21026
diff
changeset
|
1052 # if not unknown and not ignored, drop dir recursion and step 2 |
19173
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
1053 ignore = util.always |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
1054 dirignore = util.always |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
1055 |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
1056 matchfn = match.matchfn |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
1057 matchalways = match.always() |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
1058 matchtdir = match.traversedir |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
1059 dmap = self._map |
32208
d74b0cff94a9
osutil: proxy through util (and platform) modules (API)
Yuya Nishihara <yuya@tcha.org>
parents:
32177
diff
changeset
|
1060 listdir = util.listdir |
19173
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
1061 lstat = os.lstat |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
1062 dirkind = stat.S_IFDIR |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
1063 regkind = stat.S_IFREG |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
1064 lnkkind = stat.S_IFLNK |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
1065 join = self._join |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
1066 |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
1067 exact = skipstep3 = False |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1068 if match.isexact(): # match.exact |
19173
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
1069 exact = True |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1070 dirignore = util.always # skip step 2 |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1071 elif match.prefix(): # match.match, no patterns |
19173
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
1072 skipstep3 = True |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
1073 |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
1074 if not exact and self._checkcase: |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
1075 normalize = self._normalize |
24541
e235b5dc5cf9
dirstate.walk: use the file foldmap to normalize
Siddharth Agarwal <sid0@fb.com>
parents:
24540
diff
changeset
|
1076 normalizefile = self._normalizefile |
19173
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
1077 skipstep3 = False |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
1078 else: |
24560
b38bcf18993c
dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents:
24559
diff
changeset
|
1079 normalize = self._normalize |
24541
e235b5dc5cf9
dirstate.walk: use the file foldmap to normalize
Siddharth Agarwal <sid0@fb.com>
parents:
24540
diff
changeset
|
1080 normalizefile = None |
19173
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
1081 |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
1082 # step 1: find all explicit files |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
1083 results, work, dirsnotfound = self._walkexplicit(match, subrepos) |
43713
95d2eab0a7b9
dirstate: include explicit matches in match.traversedir calls
Martin von Zweigbergk <martinvonz@google.com>
parents:
43696
diff
changeset
|
1084 if matchtdir: |
95d2eab0a7b9
dirstate: include explicit matches in match.traversedir calls
Martin von Zweigbergk <martinvonz@google.com>
parents:
43696
diff
changeset
|
1085 for d in work: |
95d2eab0a7b9
dirstate: include explicit matches in match.traversedir calls
Martin von Zweigbergk <martinvonz@google.com>
parents:
43696
diff
changeset
|
1086 matchtdir(d[0]) |
95d2eab0a7b9
dirstate: include explicit matches in match.traversedir calls
Martin von Zweigbergk <martinvonz@google.com>
parents:
43696
diff
changeset
|
1087 for d in dirsnotfound: |
95d2eab0a7b9
dirstate: include explicit matches in match.traversedir calls
Martin von Zweigbergk <martinvonz@google.com>
parents:
43696
diff
changeset
|
1088 matchtdir(d) |
19173
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
1089 |
19172
c6cea2e2031b
dirstate.walk: pull skipstep3 out of the explicit walk code
Siddharth Agarwal <sid0@fb.com>
parents:
19171
diff
changeset
|
1090 skipstep3 = skipstep3 and not (work or dirsnotfound) |
24537
2bb13f2b778c
dirstate: don't require exact case when adding dirs on icasefs (issue4578)
Matt Harbison <matt_harbison@yahoo.com>
parents:
24198
diff
changeset
|
1091 work = [d for d in work if not dirignore(d[0])] |
19171
252de7b77cfd
dirstate.walk: move dirignore filter out of explicit walk code
Siddharth Agarwal <sid0@fb.com>
parents:
19170
diff
changeset
|
1092 |
6826
eca20fee0728
dirstate.walk: pull directory scanning into top-level loop
Matt Mackall <mpm@selenic.com>
parents:
6825
diff
changeset
|
1093 # step 2: visit subdirectories |
24560
b38bcf18993c
dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents:
24559
diff
changeset
|
1094 def traverse(work, alreadynormed): |
24559
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
1095 wadd = work.append |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
1096 while work: |
43239
6fcdcea2b03a
dirstate: add some traces on listdir calls
Augie Fackler <augie@google.com>
parents:
43117
diff
changeset
|
1097 tracing.counter('dirstate.walk work', len(work)) |
24560
b38bcf18993c
dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents:
24559
diff
changeset
|
1098 nd = work.pop() |
38956
a3cabe9415e1
dirstate: use visitchildrenset in traverse
Kyle Lippincott <spectral@google.com>
parents:
36995
diff
changeset
|
1099 visitentries = match.visitchildrenset(nd) |
a3cabe9415e1
dirstate: use visitchildrenset in traverse
Kyle Lippincott <spectral@google.com>
parents:
36995
diff
changeset
|
1100 if not visitentries: |
32177
8f1a2b848b52
dirstate: optimize walk() by using match.visitdir()
Martin von Zweigbergk <martinvonz@google.com>
parents:
31547
diff
changeset
|
1101 continue |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1102 if visitentries == b'this' or visitentries == b'all': |
38956
a3cabe9415e1
dirstate: use visitchildrenset in traverse
Kyle Lippincott <spectral@google.com>
parents:
36995
diff
changeset
|
1103 visitentries = None |
24559
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
1104 skip = None |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1105 if nd != b'': |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1106 skip = b'.hg' |
24559
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
1107 try: |
43239
6fcdcea2b03a
dirstate: add some traces on listdir calls
Augie Fackler <augie@google.com>
parents:
43117
diff
changeset
|
1108 with tracing.log('dirstate.walk.traverse listdir %s', nd): |
6fcdcea2b03a
dirstate: add some traces on listdir calls
Augie Fackler <augie@google.com>
parents:
43117
diff
changeset
|
1109 entries = listdir(join(nd), stat=True, skip=skip) |
25660
328739ea70c3
global: mass rewrite to use modern exception syntax
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25658
diff
changeset
|
1110 except OSError as inst: |
24559
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
1111 if inst.errno in (errno.EACCES, errno.ENOENT): |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1112 match.bad( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1113 self.pathto(nd), encoding.strtolocal(inst.strerror) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1114 ) |
24559
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
1115 continue |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
1116 raise |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
1117 for f, kind, st in entries: |
39260
27946fca8a05
match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents:
38959
diff
changeset
|
1118 # Some matchers may return files in the visitentries set, |
27946fca8a05
match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents:
38959
diff
changeset
|
1119 # instead of 'this', if the matcher explicitly mentions them |
27946fca8a05
match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents:
38959
diff
changeset
|
1120 # and is not an exactmatcher. This is acceptable; we do not |
27946fca8a05
match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents:
38959
diff
changeset
|
1121 # make any hard assumptions about file-or-directory below |
27946fca8a05
match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents:
38959
diff
changeset
|
1122 # based on the presence of `f` in visitentries. If |
27946fca8a05
match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents:
38959
diff
changeset
|
1123 # visitchildrenset returned a set, we can always skip the |
27946fca8a05
match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents:
38959
diff
changeset
|
1124 # entries *not* in the set it provided regardless of whether |
27946fca8a05
match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents:
38959
diff
changeset
|
1125 # they're actually a file or a directory. |
38956
a3cabe9415e1
dirstate: use visitchildrenset in traverse
Kyle Lippincott <spectral@google.com>
parents:
36995
diff
changeset
|
1126 if visitentries and f not in visitentries: |
a3cabe9415e1
dirstate: use visitchildrenset in traverse
Kyle Lippincott <spectral@google.com>
parents:
36995
diff
changeset
|
1127 continue |
24559
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
1128 if normalizefile: |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
1129 # even though f might be a directory, we're only |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
1130 # interested in comparing it to files currently in the |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
1131 # dmap -- therefore normalizefile is enough |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1132 nf = normalizefile( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1133 nd and (nd + b"/" + f) or f, True, True |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1134 ) |
24559
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
1135 else: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1136 nf = nd and (nd + b"/" + f) or f |
24559
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
1137 if nf not in results: |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
1138 if kind == dirkind: |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
1139 if not ignore(nf): |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
1140 if matchtdir: |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
1141 matchtdir(nf) |
24560
b38bcf18993c
dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents:
24559
diff
changeset
|
1142 wadd(nf) |
24559
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
1143 if nf in dmap and (matchalways or matchfn(nf)): |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
1144 results[nf] = None |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
1145 elif kind == regkind or kind == lnkkind: |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
1146 if nf in dmap: |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
1147 if matchalways or matchfn(nf): |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
1148 results[nf] = st |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1149 elif (matchalways or matchfn(nf)) and not ignore( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1150 nf |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1151 ): |
24560
b38bcf18993c
dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents:
24559
diff
changeset
|
1152 # unknown file -- normalize if necessary |
b38bcf18993c
dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents:
24559
diff
changeset
|
1153 if not alreadynormed: |
b38bcf18993c
dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents:
24559
diff
changeset
|
1154 nf = normalize(nf, False, True) |
24559
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
1155 results[nf] = st |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
1156 elif nf in dmap and (matchalways or matchfn(nf)): |
6829
fec1da46006e
dirstate.walk: build a dict rather than yield
Matt Mackall <mpm@selenic.com>
parents:
6828
diff
changeset
|
1157 results[nf] = None |
24559
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
1158 |
24560
b38bcf18993c
dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents:
24559
diff
changeset
|
1159 for nd, d in work: |
b38bcf18993c
dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents:
24559
diff
changeset
|
1160 # alreadynormed means that processwork doesn't have to do any |
b38bcf18993c
dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents:
24559
diff
changeset
|
1161 # expensive directory normalization |
b38bcf18993c
dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents:
24559
diff
changeset
|
1162 alreadynormed = not normalize or nd == d |
b38bcf18993c
dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents:
24559
diff
changeset
|
1163 traverse([d], alreadynormed) |
536 | 1164 |
18812
1c40526da52a
dirstate.walk: remove subrepo and .hg from results before step 3
Siddharth Agarwal <sid0@fb.com>
parents:
18792
diff
changeset
|
1165 for s in subrepos: |
1c40526da52a
dirstate.walk: remove subrepo and .hg from results before step 3
Siddharth Agarwal <sid0@fb.com>
parents:
18792
diff
changeset
|
1166 del results[s] |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1167 del results[b'.hg'] |
18812
1c40526da52a
dirstate.walk: remove subrepo and .hg from results before step 3
Siddharth Agarwal <sid0@fb.com>
parents:
18792
diff
changeset
|
1168 |
21115
1b6e37f44250
dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents:
21026
diff
changeset
|
1169 # step 3: visit remaining files from dmap |
8684
5bb7780b57c7
match: fold plan cases down to two special cases
Matt Mackall <mpm@selenic.com>
parents:
8683
diff
changeset
|
1170 if not skipstep3 and not exact: |
21115
1b6e37f44250
dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents:
21026
diff
changeset
|
1171 # If a dmap file is not in results yet, it was either |
1b6e37f44250
dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents:
21026
diff
changeset
|
1172 # a) not matching matchfn b) ignored, c) missing, or d) under a |
1b6e37f44250
dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents:
21026
diff
changeset
|
1173 # symlink directory. |
18815
a18919de61e5
dirstate.walk: fast path none-seen + match-always case for step 3
Siddharth Agarwal <sid0@fb.com>
parents:
18814
diff
changeset
|
1174 if not results and matchalways: |
31422
2e38a88bbc6c
dirstate: use list comprehension to get a list of keys
Pulkit Goyal <7895pulkit@gmail.com>
parents:
31278
diff
changeset
|
1175 visit = [f for f in dmap] |
18815
a18919de61e5
dirstate.walk: fast path none-seen + match-always case for step 3
Siddharth Agarwal <sid0@fb.com>
parents:
18814
diff
changeset
|
1176 else: |
a18919de61e5
dirstate.walk: fast path none-seen + match-always case for step 3
Siddharth Agarwal <sid0@fb.com>
parents:
18814
diff
changeset
|
1177 visit = [f for f in dmap if f not in results and matchfn(f)] |
a18919de61e5
dirstate.walk: fast path none-seen + match-always case for step 3
Siddharth Agarwal <sid0@fb.com>
parents:
18814
diff
changeset
|
1178 visit.sort() |
a18919de61e5
dirstate.walk: fast path none-seen + match-always case for step 3
Siddharth Agarwal <sid0@fb.com>
parents:
18814
diff
changeset
|
1179 |
18625
2cbd27f4f3c4
dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents:
18567
diff
changeset
|
1180 if unknown: |
21115
1b6e37f44250
dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents:
21026
diff
changeset
|
1181 # unknown == True means we walked all dirs under the roots |
1b6e37f44250
dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents:
21026
diff
changeset
|
1182 # that wasn't ignored, and everything that matched was stat'ed |
1b6e37f44250
dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents:
21026
diff
changeset
|
1183 # and is already in results. |
1b6e37f44250
dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents:
21026
diff
changeset
|
1184 # The rest must thus be ignored or under a symlink. |
33649
377e8ddaebef
pathauditor: disable cache of audited paths by default (issue5628)
Yuya Nishihara <yuya@tcha.org>
parents:
33440
diff
changeset
|
1185 audit_path = pathutil.pathauditor(self._root, cached=True) |
18625
2cbd27f4f3c4
dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents:
18567
diff
changeset
|
1186 |
2cbd27f4f3c4
dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents:
18567
diff
changeset
|
1187 for nf in iter(visit): |
24621
1784ca148392
dirstate.walk: don't report same file stat multiple times
Martin von Zweigbergk <martinvonz@google.com>
parents:
24537
diff
changeset
|
1188 # If a stat for the same file was already added with a |
1784ca148392
dirstate.walk: don't report same file stat multiple times
Martin von Zweigbergk <martinvonz@google.com>
parents:
24537
diff
changeset
|
1189 # different case, don't add one for this, since that would |
1784ca148392
dirstate.walk: don't report same file stat multiple times
Martin von Zweigbergk <martinvonz@google.com>
parents:
24537
diff
changeset
|
1190 # make it appear as if the file exists under both names |
1784ca148392
dirstate.walk: don't report same file stat multiple times
Martin von Zweigbergk <martinvonz@google.com>
parents:
24537
diff
changeset
|
1191 # on disk. |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1192 if ( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1193 normalizefile |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1194 and normalizefile(nf, True, True) in results |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1195 ): |
24621
1784ca148392
dirstate.walk: don't report same file stat multiple times
Martin von Zweigbergk <martinvonz@google.com>
parents:
24537
diff
changeset
|
1196 results[nf] = None |
18625
2cbd27f4f3c4
dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents:
18567
diff
changeset
|
1197 # Report ignored items in the dmap as long as they are not |
2cbd27f4f3c4
dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents:
18567
diff
changeset
|
1198 # under a symlink directory. |
24621
1784ca148392
dirstate.walk: don't report same file stat multiple times
Martin von Zweigbergk <martinvonz@google.com>
parents:
24537
diff
changeset
|
1199 elif audit_path.check(nf): |
18663
05cf40f9b0ec
dirstate: fix generator/list error when using python 2.7
Durham Goode <durham@fb.com>
parents:
18653
diff
changeset
|
1200 try: |
05cf40f9b0ec
dirstate: fix generator/list error when using python 2.7
Durham Goode <durham@fb.com>
parents:
18653
diff
changeset
|
1201 results[nf] = lstat(join(nf)) |
21115
1b6e37f44250
dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents:
21026
diff
changeset
|
1202 # file was just ignored, no links, and exists |
18663
05cf40f9b0ec
dirstate: fix generator/list error when using python 2.7
Durham Goode <durham@fb.com>
parents:
18653
diff
changeset
|
1203 except OSError: |
05cf40f9b0ec
dirstate: fix generator/list error when using python 2.7
Durham Goode <durham@fb.com>
parents:
18653
diff
changeset
|
1204 # file doesn't exist |
05cf40f9b0ec
dirstate: fix generator/list error when using python 2.7
Durham Goode <durham@fb.com>
parents:
18653
diff
changeset
|
1205 results[nf] = None |
18625
2cbd27f4f3c4
dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents:
18567
diff
changeset
|
1206 else: |
2cbd27f4f3c4
dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents:
18567
diff
changeset
|
1207 # It's either missing or under a symlink directory |
21115
1b6e37f44250
dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents:
21026
diff
changeset
|
1208 # which we in this case report as missing |
18625
2cbd27f4f3c4
dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents:
18567
diff
changeset
|
1209 results[nf] = None |
2cbd27f4f3c4
dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents:
18567
diff
changeset
|
1210 else: |
2cbd27f4f3c4
dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents:
18567
diff
changeset
|
1211 # We may not have walked the full directory tree above, |
21115
1b6e37f44250
dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents:
21026
diff
changeset
|
1212 # so stat and check everything we missed. |
31507
4d1dd9cf0dca
dirstate: use future-proof next(iter) instead of iter.next
Augie Fackler <augie@google.com>
parents:
31422
diff
changeset
|
1213 iv = iter(visit) |
26984
af2663680e95
dirstate: back out 502b56a9e897
Bryan O'Sullivan <bos@serpentine.com>
parents:
26887
diff
changeset
|
1214 for st in util.statfiles([join(i) for i in visit]): |
31507
4d1dd9cf0dca
dirstate: use future-proof next(iter) instead of iter.next
Augie Fackler <augie@google.com>
parents:
31422
diff
changeset
|
1215 results[next(iv)] = st |
6829
fec1da46006e
dirstate.walk: build a dict rather than yield
Matt Mackall <mpm@selenic.com>
parents:
6828
diff
changeset
|
1216 return results |
669
8aa2a282eda4
.hgignore speedups patch incorporating Matt's feedback.
mwilli2@localhost.localdomain
parents:
667
diff
changeset
|
1217 |
44530
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1218 def _rust_status(self, matcher, list_clean, list_ignored, list_unknown): |
44078
f2c350e7371e
dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents:
43917
diff
changeset
|
1219 # Force Rayon (Rust parallelism library) to respect the number of |
f2c350e7371e
dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents:
43917
diff
changeset
|
1220 # workers. This is a temporary workaround until Rust code knows |
f2c350e7371e
dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents:
43917
diff
changeset
|
1221 # how to read the config file. |
f2c350e7371e
dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents:
43917
diff
changeset
|
1222 numcpus = self._ui.configint(b"worker", b"numcpus") |
f2c350e7371e
dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents:
43917
diff
changeset
|
1223 if numcpus is not None: |
f2c350e7371e
dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents:
43917
diff
changeset
|
1224 encoding.environ.setdefault(b'RAYON_NUM_THREADS', b'%d' % numcpus) |
f2c350e7371e
dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents:
43917
diff
changeset
|
1225 |
f2c350e7371e
dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents:
43917
diff
changeset
|
1226 workers_enabled = self._ui.configbool(b"worker", b"enabled", True) |
f2c350e7371e
dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents:
43917
diff
changeset
|
1227 if not workers_enabled: |
f2c350e7371e
dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents:
43917
diff
changeset
|
1228 encoding.environ[b"RAYON_NUM_THREADS"] = b"1" |
f2c350e7371e
dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents:
43917
diff
changeset
|
1229 |
f2c350e7371e
dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents:
43917
diff
changeset
|
1230 ( |
f2c350e7371e
dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents:
43917
diff
changeset
|
1231 lookup, |
f2c350e7371e
dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents:
43917
diff
changeset
|
1232 modified, |
f2c350e7371e
dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents:
43917
diff
changeset
|
1233 added, |
f2c350e7371e
dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents:
43917
diff
changeset
|
1234 removed, |
f2c350e7371e
dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents:
43917
diff
changeset
|
1235 deleted, |
44530
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1236 clean, |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1237 ignored, |
44078
f2c350e7371e
dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents:
43917
diff
changeset
|
1238 unknown, |
44530
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1239 warnings, |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1240 bad, |
44840
4ba2a6ffcf24
status: also support for `traversedir` callback in the Rust fast-path
Raphaël Gomès <rgomes@octobus.net>
parents:
44836
diff
changeset
|
1241 traversed, |
47350
04d1f17f49e7
dirstate-v2: Write .hg/dirstate back to disk on directory cache changes
Simon Sapin <simon.sapin@octobus.net>
parents:
47320
diff
changeset
|
1242 dirty, |
44078
f2c350e7371e
dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents:
43917
diff
changeset
|
1243 ) = rustmod.status( |
48121
5fc2dfb073d6
dirstatemap: rename `_rustmap` to `_map`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48107
diff
changeset
|
1244 self._map._map, |
44078
f2c350e7371e
dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents:
43917
diff
changeset
|
1245 matcher, |
f2c350e7371e
dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents:
43917
diff
changeset
|
1246 self._rootdir, |
44530
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1247 self._ignorefiles(), |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1248 self._checkexec, |
44078
f2c350e7371e
dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents:
43917
diff
changeset
|
1249 self._lastnormaltime, |
44530
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1250 bool(list_clean), |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1251 bool(list_ignored), |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1252 bool(list_unknown), |
44840
4ba2a6ffcf24
status: also support for `traversedir` callback in the Rust fast-path
Raphaël Gomès <rgomes@octobus.net>
parents:
44836
diff
changeset
|
1253 bool(matcher.traversedir), |
44078
f2c350e7371e
dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents:
43917
diff
changeset
|
1254 ) |
44840
4ba2a6ffcf24
status: also support for `traversedir` callback in the Rust fast-path
Raphaël Gomès <rgomes@octobus.net>
parents:
44836
diff
changeset
|
1255 |
47350
04d1f17f49e7
dirstate-v2: Write .hg/dirstate back to disk on directory cache changes
Simon Sapin <simon.sapin@octobus.net>
parents:
47320
diff
changeset
|
1256 self._dirty |= dirty |
04d1f17f49e7
dirstate-v2: Write .hg/dirstate back to disk on directory cache changes
Simon Sapin <simon.sapin@octobus.net>
parents:
47320
diff
changeset
|
1257 |
44840
4ba2a6ffcf24
status: also support for `traversedir` callback in the Rust fast-path
Raphaël Gomès <rgomes@octobus.net>
parents:
44836
diff
changeset
|
1258 if matcher.traversedir: |
4ba2a6ffcf24
status: also support for `traversedir` callback in the Rust fast-path
Raphaël Gomès <rgomes@octobus.net>
parents:
44836
diff
changeset
|
1259 for dir in traversed: |
4ba2a6ffcf24
status: also support for `traversedir` callback in the Rust fast-path
Raphaël Gomès <rgomes@octobus.net>
parents:
44836
diff
changeset
|
1260 matcher.traversedir(dir) |
4ba2a6ffcf24
status: also support for `traversedir` callback in the Rust fast-path
Raphaël Gomès <rgomes@octobus.net>
parents:
44836
diff
changeset
|
1261 |
44530
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1262 if self._ui.warn: |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1263 for item in warnings: |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1264 if isinstance(item, tuple): |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1265 file_path, syntax = item |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1266 msg = _(b"%s: ignoring invalid syntax '%s'\n") % ( |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1267 file_path, |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1268 syntax, |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1269 ) |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1270 self._ui.warn(msg) |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1271 else: |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1272 msg = _(b"skipping unreadable pattern file '%s': %s\n") |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1273 self._ui.warn( |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1274 msg |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1275 % ( |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1276 pathutil.canonpath( |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1277 self._rootdir, self._rootdir, item |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1278 ), |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1279 b"No such file or directory", |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1280 ) |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1281 ) |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1282 |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1283 for (fn, message) in bad: |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1284 matcher.bad(fn, encoding.strtolocal(message)) |
44078
f2c350e7371e
dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents:
43917
diff
changeset
|
1285 |
f2c350e7371e
dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents:
43917
diff
changeset
|
1286 status = scmutil.status( |
f2c350e7371e
dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents:
43917
diff
changeset
|
1287 modified=modified, |
f2c350e7371e
dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents:
43917
diff
changeset
|
1288 added=added, |
f2c350e7371e
dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents:
43917
diff
changeset
|
1289 removed=removed, |
f2c350e7371e
dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents:
43917
diff
changeset
|
1290 deleted=deleted, |
f2c350e7371e
dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents:
43917
diff
changeset
|
1291 unknown=unknown, |
44530
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1292 ignored=ignored, |
44078
f2c350e7371e
dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents:
43917
diff
changeset
|
1293 clean=clean, |
f2c350e7371e
dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents:
43917
diff
changeset
|
1294 ) |
f2c350e7371e
dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents:
43917
diff
changeset
|
1295 return (lookup, status) |
f2c350e7371e
dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents:
43917
diff
changeset
|
1296 |
10176
24ce8f0c0a39
dirstate: don't check state of subrepo directories
Augie Fackler <durin42@gmail.com>
parents:
10145
diff
changeset
|
1297 def status(self, match, subrepos, ignored, clean, unknown): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45243
diff
changeset
|
1298 """Determine the status of the working copy relative to the |
22915
4d680deb0d9e
status: update and move documentation of status types to status class
Martin von Zweigbergk <martinvonz@gmail.com>
parents:
22913
diff
changeset
|
1299 dirstate and return a pair of (unsure, status), where status is of type |
4d680deb0d9e
status: update and move documentation of status types to status class
Martin von Zweigbergk <martinvonz@gmail.com>
parents:
22913
diff
changeset
|
1300 scmutil.status and: |
9518
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
1301 |
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
1302 unsure: |
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
1303 files that might have been modified since the dirstate was |
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
1304 written, but need to be read to be sure (size is the same |
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
1305 but mtime differs) |
22915
4d680deb0d9e
status: update and move documentation of status types to status class
Martin von Zweigbergk <martinvonz@gmail.com>
parents:
22913
diff
changeset
|
1306 status.modified: |
9518
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
1307 files that have definitely been modified since the dirstate |
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
1308 was written (different size or mode) |
22915
4d680deb0d9e
status: update and move documentation of status types to status class
Martin von Zweigbergk <martinvonz@gmail.com>
parents:
22913
diff
changeset
|
1309 status.clean: |
9518
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
1310 files that have definitely not been modified since the |
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
1311 dirstate was written |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45243
diff
changeset
|
1312 """ |
6753
ed5ffb2c12f3
repo.status: eliminate list_
Matt Mackall <mpm@selenic.com>
parents:
6750
diff
changeset
|
1313 listignored, listclean, listunknown = ignored, clean, unknown |
2022
a59da8cc35e4
New option -i/--ignored for 'hg status' to show ignored files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
2008
diff
changeset
|
1314 lookup, modified, added, unknown, ignored = [], [], [], [], [] |
2661
5c10b7ed3411
status: add -c (clean) and -A (all files) options
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2486
diff
changeset
|
1315 removed, deleted, clean = [], [], [] |
723 | 1316 |
5003
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
1317 dmap = self._map |
34935
ffeea2406276
dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents:
34934
diff
changeset
|
1318 dmap.preload() |
43274
733d4ffcd667
rust-dirstate-status: add call to rust-fast path for `dirstate.status`
Raphaël Gomès <rgomes@octobus.net>
parents:
43239
diff
changeset
|
1319 |
733d4ffcd667
rust-dirstate-status: add call to rust-fast path for `dirstate.status`
Raphaël Gomès <rgomes@octobus.net>
parents:
43239
diff
changeset
|
1320 use_rust = True |
43917
40fd1ef4e4c1
rust-matchers: add support for `exactmatcher` in `dirstate.status`
Raphaël Gomès <rgomes@octobus.net>
parents:
43891
diff
changeset
|
1321 |
44530
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1322 allowed_matchers = ( |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1323 matchmod.alwaysmatcher, |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1324 matchmod.exactmatcher, |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1325 matchmod.includematcher, |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1326 ) |
43917
40fd1ef4e4c1
rust-matchers: add support for `exactmatcher` in `dirstate.status`
Raphaël Gomès <rgomes@octobus.net>
parents:
43891
diff
changeset
|
1327 |
43274
733d4ffcd667
rust-dirstate-status: add call to rust-fast path for `dirstate.status`
Raphaël Gomès <rgomes@octobus.net>
parents:
43239
diff
changeset
|
1328 if rustmod is None: |
733d4ffcd667
rust-dirstate-status: add call to rust-fast path for `dirstate.status`
Raphaël Gomès <rgomes@octobus.net>
parents:
43239
diff
changeset
|
1329 use_rust = False |
44530
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1330 elif self._checkcase: |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1331 # Case-insensitive filesystems are not handled yet |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1332 use_rust = False |
43274
733d4ffcd667
rust-dirstate-status: add call to rust-fast path for `dirstate.status`
Raphaël Gomès <rgomes@octobus.net>
parents:
43239
diff
changeset
|
1333 elif subrepos: |
733d4ffcd667
rust-dirstate-status: add call to rust-fast path for `dirstate.status`
Raphaël Gomès <rgomes@octobus.net>
parents:
43239
diff
changeset
|
1334 use_rust = False |
44530
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1335 elif sparse.enabled: |
43274
733d4ffcd667
rust-dirstate-status: add call to rust-fast path for `dirstate.status`
Raphaël Gomès <rgomes@octobus.net>
parents:
43239
diff
changeset
|
1336 use_rust = False |
43917
40fd1ef4e4c1
rust-matchers: add support for `exactmatcher` in `dirstate.status`
Raphaël Gomès <rgomes@octobus.net>
parents:
43891
diff
changeset
|
1337 elif not isinstance(match, allowed_matchers): |
44836
63edfea7dfde
status: update comment to reflect the more recent situation
Raphaël Gomès <rgomes@octobus.net>
parents:
44801
diff
changeset
|
1338 # Some matchers have yet to be implemented |
43274
733d4ffcd667
rust-dirstate-status: add call to rust-fast path for `dirstate.status`
Raphaël Gomès <rgomes@octobus.net>
parents:
43239
diff
changeset
|
1339 use_rust = False |
733d4ffcd667
rust-dirstate-status: add call to rust-fast path for `dirstate.status`
Raphaël Gomès <rgomes@octobus.net>
parents:
43239
diff
changeset
|
1340 |
733d4ffcd667
rust-dirstate-status: add call to rust-fast path for `dirstate.status`
Raphaël Gomès <rgomes@octobus.net>
parents:
43239
diff
changeset
|
1341 if use_rust: |
44530
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1342 try: |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1343 return self._rust_status( |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1344 match, listclean, listignored, listunknown |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1345 ) |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1346 except rustmod.FallbackError: |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1347 pass |
43274
733d4ffcd667
rust-dirstate-status: add call to rust-fast path for `dirstate.status`
Raphaël Gomès <rgomes@octobus.net>
parents:
43239
diff
changeset
|
1348 |
43620
dd773340a085
dirstate: respect request to not list unknown/ignored/clean files (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
43612
diff
changeset
|
1349 def noop(f): |
dd773340a085
dirstate: respect request to not list unknown/ignored/clean files (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
43612
diff
changeset
|
1350 pass |
dd773340a085
dirstate: respect request to not list unknown/ignored/clean files (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
43612
diff
changeset
|
1351 |
34935
ffeea2406276
dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents:
34934
diff
changeset
|
1352 dcontains = dmap.__contains__ |
ffeea2406276
dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents:
34934
diff
changeset
|
1353 dget = dmap.__getitem__ |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1354 ladd = lookup.append # aka "unsure" |
5003
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
1355 madd = modified.append |
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
1356 aadd = added.append |
43620
dd773340a085
dirstate: respect request to not list unknown/ignored/clean files (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
43612
diff
changeset
|
1357 uadd = unknown.append if listunknown else noop |
dd773340a085
dirstate: respect request to not list unknown/ignored/clean files (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
43612
diff
changeset
|
1358 iadd = ignored.append if listignored else noop |
5003
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
1359 radd = removed.append |
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
1360 dadd = deleted.append |
43620
dd773340a085
dirstate: respect request to not list unknown/ignored/clean files (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
43612
diff
changeset
|
1361 cadd = clean.append if listclean else noop |
18034
1a570f04de07
dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents:
18032
diff
changeset
|
1362 mexact = match.exact |
1a570f04de07
dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents:
18032
diff
changeset
|
1363 dirignore = self._dirignore |
1a570f04de07
dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents:
18032
diff
changeset
|
1364 checkexec = self._checkexec |
34336
0865d25e8a8a
dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34335
diff
changeset
|
1365 copymap = self._map.copymap |
18034
1a570f04de07
dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents:
18032
diff
changeset
|
1366 lastnormaltime = self._lastnormaltime |
5003
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
1367 |
19191
ab9de1e8fc36
dirstate.status: avoid full walks when possible
Siddharth Agarwal <sid0@fb.com>
parents:
19190
diff
changeset
|
1368 # We need to do full walks when either |
ab9de1e8fc36
dirstate.status: avoid full walks when possible
Siddharth Agarwal <sid0@fb.com>
parents:
19190
diff
changeset
|
1369 # - we're listing all clean files, or |
ab9de1e8fc36
dirstate.status: avoid full walks when possible
Siddharth Agarwal <sid0@fb.com>
parents:
19190
diff
changeset
|
1370 # - match.traversedir does something, because match.traversedir should |
ab9de1e8fc36
dirstate.status: avoid full walks when possible
Siddharth Agarwal <sid0@fb.com>
parents:
19190
diff
changeset
|
1371 # be called for every dir in the working dir |
ab9de1e8fc36
dirstate.status: avoid full walks when possible
Siddharth Agarwal <sid0@fb.com>
parents:
19190
diff
changeset
|
1372 full = listclean or match.traversedir is not None |
43106
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43090
diff
changeset
|
1373 for fn, st in pycompat.iteritems( |
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43090
diff
changeset
|
1374 self.walk(match, subrepos, listunknown, listignored, full=full) |
d783f945a701
py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43090
diff
changeset
|
1375 ): |
34935
ffeea2406276
dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents:
34934
diff
changeset
|
1376 if not dcontains(fn): |
18034
1a570f04de07
dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents:
18032
diff
changeset
|
1377 if (listignored or mexact(fn)) and dirignore(fn): |
6753
ed5ffb2c12f3
repo.status: eliminate list_
Matt Mackall <mpm@selenic.com>
parents:
6750
diff
changeset
|
1378 if listignored: |
6033
a1ebd5cd7e55
dirstate.status: avoid putting ignored files in the unknown list
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
6032
diff
changeset
|
1379 iadd(fn) |
19910
601944f41257
dirstate.status: return explicit unknown files even when not asked
Siddharth Agarwal <sid0@fb.com>
parents:
19651
diff
changeset
|
1380 else: |
5003
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
1381 uadd(fn) |
1471
f56f38a1a85f
rewrote changes function in dirstate to use generic walk code
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1402
diff
changeset
|
1382 continue |
6591
eda3fd322a7f
dirstate: minor status cleanups
Matt Mackall <mpm@selenic.com>
parents:
6590
diff
changeset
|
1383 |
21810
4b2ebd3187a1
dirstate.status: assign members one by one instead of unpacking the tuple
Siddharth Agarwal <sid0@fb.com>
parents:
21809
diff
changeset
|
1384 # This is equivalent to 'state, mode, size, time = dmap[fn]' but not |
4b2ebd3187a1
dirstate.status: assign members one by one instead of unpacking the tuple
Siddharth Agarwal <sid0@fb.com>
parents:
21809
diff
changeset
|
1385 # written like that for performance reasons. dmap[fn] is not a |
4b2ebd3187a1
dirstate.status: assign members one by one instead of unpacking the tuple
Siddharth Agarwal <sid0@fb.com>
parents:
21809
diff
changeset
|
1386 # Python tuple in compiled builds. The CPython UNPACK_SEQUENCE |
4b2ebd3187a1
dirstate.status: assign members one by one instead of unpacking the tuple
Siddharth Agarwal <sid0@fb.com>
parents:
21809
diff
changeset
|
1387 # opcode has fast paths when the value to be unpacked is a tuple or |
4b2ebd3187a1
dirstate.status: assign members one by one instead of unpacking the tuple
Siddharth Agarwal <sid0@fb.com>
parents:
21809
diff
changeset
|
1388 # a list, but falls back to creating a full-fledged iterator in |
4b2ebd3187a1
dirstate.status: assign members one by one instead of unpacking the tuple
Siddharth Agarwal <sid0@fb.com>
parents:
21809
diff
changeset
|
1389 # general. That is much slower than simply accessing and storing the |
4b2ebd3187a1
dirstate.status: assign members one by one instead of unpacking the tuple
Siddharth Agarwal <sid0@fb.com>
parents:
21809
diff
changeset
|
1390 # tuple members one by one. |
34935
ffeea2406276
dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents:
34934
diff
changeset
|
1391 t = dget(fn) |
47536
8e4b9fe31334
dirstate-entry: add a `mode` property
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47535
diff
changeset
|
1392 mode = t.mode |
47537
0e5800c88eb4
dirstate-entry: add a `size` property
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47536
diff
changeset
|
1393 size = t.size |
47538
77fce401a2bb
dirstate-entry: add a `mtime` property
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47537
diff
changeset
|
1394 time = t.mtime |
6591
eda3fd322a7f
dirstate: minor status cleanups
Matt Mackall <mpm@selenic.com>
parents:
6590
diff
changeset
|
1395 |
47531
f5b8f0b9c129
dirstate-entry: add a `tracked` property
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47530
diff
changeset
|
1396 if not st and t.tracked: |
6818
6e93fbd847ef
dirstate.walk: eliminate src from yield
Matt Mackall <mpm@selenic.com>
parents:
6811
diff
changeset
|
1397 dadd(fn) |
47533
174d0bcce2eb
dirstate: reorder "state" checking conditional
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47532
diff
changeset
|
1398 elif t.merged: |
174d0bcce2eb
dirstate: reorder "state" checking conditional
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47532
diff
changeset
|
1399 madd(fn) |
174d0bcce2eb
dirstate: reorder "state" checking conditional
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47532
diff
changeset
|
1400 elif t.added: |
174d0bcce2eb
dirstate: reorder "state" checking conditional
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47532
diff
changeset
|
1401 aadd(fn) |
174d0bcce2eb
dirstate: reorder "state" checking conditional
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47532
diff
changeset
|
1402 elif t.removed: |
174d0bcce2eb
dirstate: reorder "state" checking conditional
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47532
diff
changeset
|
1403 radd(fn) |
47534
e53a42dce923
dirstate: drop last explicite `state` usage in status
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47533
diff
changeset
|
1404 elif t.tracked: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1405 if ( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1406 size >= 0 |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1407 and ( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1408 (size != st.st_size and size != st.st_size & _rangemask) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1409 or ((mode ^ st.st_mode) & 0o100 and checkexec) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1410 ) |
47514
559aee84b889
dirstate-entry: add a `from_p2` property
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47513
diff
changeset
|
1411 or t.from_p2 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1412 or fn in copymap |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1413 ): |
46703
ca69e29a2a30
formatting: fix redundant parentheses
Raphaël Gomès <rgomes@octobus.net>
parents:
46678
diff
changeset
|
1414 if stat.S_ISLNK(st.st_mode) and size != st.st_size: |
46678
0d055849d5f9
enclink: check contents of symlinks not just size in case of fcrypt
Corey Schuhen <cschuhen@topcon.com>
parents:
45942
diff
changeset
|
1415 # issue6456: Size returned may be longer due to |
0d055849d5f9
enclink: check contents of symlinks not just size in case of fcrypt
Corey Schuhen <cschuhen@topcon.com>
parents:
45942
diff
changeset
|
1416 # encryption on EXT-4 fscrypt, undecided. |
0d055849d5f9
enclink: check contents of symlinks not just size in case of fcrypt
Corey Schuhen <cschuhen@topcon.com>
parents:
45942
diff
changeset
|
1417 ladd(fn) |
0d055849d5f9
enclink: check contents of symlinks not just size in case of fcrypt
Corey Schuhen <cschuhen@topcon.com>
parents:
45942
diff
changeset
|
1418 else: |
0d055849d5f9
enclink: check contents of symlinks not just size in case of fcrypt
Corey Schuhen <cschuhen@topcon.com>
parents:
45942
diff
changeset
|
1419 madd(fn) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1420 elif ( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1421 time != st[stat.ST_MTIME] |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1422 and time != st[stat.ST_MTIME] & _rangemask |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1423 ): |
5003
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
1424 ladd(fn) |
36781
ffa3026d4196
cleanup: use stat_result[stat.ST_MTIME] instead of stat_result.st_mtime
Augie Fackler <augie@google.com>
parents:
36622
diff
changeset
|
1425 elif st[stat.ST_MTIME] == lastnormaltime: |
24181
5245caa0dcde
dirstate: clarify comment about leaving normal files undef if changed 'now'
Mads Kiilerich <madski@unity3d.com>
parents:
23866
diff
changeset
|
1426 # fn may have just been marked as normal and it may have |
5245caa0dcde
dirstate: clarify comment about leaving normal files undef if changed 'now'
Mads Kiilerich <madski@unity3d.com>
parents:
23866
diff
changeset
|
1427 # changed in the same second without changing its size. |
5245caa0dcde
dirstate: clarify comment about leaving normal files undef if changed 'now'
Mads Kiilerich <madski@unity3d.com>
parents:
23866
diff
changeset
|
1428 # This can happen if we quickly do multiple commits. |
13763
7a73c406c0fd
dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents:
13754
diff
changeset
|
1429 # Force lookup, so we don't miss such a racy file change. |
13704
a464763e99f1
dirstate: avoid a race with multiple commits in the same process
Greg Ward <greg@gerg.ca>
parents:
13400
diff
changeset
|
1430 ladd(fn) |
6753
ed5ffb2c12f3
repo.status: eliminate list_
Matt Mackall <mpm@selenic.com>
parents:
6750
diff
changeset
|
1431 elif listclean: |
5003
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
1432 cadd(fn) |
44530
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1433 status = scmutil.status( |
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1434 modified, added, removed, deleted, unknown, ignored, clean |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1435 ) |
44530
4d1634e59f13
rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
44357
diff
changeset
|
1436 return (lookup, status) |
21984
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
1437 |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
1438 def matches(self, match): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45243
diff
changeset
|
1439 """ |
21984
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
1440 return files in the dirstate (in whatever state) filtered by match |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
45243
diff
changeset
|
1441 """ |
21984
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
1442 dmap = self._map |
44357
bed8d08cfcb2
rust-dirstatemap: remove additional lookup in dirstate.matches
Raphaël Gomès <rgomes@octobus.net>
parents:
44297
diff
changeset
|
1443 if rustmod is not None: |
48121
5fc2dfb073d6
dirstatemap: rename `_rustmap` to `_map`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48107
diff
changeset
|
1444 dmap = self._map._map |
44357
bed8d08cfcb2
rust-dirstatemap: remove additional lookup in dirstate.matches
Raphaël Gomès <rgomes@octobus.net>
parents:
44297
diff
changeset
|
1445 |
21984
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
1446 if match.always(): |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
1447 return dmap.keys() |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
1448 files = match.files() |
24448
55c449345b10
match: add isexact() method to hide internals
Martin von Zweigbergk <martinvonz@google.com>
parents:
24212
diff
changeset
|
1449 if match.isexact(): |
21984
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
1450 # fast path -- filter the other way around, since typically files is |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
1451 # much smaller than dmap |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
1452 return [f for f in files if f in dmap] |
25275
d94e403b5237
dirstate: use match.prefix() instead of 'not match.anypats()'
Martin von Zweigbergk <martinvonz@google.com>
parents:
25234
diff
changeset
|
1453 if match.prefix() and all(fn in dmap for fn in files): |
21984
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
1454 # fast path -- all the values are known to be files, so just return |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
1455 # that |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
1456 return list(files) |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
1457 return [f for f in dmap if match(f)] |
26632
59b5e8844eb0
dirstate: move code paths for backup from dirstateguard to dirstate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26630
diff
changeset
|
1458 |
26746
3c1d297fe929
dirstateguard: remove layering violation around saving/restoring backup
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26635
diff
changeset
|
1459 def _actualfilename(self, tr): |
3c1d297fe929
dirstateguard: remove layering violation around saving/restoring backup
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26635
diff
changeset
|
1460 if tr: |
26633
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1461 return self._pendingfilename |
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1462 else: |
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1463 return self._filename |
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1464 |
33440
ec306bc6915b
dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents:
33373
diff
changeset
|
1465 def savebackup(self, tr, backupname): |
ec306bc6915b
dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents:
33373
diff
changeset
|
1466 '''Save current dirstate into backup file''' |
26746
3c1d297fe929
dirstateguard: remove layering violation around saving/restoring backup
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26635
diff
changeset
|
1467 filename = self._actualfilename(tr) |
33440
ec306bc6915b
dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents:
33373
diff
changeset
|
1468 assert backupname != filename |
26633
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1469 |
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1470 # use '_writedirstate' instead of 'write' to write changes certainly, |
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1471 # because the latter omits writing out if transaction is running. |
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1472 # output file will be used to create backup of dirstate at this point. |
31208
fc57a8b95f1b
dirstate: avoid unnecessary load+dump during backup
Jun Wu <quark@fb.com>
parents:
31207
diff
changeset
|
1473 if self._dirty or not self._opener.exists(filename): |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1474 self._writedirstate( |
47674
ff97e793ed36
dirstate-v2: Introduce a docket file
Simon Sapin <simon.sapin@octobus.net>
parents:
47673
diff
changeset
|
1475 tr, |
ff97e793ed36
dirstate-v2: Introduce a docket file
Simon Sapin <simon.sapin@octobus.net>
parents:
47673
diff
changeset
|
1476 self._opener(filename, b"w", atomictemp=True, checkambig=True), |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1477 ) |
26633
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1478 |
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1479 if tr: |
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1480 # ensure that subsequent tr.writepending returns True for |
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1481 # changes written out above, even if dirstate is never |
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1482 # changed after this |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1483 tr.addfilegenerator( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1484 b'dirstate', |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1485 (self._filename,), |
47674
ff97e793ed36
dirstate-v2: Introduce a docket file
Simon Sapin <simon.sapin@octobus.net>
parents:
47673
diff
changeset
|
1486 lambda f: self._writedirstate(tr, f), |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1487 location=b'plain', |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1488 ) |
26633
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1489 |
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1490 # ensure that pending file written above is unlinked at |
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1491 # failure, even if tr.writepending isn't invoked until the |
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1492 # end of this transaction |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
1493 tr.registertmp(filename, location=b'plain') |
26633
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1494 |
31547 | 1495 self._opener.tryunlink(backupname) |
31207
1ef37b16b8e8
dirstate: try to use hardlink to backup dirstate
Jun Wu <quark@fb.com>
parents:
31206
diff
changeset
|
1496 # hardlink backup is okay because _writedirstate is always called |
1ef37b16b8e8
dirstate: try to use hardlink to backup dirstate
Jun Wu <quark@fb.com>
parents:
31206
diff
changeset
|
1497 # with an "atomictemp=True" file. |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1498 util.copyfile( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1499 self._opener.join(filename), |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1500 self._opener.join(backupname), |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1501 hardlink=True, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
42927
diff
changeset
|
1502 ) |
26632
59b5e8844eb0
dirstate: move code paths for backup from dirstateguard to dirstate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26630
diff
changeset
|
1503 |
33440
ec306bc6915b
dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents:
33373
diff
changeset
|
1504 def restorebackup(self, tr, backupname): |
ec306bc6915b
dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents:
33373
diff
changeset
|
1505 '''Restore dirstate by backup file''' |
26632
59b5e8844eb0
dirstate: move code paths for backup from dirstateguard to dirstate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26630
diff
changeset
|
1506 # this "invalidate()" prevents "wlock.release()" from writing |
59b5e8844eb0
dirstate: move code paths for backup from dirstateguard to dirstate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26630
diff
changeset
|
1507 # changes of dirstate out after restoring from backup file |
59b5e8844eb0
dirstate: move code paths for backup from dirstateguard to dirstate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26630
diff
changeset
|
1508 self.invalidate() |
26746
3c1d297fe929
dirstateguard: remove layering violation around saving/restoring backup
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26635
diff
changeset
|
1509 filename = self._actualfilename(tr) |
34940
c2b30348930f
dirstate: clean up when restoring identical backups
Mark Thomas <mbthomas@fb.com>
parents:
34935
diff
changeset
|
1510 o = self._opener |
c2b30348930f
dirstate: clean up when restoring identical backups
Mark Thomas <mbthomas@fb.com>
parents:
34935
diff
changeset
|
1511 if util.samefile(o.join(backupname), o.join(filename)): |
c2b30348930f
dirstate: clean up when restoring identical backups
Mark Thomas <mbthomas@fb.com>
parents:
34935
diff
changeset
|
1512 o.unlink(backupname) |
c2b30348930f
dirstate: clean up when restoring identical backups
Mark Thomas <mbthomas@fb.com>
parents:
34935
diff
changeset
|
1513 else: |
c2b30348930f
dirstate: clean up when restoring identical backups
Mark Thomas <mbthomas@fb.com>
parents:
34935
diff
changeset
|
1514 o.rename(backupname, filename, checkambig=True) |
26632
59b5e8844eb0
dirstate: move code paths for backup from dirstateguard to dirstate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26630
diff
changeset
|
1515 |
33440
ec306bc6915b
dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents:
33373
diff
changeset
|
1516 def clearbackup(self, tr, backupname): |
ec306bc6915b
dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents:
33373
diff
changeset
|
1517 '''Clear backup file''' |
ec306bc6915b
dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents:
33373
diff
changeset
|
1518 self._opener.unlink(backupname) |
48089
c87844960a35
dirstate: move verification code within the dirstate itself
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48085
diff
changeset
|
1519 |
c87844960a35
dirstate: move verification code within the dirstate itself
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48085
diff
changeset
|
1520 def verify(self, m1, m2): |
c87844960a35
dirstate: move verification code within the dirstate itself
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48085
diff
changeset
|
1521 """check the dirstate content again the parent manifest and yield errors""" |
c87844960a35
dirstate: move verification code within the dirstate itself
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48085
diff
changeset
|
1522 missing_from_p1 = b"%s in state %s, but not in manifest1\n" |
c87844960a35
dirstate: move verification code within the dirstate itself
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48085
diff
changeset
|
1523 unexpected_in_p1 = b"%s in state %s, but also in manifest1\n" |
c87844960a35
dirstate: move verification code within the dirstate itself
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48085
diff
changeset
|
1524 missing_from_ps = b"%s in state %s, but not in either manifest\n" |
c87844960a35
dirstate: move verification code within the dirstate itself
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48085
diff
changeset
|
1525 missing_from_ds = b"%s in manifest1, but listed as state %s\n" |
c87844960a35
dirstate: move verification code within the dirstate itself
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48085
diff
changeset
|
1526 for f, entry in self.items(): |
c87844960a35
dirstate: move verification code within the dirstate itself
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48085
diff
changeset
|
1527 state = entry.state |
c87844960a35
dirstate: move verification code within the dirstate itself
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48085
diff
changeset
|
1528 if state in b"nr" and f not in m1: |
c87844960a35
dirstate: move verification code within the dirstate itself
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48085
diff
changeset
|
1529 yield (missing_from_p1, f, state) |
c87844960a35
dirstate: move verification code within the dirstate itself
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48085
diff
changeset
|
1530 if state in b"a" and f in m1: |
c87844960a35
dirstate: move verification code within the dirstate itself
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48085
diff
changeset
|
1531 yield (unexpected_in_p1, f, state) |
c87844960a35
dirstate: move verification code within the dirstate itself
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48085
diff
changeset
|
1532 if state in b"m" and f not in m1 and f not in m2: |
c87844960a35
dirstate: move verification code within the dirstate itself
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48085
diff
changeset
|
1533 yield (missing_from_ps, f, state) |
c87844960a35
dirstate: move verification code within the dirstate itself
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48085
diff
changeset
|
1534 for f in m1: |
c87844960a35
dirstate: move verification code within the dirstate itself
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48085
diff
changeset
|
1535 state = self.get_entry(f).state |
c87844960a35
dirstate: move verification code within the dirstate itself
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48085
diff
changeset
|
1536 if state not in b"nrm": |
c87844960a35
dirstate: move verification code within the dirstate itself
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48085
diff
changeset
|
1537 yield (missing_from_ds, f, state) |