annotate mercurial/dirstate.py @ 47277:ed0d54b20c5b

dirstate-v2: Add a new experimental `exp-dirstate-v2` repository requirement This requirement is added to `.hg/requires` when creating a new repository if Rust extensions are enabled and the `format.exp-dirstate-v2` config is set. Nothing yet changes based on this requirement, but its mere presence affects some tests (for example if they print `.hg/requires`). The next two changesets update tests’ expected outputs accordingly. There is no CI so far that enables this configuration. Differential Revision: https://phab.mercurial-scm.org/D10716
author Simon Sapin <simon.sapin@octobus.net>
date Wed, 19 May 2021 13:14:59 +0200
parents 9aba0cde0ed9
children 1766130fe9ba
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
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
25e572394f5c Update license to GPLv2+
Matt Mackall <mpm@selenic.com>
parents: 9678
diff changeset
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 (
0f4596622273 dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27399
diff changeset
22 encoding,
0f4596622273 dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27399
diff changeset
23 error,
0f4596622273 dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27399
diff changeset
24 match as matchmod,
0f4596622273 dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27399
diff changeset
25 pathutil,
32372
df448de7cf3b parsers: switch to policy importer
Yuya Nishihara <yuya@tcha.org>
parents: 32352
diff changeset
26 policy,
30304
ba2c04059317 py3: use pycompat.ossep at certain places
Pulkit Goyal <7895pulkit@gmail.com>
parents: 30224
diff changeset
27 pycompat,
27503
0f4596622273 dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 27399
diff changeset
28 scmutil,
44530
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
29 sparse,
31050
206532700213 txnutil: factor out the logic to read file in according to HG_PENDING
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 30634
diff changeset
30 txnutil,
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
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
46 _rangemask = 0x7FFFFFFF
16201
fb7c4c14223f dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents: 16200
diff changeset
47
42755
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
48 dirstatetuple = parsers.dirstatetuple
21808
7537e57f5dbd dirstate: add dirstatetuple to create dirstate values
Siddharth Agarwal <sid0@fb.com>
parents: 21116
diff changeset
49
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
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
274c99fc629f dirstate: simplify state()
Matt Mackall <mpm@selenic.com>
parents: 4609
diff changeset
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
42927
d459cd8ea42d interfaces: introduce an interface for dirstate implementations
Augie Fackler <augie@google.com>
parents: 42755
diff changeset
75 @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
76 class dirstate(object):
46780
6266d19556ad node: introduce nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 45942
diff changeset
77 def __init__(
6266d19556ad node: introduce nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 45942
diff changeset
78 self, opener, ui, root, validate, sparsematchfn, nodeconstants
6266d19556ad node: introduce nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 45942
diff changeset
79 ):
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
diff changeset
80 """Create a new dirstate object.
10145
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
81
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
82 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
83 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
84 the dirstate.
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
diff changeset
85 """
46780
6266d19556ad node: introduce nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 45942
diff changeset
86 self._nodeconstants = nodeconstants
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
87 self._opener = opener
13032
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 12907
diff changeset
88 self._validate = validate
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
89 self._root = root
33373
fb320398a21c dirstate: expose a sparse matcher on dirstate (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents: 33215
diff changeset
90 self._sparsematchfn = sparsematchfn
24198
3cc630be5f09 dirstate: make sure rootdir ends with directory separator (issue4557)
Yuya Nishihara <yuya@tcha.org>
parents: 23866
diff changeset
91 # 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
92 # 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
93 self._rootdir = pathutil.normasprefix(root)
4903
81078e177266 dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents: 4677
diff changeset
94 self._dirty = False
15791
a814f8fcc65a Use explicit integer division
Martin Geisler <mg@aragost.com>
parents: 15670
diff changeset
95 self._lastnormaltime = 0
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
96 self._ui = ui
16200
9d4a2942a732 dirstate: add filecache support
Idan Kamara <idankk86@gmail.com>
parents: 16143
diff changeset
97 self._filecache = {}
22404
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
98 self._parentwriters = 0
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
99 self._filename = b'dirstate'
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
100 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
101 self._plchangecallbacks = {}
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
102 self._origpl = None
31206
49e5491ed9bd dirstate: track updated files to improve write time
Durham Goode <durham@fb.com>
parents: 31050
diff changeset
103 self._updatedfiles = set()
35086
8db4ca768416 dirstate: make map implementation overridable
Mark Thomas <mbthomas@fb.com>
parents: 35084
diff changeset
104 self._mapcls = dirstatemap
41674
e178b131906a dirstate: call and cache os.getcwd() in constructor
Martin von Zweigbergk <martinvonz@google.com>
parents: 40424
diff changeset
105 # 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
106 # 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
107 # raises an exception).
e178b131906a dirstate: call and cache os.getcwd() in constructor
Martin von Zweigbergk <martinvonz@google.com>
parents: 40424
diff changeset
108 self._cwd
22404
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
109
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
110 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
111 """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
112
35b255e474d9 dirstate: make sure the dirstate is loaded before the changelog (issue6303)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44825
diff changeset
113 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
114 """
35b255e474d9 dirstate: make sure the dirstate is loaded before the changelog (issue6303)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44825
diff changeset
115 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
116
32346
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents: 32208
diff changeset
117 @contextlib.contextmanager
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents: 32208
diff changeset
118 def parentchange(self):
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
diff changeset
119 """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
120
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents: 32208
diff changeset
121 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
122 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
123 released.
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
diff changeset
124 """
32346
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents: 32208
diff changeset
125 self._parentwriters += 1
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents: 32208
diff changeset
126 yield
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents: 32208
diff changeset
127 # 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
128 # 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
129 # 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
130 # 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
131 # 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
132 self._parentwriters -= 1
73e67c4386ec dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents: 32208
diff changeset
133
22404
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
134 def pendingparentchange(self):
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
diff changeset
135 """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
136 that modify the dirstate parent.
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
diff changeset
137 """
22404
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
138 return self._parentwriters > 0
723
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
139
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
140 @propertycache
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
141 def _map(self):
35078
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
142 """Return the dirstate contents (see documentation for dirstatemap)."""
46780
6266d19556ad node: introduce nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 45942
diff changeset
143 self._map = self._mapcls(
6266d19556ad node: introduce nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 45942
diff changeset
144 self._ui, self._opener, self._root, self._nodeconstants
6266d19556ad node: introduce nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 45942
diff changeset
145 )
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
146 return self._map
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
147
33373
fb320398a21c dirstate: expose a sparse matcher on dirstate (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents: 33215
diff changeset
148 @property
fb320398a21c dirstate: expose a sparse matcher on dirstate (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents: 33215
diff changeset
149 def _sparsematcher(self):
fb320398a21c dirstate: expose a sparse matcher on dirstate (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents: 33215
diff changeset
150 """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
151
fb320398a21c dirstate: expose a sparse matcher on dirstate (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents: 33215
diff changeset
152 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
153 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
154 included in the working directory.
fb320398a21c dirstate: expose a sparse matcher on dirstate (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents: 33215
diff changeset
155 """
fb320398a21c dirstate: expose a sparse matcher on dirstate (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents: 33215
diff changeset
156 # 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
157 # 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
158 # 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
159 return self._sparsematchfn()
fb320398a21c dirstate: expose a sparse matcher on dirstate (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents: 33215
diff changeset
160
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
161 @repocache(b'branch')
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
162 def _branch(self):
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
163 try:
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
164 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
165 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
166 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
167 raise
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
168 return b"default"
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
169
34339
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
170 @property
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
171 def _pl(self):
34338
0c3e3810cdb6 dirstate: move parent reading to the dirstatemap class
Durham Goode <durham@fb.com>
parents: 34337
diff changeset
172 return self._map.parents()
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
173
35084
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
174 def hasdir(self, d):
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
175 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
176
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
177 @rootcache(b'.hgignore')
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
178 def _ignore(self):
27594
0921caca7703 dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents: 27593
diff changeset
179 files = self._ignorefiles()
25216
dc562165044a ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents: 25163
diff changeset
180 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
181 return matchmod.never()
25216
dc562165044a ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents: 25163
diff changeset
182
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
183 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
184 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
185
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
186 @propertycache
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
187 def _slash(self):
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
188 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
189
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
190 @propertycache
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
191 def _checklink(self):
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
192 return util.checklink(self._root)
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
193
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
194 @propertycache
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
195 def _checkexec(self):
44801
373dd22ae60e dirstate: force _checkexec to return a bool
Mitchell Plamann <mplamann@janestreet.com>
parents: 44530
diff changeset
196 return bool(util.checkexec(self._root))
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
197
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
198 @propertycache
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
199 def _checkcase(self):
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
200 return not util.fscasesensitive(self._join(b'.hg'))
8261
0fe1f57ac2bd dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents: 8226
diff changeset
201
4905
fc61495ea9cf dirstate: make wjoin function private
Matt Mackall <mpm@selenic.com>
parents: 4904
diff changeset
202 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
203 # 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
204 # 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
205 return self._rootdir + f
723
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
206
15337
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
207 def flagfunc(self, buildfallback):
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
208 if self._checklink and self._checkexec:
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
209
15337
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
210 def f(x):
18869
e8b4b139a545 dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents: 18815
diff changeset
211 try:
e8b4b139a545 dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents: 18815
diff changeset
212 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
213 if util.statislink(st):
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
214 return b'l'
18869
e8b4b139a545 dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents: 18815
diff changeset
215 if util.statisexec(st):
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
216 return b'x'
18869
e8b4b139a545 dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents: 18815
diff changeset
217 except OSError:
e8b4b139a545 dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents: 18815
diff changeset
218 pass
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
219 return b''
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
220
15337
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
221 return f
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
222
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
223 fallback = buildfallback()
6743
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
224 if self._checklink:
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
225
6743
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
226 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
227 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
228 return b'l'
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
229 if b'x' in fallback(x):
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
230 return b'x'
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
231 return b''
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
232
6743
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
233 return f
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
234 if self._checkexec:
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
235
6743
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
236 def f(x):
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
237 if b'l' in fallback(x):
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
238 return b'l'
14273
38af0f514134 rename util.is_exec to isexec
Adrian Buehlmann <adrian@cadifra.com>
parents: 14168
diff changeset
239 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
240 return b'x'
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
241 return b''
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
242
6743
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
243 return f
15337
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
244 else:
cf5f9df6406b windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents: 15057
diff changeset
245 return fallback
6743
86e8187b721a simplify flag handling
Matt Mackall <mpm@selenic.com>
parents: 6685
diff changeset
246
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
247 @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
248 def _cwd(self):
33215
b7f6885cb055 dirstate: centralize _cwd handling into _cwd method
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 32772
diff changeset
249 # internal config: ui.forcecwd
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
250 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
251 if forcecwd:
b7f6885cb055 dirstate: centralize _cwd handling into _cwd method
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 32772
diff changeset
252 return forcecwd
39818
24e493ec2229 py3: rename pycompat.getcwd() to encoding.getcwd() (API)
Matt Harbison <matt_harbison@yahoo.com>
parents: 39452
diff changeset
253 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
254
870
a82eae840447 Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents: 839
diff changeset
255 def getcwd(self):
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
diff changeset
256 """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
257
3d24f31c6b8f dirstate: state that getcwd() shouldn't be used to get real file path
Yuya Nishihara <yuya@tcha.org>
parents: 25877
diff changeset
258 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
259 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
260 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
261 """
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
262 cwd = self._cwd
10282
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
263 if cwd == self._root:
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
264 return b''
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
265 # 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
266 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
267 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
268 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
269 if cwd.startswith(rootsep):
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
270 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
271 else:
c93562fb12cc Fix handling of paths when run outside the repo.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4229
diff changeset
272 # 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
273 return cwd
870
a82eae840447 Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents: 839
diff changeset
274
4525
78b6add1f966 Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4507
diff changeset
275 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
276 if cwd is None:
78b6add1f966 Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4507
diff changeset
277 cwd = self.getcwd()
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
278 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
279 if self._slash:
19210
865beb849720 dirstate: don't overnormalize for ui.slash
Matt Mackall <mpm@selenic.com>
parents: 19128
diff changeset
280 return util.pconvert(path)
4527
b422b558015b Add ui.slash hgrc setting
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4525
diff changeset
281 return path
4525
78b6add1f966 Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4507
diff changeset
282
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
283 def __getitem__(self, key):
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
diff changeset
284 """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
285
9518
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
286 States are:
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
287 n normal
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
288 m needs merging
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
289 r marked for removal
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
290 a marked for addition
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
291 ? not tracked
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
diff changeset
292 """
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
293 return self._map.get(key, (b"?",))[0]
220
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
294
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
295 def __contains__(self, key):
4614
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
296 return key in self._map
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
297
a8be3c875988 dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents: 4613
diff changeset
298 def __iter__(self):
33707
36d216dcae6a dirstate: simplify dirstate's __iter__
Alex Gaynor <agaynor@mozilla.com>
parents: 33440
diff changeset
299 return iter(sorted(self._map))
220
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
300
32550
b98199a5c3e1 cleanup: rename all iteritems methods to items and add iteritems alias
Augie Fackler <raf@durin42.com>
parents: 32372
diff changeset
301 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
302 return pycompat.iteritems(self._map)
18792
10669e24eb6c completion: add a debugpathcomplete command
Bryan O'Sullivan <bryano@fb.com>
parents: 18760
diff changeset
303
32550
b98199a5c3e1 cleanup: rename all iteritems methods to items and add iteritems alias
Augie Fackler <raf@durin42.com>
parents: 32372
diff changeset
304 iteritems = items
b98199a5c3e1 cleanup: rename all iteritems methods to items and add iteritems alias
Augie Fackler <raf@durin42.com>
parents: 32372
diff changeset
305
227
f57519cddd3d move repo.current to dirstate.parents()
mpm@selenic.com
parents: 225
diff changeset
306 def parents(self):
13032
e41e2b79883d dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents: 12907
diff changeset
307 return [self._validate(p) for p in self._pl]
227
f57519cddd3d move repo.current to dirstate.parents()
mpm@selenic.com
parents: 225
diff changeset
308
13876
10c7d92ac482 dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents: 13763
diff changeset
309 def p1(self):
10c7d92ac482 dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents: 13763
diff changeset
310 return self._validate(self._pl[0])
10c7d92ac482 dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents: 13763
diff changeset
311
10c7d92ac482 dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents: 13763
diff changeset
312 def p2(self):
10c7d92ac482 dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents: 13763
diff changeset
313 return self._validate(self._pl[1])
10c7d92ac482 dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents: 13763
diff changeset
314
4179
7e1c8a565a4f Move branch read/write to dirstate where it belongs
Matt Mackall <mpm@selenic.com>
parents: 4172
diff changeset
315 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
316 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
317
47012
d55b71393907 node: replace nullid and friends with nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 46819
diff changeset
318 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
319 """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
320
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16542
diff changeset
321 When moving from two parents to one, 'm' merged entries a
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16542
diff changeset
322 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
323 returned by the call.
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16542
diff changeset
324
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16542
diff changeset
325 See localrepo.setparents()
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16542
diff changeset
326 """
47012
d55b71393907 node: replace nullid and friends with nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 46819
diff changeset
327 if p2 is None:
d55b71393907 node: replace nullid and friends with nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 46819
diff changeset
328 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
329 if self._parentwriters == 0:
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
330 raise ValueError(
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
331 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
332 b"dirstate.parentchange context manager"
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
333 )
22407
d259322a394b dirstate: add exception when calling setparent without begin/end (API)
Durham Goode <durham@fb.com>
parents: 22404
diff changeset
334
34339
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
335 self._dirty = True
16509
eab9119c5dee rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents: 16472
diff changeset
336 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
337 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
338 self._origpl = self._pl
34339
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
339 self._map.setparents(p1, p2)
16551
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16542
diff changeset
340 copies = {}
47012
d55b71393907 node: replace nullid and friends with nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 46819
diff changeset
341 if (
d55b71393907 node: replace nullid and friends with nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 46819
diff changeset
342 oldp2 != self._nodeconstants.nullid
d55b71393907 node: replace nullid and friends with nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 46819
diff changeset
343 and p2 == self._nodeconstants.nullid
d55b71393907 node: replace nullid and friends with nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 46819
diff changeset
344 ):
47094
e061a1df32a8 dirstate-tree: Abstract "non-normal" and "other parent" sets
Simon Sapin <simon.sapin@octobus.net>
parents: 47012
diff changeset
345 candidatefiles = self._map.non_normal_or_other_parent_paths()
e061a1df32a8 dirstate-tree: Abstract "non-normal" and "other parent" sets
Simon Sapin <simon.sapin@octobus.net>
parents: 47012
diff changeset
346
31278
1c97a91a18dc dirstate: track otherparent files same as nonnormal
Durham Goode <durham@fb.com>
parents: 31208
diff changeset
347 for f in candidatefiles:
1c97a91a18dc dirstate: track otherparent files same as nonnormal
Durham Goode <durham@fb.com>
parents: 31208
diff changeset
348 s = self._map.get(f)
1c97a91a18dc dirstate: track otherparent files same as nonnormal
Durham Goode <durham@fb.com>
parents: 31208
diff changeset
349 if s is None:
1c97a91a18dc dirstate: track otherparent files same as nonnormal
Durham Goode <durham@fb.com>
parents: 31208
diff changeset
350 continue
1c97a91a18dc dirstate: track otherparent files same as nonnormal
Durham Goode <durham@fb.com>
parents: 31208
diff changeset
351
22895
dfa44e25bb53 dirstate: properly clean-up some more merge state on setparents
Matt Mackall <mpm@selenic.com>
parents: 22782
diff changeset
352 # Discard 'm' markers when moving away from a merge state
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
353 if s[0] == b'm':
34336
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34335
diff changeset
354 source = self._map.copymap.get(f)
33981
5cb0a8fe096e dirstate: perform transactions with _copymap using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 33737
diff changeset
355 if source:
5cb0a8fe096e dirstate: perform transactions with _copymap using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 33737
diff changeset
356 copies[f] = source
16509
eab9119c5dee rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents: 16472
diff changeset
357 self.normallookup(f)
22895
dfa44e25bb53 dirstate: properly clean-up some more merge state on setparents
Matt Mackall <mpm@selenic.com>
parents: 22782
diff changeset
358 # Also fix up otherparent markers
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
359 elif s[0] == b'n' and s[2] == -2:
34336
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34335
diff changeset
360 source = self._map.copymap.get(f)
33981
5cb0a8fe096e dirstate: perform transactions with _copymap using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 33737
diff changeset
361 if source:
5cb0a8fe096e dirstate: perform transactions with _copymap using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 33737
diff changeset
362 copies[f] = source
22895
dfa44e25bb53 dirstate: properly clean-up some more merge state on setparents
Matt Mackall <mpm@selenic.com>
parents: 22782
diff changeset
363 self.add(f)
16551
ebf6d38c9063 localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents: 16542
diff changeset
364 return copies
227
f57519cddd3d move repo.current to dirstate.parents()
mpm@selenic.com
parents: 225
diff changeset
365
4179
7e1c8a565a4f Move branch read/write to dirstate where it belongs
Matt Mackall <mpm@selenic.com>
parents: 4172
diff changeset
366 def setbranch(self, branch):
40424
7caf632e30c3 filecache: unimplement __set__() and __delete__() (API)
Yuya Nishihara <yuya@tcha.org>
parents: 39818
diff changeset
367 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
368 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
369 try:
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
370 f.write(self._branch + b'\n')
16472
14a4e17f0817 dirstate: write branch file atomically
Idan Kamara <idankk86@gmail.com>
parents: 16323
diff changeset
371 f.close()
18317
365fecd984c7 dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents: 18078
diff changeset
372
365fecd984c7 dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents: 18078
diff changeset
373 # 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
374 # replacing the underlying file
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
375 ce = self._filecache[b'_branch']
18317
365fecd984c7 dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents: 18078
diff changeset
376 if ce:
365fecd984c7 dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents: 18078
diff changeset
377 ce.refresh()
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
378 except: # re-raises
18076
3bc21f6daac4 dirstate: don't rename branch file if writing it failed
Idan Kamara <idankk86@gmail.com>
parents: 17984
diff changeset
379 f.discard()
3bc21f6daac4 dirstate: don't rename branch file if writing it failed
Idan Kamara <idankk86@gmail.com>
parents: 17984
diff changeset
380 raise
4179
7e1c8a565a4f Move branch read/write to dirstate where it belongs
Matt Mackall <mpm@selenic.com>
parents: 4172
diff changeset
381
4613
3a645af7fb76 localrepo and dirstate: rename reload to invalidate
Matt Mackall <mpm@selenic.com>
parents: 4612
diff changeset
382 def invalidate(self):
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
diff changeset
383 """Causes the next access to reread the dirstate.
32682
e696f597d02f dirstate: add docstring for invalidate
Siddharth Agarwal <sid0@fb.com>
parents: 32605
diff changeset
384
e696f597d02f dirstate: add docstring for invalidate
Siddharth Agarwal <sid0@fb.com>
parents: 32605
diff changeset
385 This is different from localrepo.invalidatedirstate() because it always
e696f597d02f dirstate: add docstring for invalidate
Siddharth Agarwal <sid0@fb.com>
parents: 32605
diff changeset
386 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
387 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
388
43503
313e3a279828 cleanup: remove pointless r-prefixes on double-quoted strings
Augie Fackler <augie@google.com>
parents: 43456
diff changeset
389 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
390 if a in self.__dict__:
6b3ed43f77ba dirstate.invalidate: avoid rebuilding _map
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4952
diff changeset
391 delattr(self, a)
15791
a814f8fcc65a Use explicit integer division
Martin Geisler <mg@aragost.com>
parents: 15670
diff changeset
392 self._lastnormaltime = 0
4903
81078e177266 dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents: 4677
diff changeset
393 self._dirty = False
31206
49e5491ed9bd dirstate: track updated files to improve write time
Durham Goode <durham@fb.com>
parents: 31050
diff changeset
394 self._updatedfiles.clear()
22404
12bc7f06fc41 dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents: 21984
diff changeset
395 self._parentwriters = 0
29772
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
396 self._origpl = None
4375
109077e7048d When reloading the dirstate, recompute ignore information if needed.
Bryan O'Sullivan <bos@serpentine.com>
parents: 4374
diff changeset
397
363
ae96b7e1318d Add hg copy
mpm@selenic.com
parents: 360
diff changeset
398 def copy(self, source, dest):
10145
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
399 """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
400 if source == dest:
deda205a00e1 Ignore dummy copies in dirstate and localrepo.filecommit()
Patrick Mezard <pmezard@gmail.com>
parents: 6479
diff changeset
401 return
4903
81078e177266 dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents: 4677
diff changeset
402 self._dirty = True
7566
5f7e3f17aece mq: drop copy records when refreshing regular patches (issue1441)
Patrick Mezard <pmezard@gmail.com>
parents: 7280
diff changeset
403 if source is not None:
34336
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34335
diff changeset
404 self._map.copymap[dest] = source
31206
49e5491ed9bd dirstate: track updated files to improve write time
Durham Goode <durham@fb.com>
parents: 31050
diff changeset
405 self._updatedfiles.add(source)
49e5491ed9bd dirstate: track updated files to improve write time
Durham Goode <durham@fb.com>
parents: 31050
diff changeset
406 self._updatedfiles.add(dest)
34336
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34335
diff changeset
407 elif self._map.copymap.pop(dest, None):
31206
49e5491ed9bd dirstate: track updated files to improve write time
Durham Goode <durham@fb.com>
parents: 31050
diff changeset
408 self._updatedfiles.add(dest)
363
ae96b7e1318d Add hg copy
mpm@selenic.com
parents: 360
diff changeset
409
ae96b7e1318d Add hg copy
mpm@selenic.com
parents: 360
diff changeset
410 def copied(self, file):
34336
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34335
diff changeset
411 return self._map.copymap.get(file, None)
3154
b1f10d3223c1 dirstate: add copies function
Matt Mackall <mpm@selenic.com>
parents: 2962
diff changeset
412
b1f10d3223c1 dirstate: add copies function
Matt Mackall <mpm@selenic.com>
parents: 2962
diff changeset
413 def copies(self):
34336
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34335
diff changeset
414 return self._map.copymap
515
03f27b1381f9 Whitespace cleanups
mpm@selenic.com
parents: 514
diff changeset
415
17196
2abe975ffb94 dirstate: eliminate redundant check parameter on _addpath()
Adrian Buehlmann <adrian@cadifra.com>
parents: 17094
diff changeset
416 def _addpath(self, f, state, mode, size, mtime):
5487
7a64931e2d76 Fix file-changed-to-dir and dir-to-file commits (issue660).
Maxim Dounin <mdounin@mdounin.ru>
parents: 5396
diff changeset
417 oldstate = self[f]
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
418 if state == b'a' or oldstate == b'r':
13974
23f2736abce3 move checkfilename from util to scmutil
Adrian Buehlmann <adrian@cadifra.com>
parents: 13944
diff changeset
419 scmutil.checkfilename(f)
35084
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
420 if self._map.hastrackeddir(f):
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
421 raise error.Abort(
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
422 _(b'directory %r already in dirstate') % pycompat.bytestr(f)
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
423 )
6767
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
424 # shadows
43633
0b7733719d21 utils: move finddirs() to pathutil
Martin von Zweigbergk <martinvonz@google.com>
parents: 43620
diff changeset
425 for d in pathutil.finddirs(f):
35084
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
426 if self._map.hastrackeddir(d):
6767
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
427 break
34188
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34022
diff changeset
428 entry = self._map.get(d)
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
429 if entry is not None and entry[0] != b'r':
26587
56b2bcea2529 error: get Abort from 'error' instead of 'util'
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 26521
diff changeset
430 raise error.Abort(
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
431 _(b'file %r in dirstate clashes with %r')
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
432 % (pycompat.bytestr(d), pycompat.bytestr(f))
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
433 )
17094
c2016bae3b97 dirstate: factor common update code into _addpath
Joshua Redstone <joshua.redstone@fb.com>
parents: 16955
diff changeset
434 self._dirty = True
31206
49e5491ed9bd dirstate: track updated files to improve write time
Durham Goode <durham@fb.com>
parents: 31050
diff changeset
435 self._updatedfiles.add(f)
35081
a947cf872799 dirstate: move management of the dirstate dirs into the dirstatemap
Mark Thomas <mbthomas@fb.com>
parents: 35080
diff changeset
436 self._map.addfile(f, oldstate, state, mode, size, mtime)
5487
7a64931e2d76 Fix file-changed-to-dir and dir-to-file commits (issue660).
Maxim Dounin <mdounin@mdounin.ru>
parents: 5396
diff changeset
437
42456
87a34c767384 merge: fix race that could cause wrong size in dirstate
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents: 42452
diff changeset
438 def normal(self, f, parentfiledata=None):
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
diff changeset
439 """Mark a file normal and clean.
42456
87a34c767384 merge: fix race that could cause wrong size in dirstate
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents: 42452
diff changeset
440
87a34c767384 merge: fix race that could cause wrong size in dirstate
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents: 42452
diff changeset
441 parentfiledata: (mode, size, mtime) of the clean file
87a34c767384 merge: fix race that could cause wrong size in dirstate
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents: 42452
diff changeset
442
87a34c767384 merge: fix race that could cause wrong size in dirstate
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents: 42452
diff changeset
443 parentfiledata should be computed from memory (for mode,
87a34c767384 merge: fix race that could cause wrong size in dirstate
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents: 42452
diff changeset
444 size), as or close as possible from the point where we
87a34c767384 merge: fix race that could cause wrong size in dirstate
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents: 42452
diff changeset
445 determined the file was clean, to limit the risk of the
87a34c767384 merge: fix race that could cause wrong size in dirstate
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents: 42452
diff changeset
446 file having been changed by an external process between the
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
diff changeset
447 moment where the file was determined to be clean and now."""
42456
87a34c767384 merge: fix race that could cause wrong size in dirstate
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents: 42452
diff changeset
448 if parentfiledata:
87a34c767384 merge: fix race that could cause wrong size in dirstate
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents: 42452
diff changeset
449 (mode, size, mtime) = parentfiledata
87a34c767384 merge: fix race that could cause wrong size in dirstate
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents: 42452
diff changeset
450 else:
87a34c767384 merge: fix race that could cause wrong size in dirstate
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents: 42452
diff changeset
451 s = os.lstat(self._join(f))
87a34c767384 merge: fix race that could cause wrong size in dirstate
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents: 42452
diff changeset
452 mode = s.st_mode
87a34c767384 merge: fix race that could cause wrong size in dirstate
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents: 42452
diff changeset
453 size = s.st_size
87a34c767384 merge: fix race that could cause wrong size in dirstate
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents: 42452
diff changeset
454 mtime = s[stat.ST_MTIME]
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
455 self._addpath(f, b'n', mode, size & _rangemask, mtime & _rangemask)
34336
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34335
diff changeset
456 self._map.copymap.pop(f, None)
34674
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents: 34673
diff changeset
457 if f in self._map.nonnormalset:
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents: 34673
diff changeset
458 self._map.nonnormalset.remove(f)
13763
7a73c406c0fd dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents: 13754
diff changeset
459 if mtime > self._lastnormaltime:
7a73c406c0fd dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents: 13754
diff changeset
460 # Remember the most recent modification timeslot for status(),
13754
ae157ca56cd5 dirstate: check mtime when adding to _lastnormal
Adrian Buehlmann <adrian@cadifra.com>
parents: 13743
diff changeset
461 # to make sure we won't miss future size-preserving file content
ae157ca56cd5 dirstate: check mtime when adding to _lastnormal
Adrian Buehlmann <adrian@cadifra.com>
parents: 13743
diff changeset
462 # modifications that happen within the same timeslot.
13763
7a73c406c0fd dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents: 13754
diff changeset
463 self._lastnormaltime = mtime
13704
a464763e99f1 dirstate: avoid a race with multiple commits in the same process
Greg Ward <greg@gerg.ca>
parents: 13400
diff changeset
464
5210
90d9ec0dc69d merge: forcefully mark files that we get from the second parent as dirty
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5123
diff changeset
465 def normallookup(self, f):
10145
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
466 '''Mark a file normal, but possibly dirty.'''
47012
d55b71393907 node: replace nullid and friends with nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 46819
diff changeset
467 if self._pl[1] != self._nodeconstants.nullid:
6298
53cbb33e1269 normallookup: during merges, restore the state saved by remove
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 6297
diff changeset
468 # if there is a merge going on and the file was either
10968
7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10935
diff changeset
469 # in state 'm' (-1) or coming from other parent (-2) before
7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10935
diff changeset
470 # being removed, restore that state.
34188
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34022
diff changeset
471 entry = self._map.get(f)
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34022
diff changeset
472 if entry is not None:
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
473 if entry[0] == b'r' and entry[2] in (-1, -2):
34336
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34335
diff changeset
474 source = self._map.copymap.get(f)
34188
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34022
diff changeset
475 if entry[2] == -1:
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34022
diff changeset
476 self.merge(f)
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34022
diff changeset
477 elif entry[2] == -2:
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34022
diff changeset
478 self.otherparent(f)
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34022
diff changeset
479 if source:
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34022
diff changeset
480 self.copy(source, f)
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34022
diff changeset
481 return
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
482 if entry[0] == b'm' or entry[0] == b'n' and entry[2] == -2:
34188
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34022
diff changeset
483 return
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
484 self._addpath(f, b'n', 0, -1, -1)
34336
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34335
diff changeset
485 self._map.copymap.pop(f, None)
5210
90d9ec0dc69d merge: forcefully mark files that we get from the second parent as dirty
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5123
diff changeset
486
10968
7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10935
diff changeset
487 def otherparent(self, f):
7a0d096e221e dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 10935
diff changeset
488 '''Mark as coming from the other parent, always dirty.'''
47012
d55b71393907 node: replace nullid and friends with nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 46819
diff changeset
489 if self._pl[1] == self._nodeconstants.nullid:
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
490 raise error.Abort(
43117
8ff1ecfadcd1 cleanup: join string literals that are already on one line
Martin von Zweigbergk <martinvonz@google.com>
parents: 43106
diff changeset
491 _(b"setting %r to other parent only allowed in merges") % f
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
492 )
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
493 if f in self and self[f] == b'n':
22896
7e9cbb9c6053 dirstate: use 'm' state in otherparent to reduce ambiguity
Matt Mackall <mpm@selenic.com>
parents: 22895
diff changeset
494 # merge-like
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
495 self._addpath(f, b'm', 0, -2, -1)
22896
7e9cbb9c6053 dirstate: use 'm' state in otherparent to reduce ambiguity
Matt Mackall <mpm@selenic.com>
parents: 22895
diff changeset
496 else:
7e9cbb9c6053 dirstate: use 'm' state in otherparent to reduce ambiguity
Matt Mackall <mpm@selenic.com>
parents: 22895
diff changeset
497 # add-like
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
498 self._addpath(f, b'n', 0, -2, -1)
34336
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34335
diff changeset
499 self._map.copymap.pop(f, None)
4904
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
500
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
501 def add(self, f):
10145
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
502 '''Mark a file added.'''
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
503 self._addpath(f, b'a', 0, -1, -1)
34336
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34335
diff changeset
504 self._map.copymap.pop(f, None)
4616
70352337934e dirstate: refactor checkinterfering
Matt Mackall <mpm@selenic.com>
parents: 4615
diff changeset
505
4904
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
506 def remove(self, f):
10145
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
507 '''Mark a file removed.'''
4904
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
508 self._dirty = True
35081
a947cf872799 dirstate: move management of the dirstate dirs into the dirstatemap
Mark Thomas <mbthomas@fb.com>
parents: 35080
diff changeset
509 oldstate = self[f]
6297
fed1a9c22076 dirstate.remove: during merges, remember the previous file state
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 6257
diff changeset
510 size = 0
47012
d55b71393907 node: replace nullid and friends with nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 46819
diff changeset
511 if self._pl[1] != self._nodeconstants.nullid:
34188
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34022
diff changeset
512 entry = self._map.get(f)
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34022
diff changeset
513 if entry is not None:
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34022
diff changeset
514 # backup the previous state
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
515 if entry[0] == b'm': # merge
34188
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34022
diff changeset
516 size = -1
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
517 elif entry[0] == b'n' and entry[2] == -2: # other parent
34188
1246acdad653 dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 34022
diff changeset
518 size = -2
34674
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents: 34673
diff changeset
519 self._map.otherparentset.add(f)
35083
e8ae0b2d88a8 dirstate: remove _droppath method
Mark Thomas <mbthomas@fb.com>
parents: 35082
diff changeset
520 self._updatedfiles.add(f)
35081
a947cf872799 dirstate: move management of the dirstate dirs into the dirstatemap
Mark Thomas <mbthomas@fb.com>
parents: 35080
diff changeset
521 self._map.removefile(f, oldstate, size)
33981
5cb0a8fe096e dirstate: perform transactions with _copymap using single call, where possible
Michael Bolin <mbolin@fb.com>
parents: 33737
diff changeset
522 if size == 0:
34336
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34335
diff changeset
523 self._map.copymap.pop(f, None)
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
524
4904
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
525 def merge(self, f):
10145
aec936051734 dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents: 9678
diff changeset
526 '''Mark a file merged.'''
47012
d55b71393907 node: replace nullid and friends with nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 46819
diff changeset
527 if self._pl[1] == self._nodeconstants.nullid:
16509
eab9119c5dee rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents: 16472
diff changeset
528 return self.normallookup(f)
22897
8fe74328f700 dirstate: merge falls through to otherparent
Matt Mackall <mpm@selenic.com>
parents: 22896
diff changeset
529 return self.otherparent(f)
4904
6fd953d5faea dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents: 4903
diff changeset
530
14434
cc8c09855d19 dirstate: rename forget to drop
Matt Mackall <mpm@selenic.com>
parents: 14273
diff changeset
531 def drop(self, f):
cc8c09855d19 dirstate: rename forget to drop
Matt Mackall <mpm@selenic.com>
parents: 14273
diff changeset
532 '''Drop a file from the dirstate'''
35081
a947cf872799 dirstate: move management of the dirstate dirs into the dirstatemap
Mark Thomas <mbthomas@fb.com>
parents: 35080
diff changeset
533 oldstate = self[f]
a947cf872799 dirstate: move management of the dirstate dirs into the dirstatemap
Mark Thomas <mbthomas@fb.com>
parents: 35080
diff changeset
534 if self._map.dropfile(f, oldstate):
15399
41453d55b481 dirstate: don't fail when dropping a not-tracked file (issue3080)
Matt Mackall <mpm@selenic.com>
parents: 15337
diff changeset
535 self._dirty = True
35083
e8ae0b2d88a8 dirstate: remove _droppath method
Mark Thomas <mbthomas@fb.com>
parents: 35082
diff changeset
536 self._updatedfiles.add(f)
34336
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34335
diff changeset
537 self._map.copymap.pop(f, None)
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
538
24538
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
539 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
540 if exists is None:
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
541 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
542 if not exists:
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
543 # Maybe a path component exists
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
544 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
545 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
546 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
547 folded = d + b"/" + f
24538
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
548 else:
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
549 # No path components, preserve original case
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
550 folded = path
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
551 else:
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
552 # recursively normalize leading directory components
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
553 # against dirstate
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
554 if b'/' in normed:
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
555 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
556 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
557 r = self._root + b"/" + d
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
558 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
559 else:
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
560 folded = util.fspath(normed, self._root)
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
561 storemap[normed] = folded
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
562
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
563 return folded
24df92075200 dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents: 24523
diff changeset
564
24539
3a8eba78803e dirstate: introduce function to normalize just filenames
Siddharth Agarwal <sid0@fb.com>
parents: 24538
diff changeset
565 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
566 normed = util.normcase(path)
34676
bfddc3d678ae dirstate: remove _filefoldmap property cache
Durham Goode <durham@fb.com>
parents: 34675
diff changeset
567 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
568 if folded is None:
16542
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
569 if isknown:
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
570 folded = path
7068
57377fa7eda2 issue 1286: dirstat regression on case folding systems
Petr Kodl <petrkodl@gmail.com>
parents: 7034
diff changeset
571 else:
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
572 folded = self._discoverpath(
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
573 path, normed, ignoremissing, exists, self._map.filefoldmap
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
574 )
24539
3a8eba78803e dirstate: introduce function to normalize just filenames
Siddharth Agarwal <sid0@fb.com>
parents: 24538
diff changeset
575 return folded
16302
49b54f1ae053 dirstate: normalize case of directory components
Matt Mackall <mpm@selenic.com>
parents: 16258
diff changeset
576
16542
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
577 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
578 normed = util.normcase(path)
34676
bfddc3d678ae dirstate: remove _filefoldmap property cache
Durham Goode <durham@fb.com>
parents: 34675
diff changeset
579 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
580 if folded is None:
34678
e8a89ed7ce96 dirstate: move the _dirfoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34677
diff changeset
581 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
582 if folded is None:
16542
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
583 if isknown:
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
584 folded = path
7068
57377fa7eda2 issue 1286: dirstat regression on case folding systems
Petr Kodl <petrkodl@gmail.com>
parents: 7034
diff changeset
585 else:
24540
25c1d3ca5ff6 dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents: 24539
diff changeset
586 # 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
587 # normalizefile calls don't start matching directories
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
588 folded = self._discoverpath(
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
589 path, normed, ignoremissing, exists, self._map.dirfoldmap
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
590 )
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
591 return folded
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
592
16542
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
593 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
594 """
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
595 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
596
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
597 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
598 disk, to avoid extra filesystem access.
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
599
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
600 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
601 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
602 existing path components.
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
603
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
604 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
605
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
606 - 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
607 - version of name stored on disk
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
608 - version provided via command arguments
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
diff changeset
609 """
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
610
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
611 if self._checkcase:
16542
e596a631210e dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents: 16509
diff changeset
612 return self._normalize(path, isknown, ignoremissing)
13717
bc41d08a5ccc dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents: 13400
diff changeset
613 return path
6677
9865e15febd0 Add a normalize() method to dirstate
Paul Moore <p.f.moore@gmail.com>
parents: 6675
diff changeset
614
5065
b304c2496f52 dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4953
diff changeset
615 def clear(self):
34933
0217f75b6e59 dirstate: move clear onto dirstatemap class
Durham Goode <durham@fb.com>
parents: 34678
diff changeset
616 self._map.clear()
15791
a814f8fcc65a Use explicit integer division
Martin Geisler <mg@aragost.com>
parents: 15670
diff changeset
617 self._lastnormaltime = 0
31206
49e5491ed9bd dirstate: track updated files to improve write time
Durham Goode <durham@fb.com>
parents: 31050
diff changeset
618 self._updatedfiles.clear()
5123
79373ec3f27d merge with crew-stable
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5045 5065
diff changeset
619 self._dirty = True
5065
b304c2496f52 dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 4953
diff changeset
620
18760
e74704c33e24 strip: make --keep option not set all dirstate times to 0
Durham Goode <durham@fb.com>
parents: 18663
diff changeset
621 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
622 if changedfiles is None:
27176
54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents: 27016
diff changeset
623 # Rebuild entire dirstate
43891
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43869
diff changeset
624 to_lookup = allfiles
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43869
diff changeset
625 to_drop = []
27176
54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents: 27016
diff changeset
626 lastnormaltime = self._lastnormaltime
54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents: 27016
diff changeset
627 self.clear()
54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents: 27016
diff changeset
628 self._lastnormaltime = lastnormaltime
43891
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43869
diff changeset
629 elif len(changedfiles) < 10:
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43869
diff changeset
630 # 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
631 # large.
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43869
diff changeset
632 to_lookup = []
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43869
diff changeset
633 to_drop = []
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43869
diff changeset
634 for f in changedfiles:
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43869
diff changeset
635 if f in allfiles:
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43869
diff changeset
636 to_lookup.append(f)
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43869
diff changeset
637 else:
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43869
diff changeset
638 to_drop.append(f)
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43869
diff changeset
639 else:
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43869
diff changeset
640 changedfilesset = set(changedfiles)
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43869
diff changeset
641 to_lookup = changedfilesset & set(allfiles)
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43869
diff changeset
642 to_drop = changedfilesset - to_lookup
27176
54ace3372f84 dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents: 27016
diff changeset
643
29772
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
644 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
645 self._origpl = self._pl
47012
d55b71393907 node: replace nullid and friends with nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 46819
diff changeset
646 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
647
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43869
diff changeset
648 for f in to_lookup:
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43869
diff changeset
649 self.normallookup(f)
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43869
diff changeset
650 for f in to_drop:
7eb6a2680ae6 dirstate: when calling rebuild(), avoid some N^2 codepaths
Kyle Lippincott <spectral@google.com>
parents: 43869
diff changeset
651 self.drop(f)
30026
ba06562a06a2 dirstate: rebuild should update dirstate properly
Mateusz Kwapich <mitrandir@fb.com>
parents: 29889
diff changeset
652
4903
81078e177266 dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents: 4677
diff changeset
653 self._dirty = True
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
654
32750
b698921ee137 dirstate: add identity information to detect simultaneous changing in storage
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 32682
diff changeset
655 def identity(self):
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
diff changeset
656 """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
657
b698921ee137 dirstate: add identity information to detect simultaneous changing in storage
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 32682
diff changeset
658 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
659 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
660 """
34675
c6ef9a2498a5 dirstate: move identity to dirstatemap
Durham Goode <durham@fb.com>
parents: 34674
diff changeset
661 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
662
29673
52ff07e1de91 deprecation: enforce thew 'tr' argument of 'dirstate.write' (API)
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 29351
diff changeset
663 def write(self, tr):
4612
17ee7407097f dirstate: simplify dirty handling
Matt Mackall <mpm@selenic.com>
parents: 4611
diff changeset
664 if not self._dirty:
1794
98b6c1cad58b only write the dirstate when something changed
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents: 1755
diff changeset
665 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
666
26634
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
667 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
668 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
669 # '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
670 # 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
671 # 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
672 # 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
673 # 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
674
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
675 # emulate dropping timestamp in 'parsers.pack_dirstate'
26747
beff0b2481b3 dirstate: remove layering violation around writing dirstate out
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26746
diff changeset
676 now = _getfsnow(self._opener)
35080
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents: 35079
diff changeset
677 self._map.clearambiguoustimes(self._updatedfiles, now)
26634
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
678
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
679 # emulate that all 'dirstate.normal' results are written out
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
680 self._lastnormaltime = 0
31206
49e5491ed9bd dirstate: track updated files to improve write time
Durham Goode <durham@fb.com>
parents: 31050
diff changeset
681 self._updatedfiles.clear()
26634
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
682
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
683 # delay writing in-memory changes out
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
684 tr.addfilegenerator(
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
685 b'dirstate',
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
686 (self._filename,),
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
687 self._writedirstate,
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
688 location=b'plain',
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
689 )
26634
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
690 return
09bb1ee7e73e dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26633
diff changeset
691
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
692 st = self._opener(filename, b"w", atomictemp=True, checkambig=True)
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
693 self._writedirstate(st)
3f41e28a16d8 dirstate: split write to write changes into files other than .hg/dirstate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26492
diff changeset
694
29772
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
695 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
696 """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
697
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
698 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
699 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
700
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
701 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
702 with a newer callback.
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
703 """
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
704 self._plchangecallbacks[category] = callback
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
705
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
706 def _writedirstate(self, st):
29772
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
707 # 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
708 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
709 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
710 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
711 ):
29772
2ebd507e5ac3 dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents: 29673
diff changeset
712 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
713 self._origpl = None
9509
e4ca8c258d9b dirstate: kill dirstate.granularity config option
Adrian Buehlmann <adrian@cadifra.com>
parents: 9379
diff changeset
714 # use the modification time of the newly created temporary file as the
e4ca8c258d9b dirstate: kill dirstate.granularity config option
Adrian Buehlmann <adrian@cadifra.com>
parents: 9379
diff changeset
715 # filesystem's notion of 'now'
36781
ffa3026d4196 cleanup: use stat_result[stat.ST_MTIME] instead of stat_result.st_mtime
Augie Fackler <augie@google.com>
parents: 36622
diff changeset
716 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
717
6c6b48aca328 dirstate: move delaywrite logic from write to _write
Matt Mackall <mpm@selenic.com>
parents: 27176
diff changeset
718 # 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
719 # 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
720 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
721 if delaywrite > 0:
27398
c81675776c95 dirstate: only invoke delaywrite if relevant
Matt Mackall <mpm@selenic.com>
parents: 27397
diff changeset
722 # 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
723 for f, e in pycompat.iteritems(self._map):
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
724 if e[0] == b'n' and e[3] == now:
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
725 import time # to avoid useless import
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
726
27399
425dc70037f7 dirstate: make delaywrite sleep until the next multiple of n seconds
Matt Mackall <mpm@selenic.com>
parents: 27398
diff changeset
727 # 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
728 # 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
729 clock = time.time()
425dc70037f7 dirstate: make delaywrite sleep until the next multiple of n seconds
Matt Mackall <mpm@selenic.com>
parents: 27398
diff changeset
730 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
731 end = start + delaywrite
425dc70037f7 dirstate: make delaywrite sleep until the next multiple of n seconds
Matt Mackall <mpm@selenic.com>
parents: 27398
diff changeset
732 time.sleep(end - clock)
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
733 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
734 break
27397
6c6b48aca328 dirstate: move delaywrite logic from write to _write
Matt Mackall <mpm@selenic.com>
parents: 27176
diff changeset
735
34673
e2214632c3a2 dirstate: move write into dirstatemap
Durham Goode <durham@fb.com>
parents: 34672
diff changeset
736 self._map.write(st, now)
21026
7ee03e190c1d dirstate: inline local finish function
Mads Kiilerich <madski@unity3d.com>
parents: 20632
diff changeset
737 self._lastnormaltime = 0
34673
e2214632c3a2 dirstate: move write into dirstatemap
Durham Goode <durham@fb.com>
parents: 34672
diff changeset
738 self._dirty = False
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
739
6032
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
740 def _dirignore(self, f):
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
741 if self._ignore(f):
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
742 return True
43633
0b7733719d21 utils: move finddirs() to pathutil
Martin von Zweigbergk <martinvonz@google.com>
parents: 43620
diff changeset
743 for p in pathutil.finddirs(f):
6767
80605a8127e0 dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents: 6762
diff changeset
744 if self._ignore(p):
6032
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
745 return True
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
746 return False
b41f0d6a74fc dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents: 5516
diff changeset
747
27594
0921caca7703 dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents: 27593
diff changeset
748 def _ignorefiles(self):
0921caca7703 dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents: 27593
diff changeset
749 files = []
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
750 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
751 files.append(self._join(b'.hgignore'))
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
752 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
753 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
754 # 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
755 # 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
756 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
757 return files
0921caca7703 dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents: 27593
diff changeset
758
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
759 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
760 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
761 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
762 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
763 i = files.popleft()
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
764 patterns = matchmod.readpatternfile(
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
765 i, self._ui.warn, sourceinfo=True
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
766 )
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
767 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
768 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
769 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
770 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
771 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
772 continue
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
773 m = matchmod.match(
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
774 self._root, b'', [], [pattern], warn=self._ui.warn
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
775 )
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
776 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
777 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
778 visited.add(i)
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
779 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
780
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
781 def _walkexplicit(self, match, subrepos):
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
diff changeset
782 """Get stat data about the files explicitly specified by match.
3529
09d99b7e4da0 simplify dirstate walking
Matt Mackall <mpm@selenic.com>
parents: 3223
diff changeset
783
19174
022256ef47b8 dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents: 19173
diff changeset
784 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
785 - 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
786 listings mapping subrepos and .hg to None.
19174
022256ef47b8 dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents: 19173
diff changeset
787 - 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
788 - 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
789 directories and that were not found."""
6578
f242d3684f83 walk: begin refactoring badmatch handling
Matt Mackall <mpm@selenic.com>
parents: 6577
diff changeset
790
8681
26f133267cd7 walk: use match.bad callback for filetype messages
Matt Mackall <mpm@selenic.com>
parents: 8680
diff changeset
791 def badtype(mode):
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
792 kind = _(b'unknown')
10282
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
793 if stat.S_ISCHR(mode):
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
794 kind = _(b'character device')
10282
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
795 elif stat.S_ISBLK(mode):
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
796 kind = _(b'block device')
10282
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
797 elif stat.S_ISFIFO(mode):
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
798 kind = _(b'fifo')
10282
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
799 elif stat.S_ISSOCK(mode):
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
800 kind = _(b'socket')
10282
08a0f04b56bd many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents: 10264
diff changeset
801 elif stat.S_ISDIR(mode):
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
802 kind = _(b'directory')
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
803 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
804
8676
acd69fc201a5 walk: we always have a badfn
Matt Mackall <mpm@selenic.com>
parents: 8675
diff changeset
805 badfn = match.bad
6831
2b663f542bd3 dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents: 6830
diff changeset
806 dmap = self._map
5000
46facb73ba8b dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents: 4965
diff changeset
807 lstat = os.lstat
6830
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
808 getkind = stat.S_IFMT
6828
55d65a33da52 dirstate.walk: minor cleanups
Matt Mackall <mpm@selenic.com>
parents: 6827
diff changeset
809 dirkind = stat.S_IFDIR
6830
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
810 regkind = stat.S_IFREG
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
811 lnkkind = stat.S_IFLNK
6831
2b663f542bd3 dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents: 6830
diff changeset
812 join = self._join
19174
022256ef47b8 dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents: 19173
diff changeset
813 dirsfound = []
022256ef47b8 dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents: 19173
diff changeset
814 foundadd = dirsfound.append
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
815 dirsnotfound = []
19175
63f7bd2e1a46 dirstate._walkexplicit: inline dirsnotfound.append
Siddharth Agarwal <sid0@fb.com>
parents: 19174
diff changeset
816 notfoundadd = dirsnotfound.append
6820
639d9cb95509 dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents: 6819
diff changeset
817
24448
55c449345b10 match: add isexact() method to hide internals
Martin von Zweigbergk <martinvonz@google.com>
parents: 24212
diff changeset
818 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
819 normalize = self._normalize
e255a5dc29e6 dirstate: skip optimization on case-folding FS (issue2440)
Matt Mackall <mpm@selenic.com>
parents: 12401
diff changeset
820 else:
18032
a9e623bb440e dirstate: test normalize is truthy instead of using a no-op lambda
Siddharth Agarwal <sid0@fb.com>
parents: 18018
diff changeset
821 normalize = None
12907
e255a5dc29e6 dirstate: skip optimization on case-folding FS (issue2440)
Matt Mackall <mpm@selenic.com>
parents: 12401
diff changeset
822
12211
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
823 files = sorted(match.files())
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
824 subrepos.sort()
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
825 i, j = 0, 0
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
826 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
827 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
828 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
829 i += 1
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
830 continue
13339
22167be007ed subrepo: fix pruning of subrepo filenames in dirstate (issue2619)
trbs <trbs@trbs.net>
parents: 13233
diff changeset
831 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
832 del files[i]
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
833 j += 1
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
834
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
835 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
836 files = [b'']
42340
7ada598941d2 dirstate: move special handling of files==['.'] together
Martin von Zweigbergk <martinvonz@google.com>
parents: 42304
diff changeset
837 # 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
838 # common case where files is ['']
42340
7ada598941d2 dirstate: move special handling of files==['.'] together
Martin von Zweigbergk <martinvonz@google.com>
parents: 42304
diff changeset
839 normalize = None
10176
24ce8f0c0a39 dirstate: don't check state of subrepo directories
Augie Fackler <durin42@gmail.com>
parents: 10145
diff changeset
840 results = dict.fromkeys(subrepos)
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
841 results[b'.hg'] = None
5000
46facb73ba8b dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents: 4965
diff changeset
842
12211
798d72f3621c dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents: 12164
diff changeset
843 for ff in files:
42340
7ada598941d2 dirstate: move special handling of files==['.'] together
Martin von Zweigbergk <martinvonz@google.com>
parents: 42304
diff changeset
844 if normalize:
24522
18085e46caa9 dirstate._walkexplicit: drop normpath calls
Siddharth Agarwal <sid0@fb.com>
parents: 24521
diff changeset
845 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
846 else:
24522
18085e46caa9 dirstate._walkexplicit: drop normpath calls
Siddharth Agarwal <sid0@fb.com>
parents: 24521
diff changeset
847 nf = ff
6829
fec1da46006e dirstate.walk: build a dict rather than yield
Matt Mackall <mpm@selenic.com>
parents: 6828
diff changeset
848 if nf in results:
6820
639d9cb95509 dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents: 6819
diff changeset
849 continue
639d9cb95509 dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents: 6819
diff changeset
850
639d9cb95509 dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents: 6819
diff changeset
851 try:
6831
2b663f542bd3 dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents: 6830
diff changeset
852 st = lstat(join(nf))
6830
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
853 kind = getkind(st.st_mode)
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
854 if kind == dirkind:
8588
2624f485b9bc dirstate: set more states in step 1 of walk
Simon Heimberg <simohe@besonet.ch>
parents: 8521
diff changeset
855 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
856 # 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
857 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
858 foundadd((nf, ff))
12401
4cdaf1adafc8 backout most of 4f8067c94729
Matt Mackall <mpm@selenic.com>
parents: 12387
diff changeset
859 elif kind == regkind or kind == lnkkind:
6830
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
860 results[nf] = st
6828
55d65a33da52 dirstate.walk: minor cleanups
Matt Mackall <mpm@selenic.com>
parents: 6827
diff changeset
861 else:
8681
26f133267cd7 walk: use match.bad callback for filetype messages
Matt Mackall <mpm@selenic.com>
parents: 8680
diff changeset
862 badfn(ff, badtype(kind))
6830
2cf4cda64727 dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents: 6829
diff changeset
863 if nf in dmap:
6829
fec1da46006e dirstate.walk: build a dict rather than yield
Matt Mackall <mpm@selenic.com>
parents: 6828
diff changeset
864 results[nf] = None
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
865 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
866 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
867 results[nf] = None
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
868 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
869 if self._map.hasdir(nf):
23375
a179db3db9b9 dirstate: speed up repeated missing directory checks
Martin von Zweigbergk <martinvonz@google.com>
parents: 22915
diff changeset
870 notfoundadd(nf)
8677
34df078b8b1b walk: simplify logic for badfn clause
Matt Mackall <mpm@selenic.com>
parents: 8676
diff changeset
871 else:
34022
d5b2beca16c0 python3: wrap all uses of <exception>.strerror with strtolocal
Augie Fackler <raf@durin42.com>
parents: 33981
diff changeset
872 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
873
36200
deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents: 35895
diff changeset
874 # 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
875 # 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
876 # 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
877 if match.anypats():
deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents: 35895
diff changeset
878 for f in list(results):
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
879 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
880 # 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
881 continue
deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents: 35895
diff changeset
882 if not match(f):
deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents: 35895
diff changeset
883 del results[f]
deb851914fd7 dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents: 35895
diff changeset
884
25877
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
885 # 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
886 # 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
887 # 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
888 # 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
889 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
890 normed = {}
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
891
43106
d783f945a701 py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents: 43090
diff changeset
892 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
893 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
894 continue
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
895
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
896 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
897 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
898
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
899 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
900 paths = set()
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
901 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
902
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
903 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
904
43106
d783f945a701 py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents: 43090
diff changeset
905 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
906 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
907 for path in paths:
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
908 folded = self._discoverpath(
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
909 path, norm, True, None, self._map.dirfoldmap
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
910 )
25877
85785cd3b69f dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents: 25660
diff changeset
911 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
912 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
913
19174
022256ef47b8 dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents: 19173
diff changeset
914 return results, dirsfound, dirsnotfound
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
915
19190
b03952ee634d dirstate.walk: add a flag to let extensions avoid full walks
Siddharth Agarwal <sid0@fb.com>
parents: 19175
diff changeset
916 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
917 """
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
918 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
919 matched by match.
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
920
19190
b03952ee634d dirstate.walk: add a flag to let extensions avoid full walks
Siddharth Agarwal <sid0@fb.com>
parents: 19175
diff changeset
921 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
922
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
923 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
924 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
925
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
diff changeset
926 """
19190
b03952ee634d dirstate.walk: add a flag to let extensions avoid full walks
Siddharth Agarwal <sid0@fb.com>
parents: 19175
diff changeset
927 # 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
928 # 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
929 # 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
930
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
931 if ignored:
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
932 ignore = util.never
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
933 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
934 elif unknown:
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents: 21026
diff changeset
935 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
936 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
937 else:
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents: 21026
diff changeset
938 # 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
939 ignore = util.always
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
940 dirignore = util.always
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
941
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
942 matchfn = match.matchfn
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
943 matchalways = match.always()
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
944 matchtdir = match.traversedir
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
945 dmap = self._map
32208
d74b0cff94a9 osutil: proxy through util (and platform) modules (API)
Yuya Nishihara <yuya@tcha.org>
parents: 32177
diff changeset
946 listdir = util.listdir
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
947 lstat = os.lstat
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
948 dirkind = stat.S_IFDIR
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
949 regkind = stat.S_IFREG
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
950 lnkkind = stat.S_IFLNK
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
951 join = self._join
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
952
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
953 exact = skipstep3 = False
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
954 if match.isexact(): # match.exact
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
955 exact = True
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
956 dirignore = util.always # skip step 2
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
957 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
958 skipstep3 = True
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
959
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
960 if not exact and self._checkcase:
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
961 normalize = self._normalize
24541
e235b5dc5cf9 dirstate.walk: use the file foldmap to normalize
Siddharth Agarwal <sid0@fb.com>
parents: 24540
diff changeset
962 normalizefile = self._normalizefile
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
963 skipstep3 = False
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
964 else:
24560
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
965 normalize = self._normalize
24541
e235b5dc5cf9 dirstate.walk: use the file foldmap to normalize
Siddharth Agarwal <sid0@fb.com>
parents: 24540
diff changeset
966 normalizefile = None
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
967
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
968 # step 1: find all explicit files
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
969 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
970 if matchtdir:
95d2eab0a7b9 dirstate: include explicit matches in match.traversedir calls
Martin von Zweigbergk <martinvonz@google.com>
parents: 43696
diff changeset
971 for d in work:
95d2eab0a7b9 dirstate: include explicit matches in match.traversedir calls
Martin von Zweigbergk <martinvonz@google.com>
parents: 43696
diff changeset
972 matchtdir(d[0])
95d2eab0a7b9 dirstate: include explicit matches in match.traversedir calls
Martin von Zweigbergk <martinvonz@google.com>
parents: 43696
diff changeset
973 for d in dirsnotfound:
95d2eab0a7b9 dirstate: include explicit matches in match.traversedir calls
Martin von Zweigbergk <martinvonz@google.com>
parents: 43696
diff changeset
974 matchtdir(d)
19173
ec70a78a70e0 dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents: 19172
diff changeset
975
19172
c6cea2e2031b dirstate.walk: pull skipstep3 out of the explicit walk code
Siddharth Agarwal <sid0@fb.com>
parents: 19171
diff changeset
976 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
977 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
978
6826
eca20fee0728 dirstate.walk: pull directory scanning into top-level loop
Matt Mackall <mpm@selenic.com>
parents: 6825
diff changeset
979 # 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
980 def traverse(work, alreadynormed):
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
981 wadd = work.append
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
982 while work:
43239
6fcdcea2b03a dirstate: add some traces on listdir calls
Augie Fackler <augie@google.com>
parents: 43117
diff changeset
983 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
984 nd = work.pop()
38956
a3cabe9415e1 dirstate: use visitchildrenset in traverse
Kyle Lippincott <spectral@google.com>
parents: 36995
diff changeset
985 visitentries = match.visitchildrenset(nd)
a3cabe9415e1 dirstate: use visitchildrenset in traverse
Kyle Lippincott <spectral@google.com>
parents: 36995
diff changeset
986 if not visitentries:
32177
8f1a2b848b52 dirstate: optimize walk() by using match.visitdir()
Martin von Zweigbergk <martinvonz@google.com>
parents: 31547
diff changeset
987 continue
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
988 if visitentries == b'this' or visitentries == b'all':
38956
a3cabe9415e1 dirstate: use visitchildrenset in traverse
Kyle Lippincott <spectral@google.com>
parents: 36995
diff changeset
989 visitentries = None
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
990 skip = None
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
991 if nd != b'':
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
992 skip = b'.hg'
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
993 try:
43239
6fcdcea2b03a dirstate: add some traces on listdir calls
Augie Fackler <augie@google.com>
parents: 43117
diff changeset
994 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
995 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
996 except OSError as inst:
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
997 if inst.errno in (errno.EACCES, errno.ENOENT):
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
998 match.bad(
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
999 self.pathto(nd), encoding.strtolocal(inst.strerror)
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1000 )
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
1001 continue
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
1002 raise
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
1003 for f, kind, st in entries:
39260
27946fca8a05 match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents: 38959
diff changeset
1004 # 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
1005 # 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
1006 # 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
1007 # 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
1008 # 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
1009 # 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
1010 # 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
1011 # they're actually a file or a directory.
38956
a3cabe9415e1 dirstate: use visitchildrenset in traverse
Kyle Lippincott <spectral@google.com>
parents: 36995
diff changeset
1012 if visitentries and f not in visitentries:
a3cabe9415e1 dirstate: use visitchildrenset in traverse
Kyle Lippincott <spectral@google.com>
parents: 36995
diff changeset
1013 continue
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
1014 if normalizefile:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
1015 # 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
1016 # 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
1017 # dmap -- therefore normalizefile is enough
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1018 nf = normalizefile(
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1019 nd and (nd + b"/" + f) or f, True, True
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1020 )
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
1021 else:
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1022 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
1023 if nf not in results:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
1024 if kind == dirkind:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
1025 if not ignore(nf):
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
1026 if matchtdir:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
1027 matchtdir(nf)
24560
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
1028 wadd(nf)
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
1029 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
1030 results[nf] = None
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
1031 elif kind == regkind or kind == lnkkind:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
1032 if nf in dmap:
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
1033 if matchalways or matchfn(nf):
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
1034 results[nf] = st
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1035 elif (matchalways or matchfn(nf)) and not ignore(
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1036 nf
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1037 ):
24560
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
1038 # 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
1039 if not alreadynormed:
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
1040 nf = normalize(nf, False, True)
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
1041 results[nf] = st
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
1042 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
1043 results[nf] = None
24559
4728d6f7c69f dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents: 24553
diff changeset
1044
24560
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
1045 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
1046 # 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
1047 # expensive directory normalization
b38bcf18993c dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents: 24559
diff changeset
1048 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
1049 traverse([d], alreadynormed)
536
c15b4bc0a11c Refactor diffrevs/diffdir into changes
mpm@selenic.com
parents: 529
diff changeset
1050
18812
1c40526da52a dirstate.walk: remove subrepo and .hg from results before step 3
Siddharth Agarwal <sid0@fb.com>
parents: 18792
diff changeset
1051 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
1052 del results[s]
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1053 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
1054
21115
1b6e37f44250 dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents: 21026
diff changeset
1055 # 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
1056 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
1057 # 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
1058 # 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
1059 # 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
1060 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
1061 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
1062 else:
a18919de61e5 dirstate.walk: fast path none-seen + match-always case for step 3
Siddharth Agarwal <sid0@fb.com>
parents: 18814
diff changeset
1063 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
1064 visit.sort()
a18919de61e5 dirstate.walk: fast path none-seen + match-always case for step 3
Siddharth Agarwal <sid0@fb.com>
parents: 18814
diff changeset
1065
18625
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents: 18567
diff changeset
1066 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
1067 # 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
1068 # 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
1069 # 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
1070 # 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
1071 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
1072
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents: 18567
diff changeset
1073 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
1074 # 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
1075 # 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
1076 # 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
1077 # on disk.
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1078 if (
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1079 normalizefile
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1080 and normalizefile(nf, True, True) in results
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1081 ):
24621
1784ca148392 dirstate.walk: don't report same file stat multiple times
Martin von Zweigbergk <martinvonz@google.com>
parents: 24537
diff changeset
1082 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
1083 # 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
1084 # 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
1085 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
1086 try:
05cf40f9b0ec dirstate: fix generator/list error when using python 2.7
Durham Goode <durham@fb.com>
parents: 18653
diff changeset
1087 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
1088 # 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
1089 except OSError:
05cf40f9b0ec dirstate: fix generator/list error when using python 2.7
Durham Goode <durham@fb.com>
parents: 18653
diff changeset
1090 # file doesn't exist
05cf40f9b0ec dirstate: fix generator/list error when using python 2.7
Durham Goode <durham@fb.com>
parents: 18653
diff changeset
1091 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
1092 else:
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents: 18567
diff changeset
1093 # 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
1094 # 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
1095 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
1096 else:
2cbd27f4f3c4 dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents: 18567
diff changeset
1097 # 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
1098 # 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
1099 iv = iter(visit)
26984
af2663680e95 dirstate: back out 502b56a9e897
Bryan O'Sullivan <bos@serpentine.com>
parents: 26887
diff changeset
1100 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
1101 results[next(iv)] = st
6829
fec1da46006e dirstate.walk: build a dict rather than yield
Matt Mackall <mpm@selenic.com>
parents: 6828
diff changeset
1102 return results
669
8aa2a282eda4 .hgignore speedups patch incorporating Matt's feedback.
mwilli2@localhost.localdomain
parents: 667
diff changeset
1103
44530
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
1104 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
1105 # 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
1106 # 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
1107 # 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
1108 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
1109 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
1110 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
1111
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
1112 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
1113 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
1114 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
1115
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
1116 (
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
1117 lookup,
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
1118 modified,
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
1119 added,
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
1120 removed,
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
1121 deleted,
44530
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
1122 clean,
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
1123 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
1124 unknown,
44530
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
1125 warnings,
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
1126 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
1127 traversed,
44078
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
1128 ) = rustmod.status(
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
1129 self._map._rustmap,
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
1130 matcher,
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
1131 self._rootdir,
44530
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
1132 self._ignorefiles(),
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
1133 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
1134 self._lastnormaltime,
44530
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
1135 bool(list_clean),
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
1136 bool(list_ignored),
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
1137 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
1138 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
1139 )
44840
4ba2a6ffcf24 status: also support for `traversedir` callback in the Rust fast-path
Raphaël Gomès <rgomes@octobus.net>
parents: 44836
diff changeset
1140
4ba2a6ffcf24 status: also support for `traversedir` callback in the Rust fast-path
Raphaël Gomès <rgomes@octobus.net>
parents: 44836
diff changeset
1141 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
1142 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
1143 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
1144
44530
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
1145 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
1146 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
1147 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
1148 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
1149 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
1150 file_path,
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
1151 syntax,
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
1152 )
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
1153 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
1154 else:
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
1155 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
1156 self._ui.warn(
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
1157 msg
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
1158 % (
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
1159 pathutil.canonpath(
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
1160 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
1161 ),
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
1162 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
1163 )
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
1164 )
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
1165
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
1166 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
1167 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
1168
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
1169 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
1170 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
1171 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
1172 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
1173 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
1174 unknown=unknown,
44530
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
1175 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
1176 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
1177 )
f2c350e7371e dirstate: move rust fast-path calling code to its own method
Raphaël Gomès <rgomes@octobus.net>
parents: 43917
diff changeset
1178 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
1179
10176
24ce8f0c0a39 dirstate: don't check state of subrepo directories
Augie Fackler <durin42@gmail.com>
parents: 10145
diff changeset
1180 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
1181 """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
1182 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
1183 scmutil.status and:
9518
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
1184
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
1185 unsure:
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
1186 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
1187 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
1188 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
1189 status.modified:
9518
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
1190 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
1191 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
1192 status.clean:
9518
bc19a0b04e83 dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents: 9509
diff changeset
1193 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
1194 dirstate was written
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
diff changeset
1195 """
6753
ed5ffb2c12f3 repo.status: eliminate list_
Matt Mackall <mpm@selenic.com>
parents: 6750
diff changeset
1196 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
1197 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
1198 removed, deleted, clean = [], [], []
723
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
1199
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
1200 dmap = self._map
34935
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents: 34934
diff changeset
1201 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
1202
733d4ffcd667 rust-dirstate-status: add call to rust-fast path for `dirstate.status`
Raphaël Gomès <rgomes@octobus.net>
parents: 43239
diff changeset
1203 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
1204
44530
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
1205 allowed_matchers = (
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
1206 matchmod.alwaysmatcher,
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
1207 matchmod.exactmatcher,
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
1208 matchmod.includematcher,
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
1209 )
43917
40fd1ef4e4c1 rust-matchers: add support for `exactmatcher` in `dirstate.status`
Raphaël Gomès <rgomes@octobus.net>
parents: 43891
diff changeset
1210
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
1211 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
1212 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
1213 elif self._checkcase:
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
1214 # 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
1215 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
1216 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
1217 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
1218 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
1219 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
1220 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
1221 # 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
1222 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
1223
733d4ffcd667 rust-dirstate-status: add call to rust-fast path for `dirstate.status`
Raphaël Gomès <rgomes@octobus.net>
parents: 43239
diff changeset
1224 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
1225 try:
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
1226 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
1227 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
1228 )
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
1229 except rustmod.FallbackError:
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
1230 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
1231
43620
dd773340a085 dirstate: respect request to not list unknown/ignored/clean files (API)
Martin von Zweigbergk <martinvonz@google.com>
parents: 43612
diff changeset
1232 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
1233 pass
dd773340a085 dirstate: respect request to not list unknown/ignored/clean files (API)
Martin von Zweigbergk <martinvonz@google.com>
parents: 43612
diff changeset
1234
34935
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents: 34934
diff changeset
1235 dcontains = dmap.__contains__
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents: 34934
diff changeset
1236 dget = dmap.__getitem__
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1237 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
1238 madd = modified.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
1239 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
1240 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
1241 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
1242 radd = removed.append
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
1243 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
1244 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
1245 mexact = match.exact
1a570f04de07 dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents: 18032
diff changeset
1246 dirignore = self._dirignore
1a570f04de07 dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents: 18032
diff changeset
1247 checkexec = self._checkexec
34336
0865d25e8a8a dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34335
diff changeset
1248 copymap = self._map.copymap
18034
1a570f04de07 dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents: 18032
diff changeset
1249 lastnormaltime = self._lastnormaltime
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
1250
19191
ab9de1e8fc36 dirstate.status: avoid full walks when possible
Siddharth Agarwal <sid0@fb.com>
parents: 19190
diff changeset
1251 # 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
1252 # - we're listing all clean files, or
ab9de1e8fc36 dirstate.status: avoid full walks when possible
Siddharth Agarwal <sid0@fb.com>
parents: 19190
diff changeset
1253 # - 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
1254 # 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
1255 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
1256 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
1257 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
1258 ):
34935
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents: 34934
diff changeset
1259 if not dcontains(fn):
18034
1a570f04de07 dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents: 18032
diff changeset
1260 if (listignored or mexact(fn)) and dirignore(fn):
6753
ed5ffb2c12f3 repo.status: eliminate list_
Matt Mackall <mpm@selenic.com>
parents: 6750
diff changeset
1261 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
1262 iadd(fn)
19910
601944f41257 dirstate.status: return explicit unknown files even when not asked
Siddharth Agarwal <sid0@fb.com>
parents: 19651
diff changeset
1263 else:
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
1264 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
1265 continue
6591
eda3fd322a7f dirstate: minor status cleanups
Matt Mackall <mpm@selenic.com>
parents: 6590
diff changeset
1266
21810
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple
Siddharth Agarwal <sid0@fb.com>
parents: 21809
diff changeset
1267 # 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
1268 # 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
1269 # 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
1270 # 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
1271 # 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
1272 # 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
1273 # 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
1274 t = dget(fn)
21810
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple
Siddharth Agarwal <sid0@fb.com>
parents: 21809
diff changeset
1275 state = t[0]
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple
Siddharth Agarwal <sid0@fb.com>
parents: 21809
diff changeset
1276 mode = t[1]
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple
Siddharth Agarwal <sid0@fb.com>
parents: 21809
diff changeset
1277 size = t[2]
4b2ebd3187a1 dirstate.status: assign members one by one instead of unpacking the tuple
Siddharth Agarwal <sid0@fb.com>
parents: 21809
diff changeset
1278 time = t[3]
6591
eda3fd322a7f dirstate: minor status cleanups
Matt Mackall <mpm@selenic.com>
parents: 6590
diff changeset
1279
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1280 if not st and state in b"nma":
6818
6e93fbd847ef dirstate.walk: eliminate src from yield
Matt Mackall <mpm@selenic.com>
parents: 6811
diff changeset
1281 dadd(fn)
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1282 elif state == b'n':
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1283 if (
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1284 size >= 0
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1285 and (
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1286 (size != st.st_size and size != st.st_size & _rangemask)
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1287 or ((mode ^ st.st_mode) & 0o100 and checkexec)
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1288 )
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1289 or size == -2 # other parent
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1290 or fn in copymap
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1291 ):
46703
ca69e29a2a30 formatting: fix redundant parentheses
Raphaël Gomès <rgomes@octobus.net>
parents: 46678
diff changeset
1292 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
1293 # 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
1294 # 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
1295 ladd(fn)
0d055849d5f9 enclink: check contents of symlinks not just size in case of fcrypt
Corey Schuhen <cschuhen@topcon.com>
parents: 45942
diff changeset
1296 else:
0d055849d5f9 enclink: check contents of symlinks not just size in case of fcrypt
Corey Schuhen <cschuhen@topcon.com>
parents: 45942
diff changeset
1297 madd(fn)
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1298 elif (
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1299 time != st[stat.ST_MTIME]
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1300 and time != st[stat.ST_MTIME] & _rangemask
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1301 ):
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
1302 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
1303 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
1304 # 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
1305 # 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
1306 # This can happen if we quickly do multiple commits.
13763
7a73c406c0fd dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents: 13754
diff changeset
1307 # 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
1308 ladd(fn)
6753
ed5ffb2c12f3 repo.status: eliminate list_
Matt Mackall <mpm@selenic.com>
parents: 6750
diff changeset
1309 elif listclean:
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
1310 cadd(fn)
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1311 elif state == b'm':
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
1312 madd(fn)
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1313 elif state == b'a':
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
1314 aadd(fn)
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1315 elif state == b'r':
5003
4b1acb3ecb3c dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents: 5002
diff changeset
1316 radd(fn)
44530
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
1317 status = scmutil.status(
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
1318 modified, added, removed, deleted, unknown, ignored, clean
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1319 )
44530
4d1634e59f13 rust-status: use bare hg status fastpath from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 44357
diff changeset
1320 return (lookup, status)
21984
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
1321
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
1322 def matches(self, match):
45942
89a2afe31e82 formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents: 45243
diff changeset
1323 """
21984
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
1324 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
1325 """
21984
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
1326 dmap = self._map
44357
bed8d08cfcb2 rust-dirstatemap: remove additional lookup in dirstate.matches
Raphaël Gomès <rgomes@octobus.net>
parents: 44297
diff changeset
1327 if rustmod is not None:
bed8d08cfcb2 rust-dirstatemap: remove additional lookup in dirstate.matches
Raphaël Gomès <rgomes@octobus.net>
parents: 44297
diff changeset
1328 dmap = self._map._rustmap
bed8d08cfcb2 rust-dirstatemap: remove additional lookup in dirstate.matches
Raphaël Gomès <rgomes@octobus.net>
parents: 44297
diff changeset
1329
21984
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
1330 if match.always():
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
1331 return dmap.keys()
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
1332 files = match.files()
24448
55c449345b10 match: add isexact() method to hide internals
Martin von Zweigbergk <martinvonz@google.com>
parents: 24212
diff changeset
1333 if match.isexact():
21984
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
1334 # 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
1335 # much smaller than dmap
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
1336 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
1337 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
1338 # 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
1339 # that
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
1340 return list(files)
977a0b9af5ac dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents: 21931
diff changeset
1341 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
1342
26746
3c1d297fe929 dirstateguard: remove layering violation around saving/restoring backup
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26635
diff changeset
1343 def _actualfilename(self, tr):
3c1d297fe929 dirstateguard: remove layering violation around saving/restoring backup
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26635
diff changeset
1344 if tr:
26633
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
1345 return self._pendingfilename
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
1346 else:
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
1347 return self._filename
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
1348
33440
ec306bc6915b dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents: 33373
diff changeset
1349 def savebackup(self, tr, backupname):
ec306bc6915b dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents: 33373
diff changeset
1350 '''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
1351 filename = self._actualfilename(tr)
33440
ec306bc6915b dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents: 33373
diff changeset
1352 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
1353
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
1354 # 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
1355 # 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
1356 # 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
1357 if self._dirty or not self._opener.exists(filename):
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1358 self._writedirstate(
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1359 self._opener(filename, b"w", atomictemp=True, checkambig=True)
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1360 )
26633
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
1361
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
1362 if tr:
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
1363 # 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
1364 # 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
1365 # changed after this
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1366 tr.addfilegenerator(
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1367 b'dirstate',
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1368 (self._filename,),
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1369 self._writedirstate,
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1370 location=b'plain',
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1371 )
26633
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
1372
020b12d591f3 dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26632
diff changeset
1373 # 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
1374 # 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
1375 # end of this transaction
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1376 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
1377
31547
ddadb6b0b58e dirstate: use tryunlink
Ryan McElroy <rmcelroy@fb.com>
parents: 31507
diff changeset
1378 self._opener.tryunlink(backupname)
31207
1ef37b16b8e8 dirstate: try to use hardlink to backup dirstate
Jun Wu <quark@fb.com>
parents: 31206
diff changeset
1379 # 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
1380 # with an "atomictemp=True" file.
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1381 util.copyfile(
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1382 self._opener.join(filename),
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1383 self._opener.join(backupname),
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1384 hardlink=True,
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1385 )
26632
59b5e8844eb0 dirstate: move code paths for backup from dirstateguard to dirstate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26630
diff changeset
1386
33440
ec306bc6915b dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents: 33373
diff changeset
1387 def restorebackup(self, tr, backupname):
ec306bc6915b dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents: 33373
diff changeset
1388 '''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
1389 # 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
1390 # 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
1391 self.invalidate()
26746
3c1d297fe929 dirstateguard: remove layering violation around saving/restoring backup
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents: 26635
diff changeset
1392 filename = self._actualfilename(tr)
34940
c2b30348930f dirstate: clean up when restoring identical backups
Mark Thomas <mbthomas@fb.com>
parents: 34935
diff changeset
1393 o = self._opener
c2b30348930f dirstate: clean up when restoring identical backups
Mark Thomas <mbthomas@fb.com>
parents: 34935
diff changeset
1394 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
1395 o.unlink(backupname)
c2b30348930f dirstate: clean up when restoring identical backups
Mark Thomas <mbthomas@fb.com>
parents: 34935
diff changeset
1396 else:
c2b30348930f dirstate: clean up when restoring identical backups
Mark Thomas <mbthomas@fb.com>
parents: 34935
diff changeset
1397 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
1398
33440
ec306bc6915b dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents: 33373
diff changeset
1399 def clearbackup(self, tr, backupname):
ec306bc6915b dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents: 33373
diff changeset
1400 '''Clear backup file'''
ec306bc6915b dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents: 33373
diff changeset
1401 self._opener.unlink(backupname)
34332
b36881c68569 dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents: 34188
diff changeset
1402
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1403
34332
b36881c68569 dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents: 34188
diff changeset
1404 class dirstatemap(object):
35078
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
1405 """Map encapsulating the dirstate's contents.
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
1406
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
1407 The dirstate contains the following state:
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
1408
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
1409 - `identity` is the identity of the dirstate file, which can be used to
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
1410 detect when changes have occurred to the dirstate file.
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
1411
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
1412 - `parents` is a pair containing the parents of the working copy. The
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
1413 parents are updated by calling `setparents`.
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
1414
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
1415 - the state map maps filenames to tuples of (state, mode, size, mtime),
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
1416 where state is a single character representing 'normal', 'added',
35079
853b7c41d19c dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents: 35078
diff changeset
1417 'removed', or 'merged'. It is read by treating the dirstate as a
853b7c41d19c dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents: 35078
diff changeset
1418 dict. File state is updated by calling the `addfile`, `removefile` and
853b7c41d19c dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents: 35078
diff changeset
1419 `dropfile` methods.
35078
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
1420
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
1421 - `copymap` maps destination filenames to their source filename.
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
1422
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
1423 The dirstate also provides the following views onto the state:
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
1424
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
1425 - `nonnormalset` is a set of the filenames that have state other
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
1426 than 'normal', or are normal but have an mtime of -1 ('normallookup').
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
1427
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
1428 - `otherparentset` is a set of the filenames that are marked as coming
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
1429 from the second parent when the dirstate is currently being merged.
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
1430
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
1431 - `filefoldmap` is a dict mapping normalized filenames to the denormalized
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
1432 form that they appear as in the dirstate.
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
1433
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
1434 - `dirfoldmap` is a dict mapping normalized directory names to the
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
1435 denormalized form that they appear as in the dirstate.
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
1436 """
a052022639cc dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents: 35016
diff changeset
1437
46780
6266d19556ad node: introduce nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 45942
diff changeset
1438 def __init__(self, ui, opener, root, nodeconstants):
34337
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents: 34336
diff changeset
1439 self._ui = ui
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents: 34336
diff changeset
1440 self._opener = opener
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents: 34336
diff changeset
1441 self._root = root
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1442 self._filename = b'dirstate'
45219
4f0e03d980f3 dirstate: isolate node len dependency for the pure version
Joerg Sonnenberger <joerg@bec.de>
parents: 44852
diff changeset
1443 self._nodelen = 20
46780
6266d19556ad node: introduce nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 45942
diff changeset
1444 self._nodeconstants = nodeconstants
34337
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents: 34336
diff changeset
1445
34339
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
1446 self._parents = None
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
1447 self._dirtyparents = False
34332
b36881c68569 dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents: 34188
diff changeset
1448
34337
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents: 34336
diff changeset
1449 # for consistent view between _pl() and _read() invocations
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents: 34336
diff changeset
1450 self._pendingmode = None
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents: 34336
diff changeset
1451
34934
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717)
Durham Goode <durham@fb.com>
parents: 34933
diff changeset
1452 @propertycache
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717)
Durham Goode <durham@fb.com>
parents: 34933
diff changeset
1453 def _map(self):
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717)
Durham Goode <durham@fb.com>
parents: 34933
diff changeset
1454 self._map = {}
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717)
Durham Goode <durham@fb.com>
parents: 34933
diff changeset
1455 self.read()
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717)
Durham Goode <durham@fb.com>
parents: 34933
diff changeset
1456 return self._map
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717)
Durham Goode <durham@fb.com>
parents: 34933
diff changeset
1457
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717)
Durham Goode <durham@fb.com>
parents: 34933
diff changeset
1458 @propertycache
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717)
Durham Goode <durham@fb.com>
parents: 34933
diff changeset
1459 def copymap(self):
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717)
Durham Goode <durham@fb.com>
parents: 34933
diff changeset
1460 self.copymap = {}
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717)
Durham Goode <durham@fb.com>
parents: 34933
diff changeset
1461 self._map
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717)
Durham Goode <durham@fb.com>
parents: 34933
diff changeset
1462 return self.copymap
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717)
Durham Goode <durham@fb.com>
parents: 34933
diff changeset
1463
34933
0217f75b6e59 dirstate: move clear onto dirstatemap class
Durham Goode <durham@fb.com>
parents: 34678
diff changeset
1464 def clear(self):
34935
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents: 34934
diff changeset
1465 self._map.clear()
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents: 34934
diff changeset
1466 self.copymap.clear()
47012
d55b71393907 node: replace nullid and friends with nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 46819
diff changeset
1467 self.setparents(self._nodeconstants.nullid, self._nodeconstants.nullid)
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1468 util.clearcachedproperty(self, b"_dirs")
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1469 util.clearcachedproperty(self, b"_alldirs")
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1470 util.clearcachedproperty(self, b"filefoldmap")
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1471 util.clearcachedproperty(self, b"dirfoldmap")
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1472 util.clearcachedproperty(self, b"nonnormalset")
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1473 util.clearcachedproperty(self, b"otherparentset")
34933
0217f75b6e59 dirstate: move clear onto dirstatemap class
Durham Goode <durham@fb.com>
parents: 34678
diff changeset
1474
35878
6e7fae8f1c6c contrib: fix dirstatenonnormalcheck to work in Python 3
Augie Fackler <augie@google.com>
parents: 35835
diff changeset
1475 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
1476 return pycompat.iteritems(self._map)
34332
b36881c68569 dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents: 34188
diff changeset
1477
35878
6e7fae8f1c6c contrib: fix dirstatenonnormalcheck to work in Python 3
Augie Fackler <augie@google.com>
parents: 35835
diff changeset
1478 # forward for python2,3 compat
6e7fae8f1c6c contrib: fix dirstatenonnormalcheck to work in Python 3
Augie Fackler <augie@google.com>
parents: 35835
diff changeset
1479 iteritems = items
6e7fae8f1c6c contrib: fix dirstatenonnormalcheck to work in Python 3
Augie Fackler <augie@google.com>
parents: 35835
diff changeset
1480
34408
7d2f71b7bc31 dirstate: implement __len__ on dirstatemap (issue5695)
Simon Whitaker <swhitaker@fb.com>
parents: 34339
diff changeset
1481 def __len__(self):
7d2f71b7bc31 dirstate: implement __len__ on dirstatemap (issue5695)
Simon Whitaker <swhitaker@fb.com>
parents: 34339
diff changeset
1482 return len(self._map)
7d2f71b7bc31 dirstate: implement __len__ on dirstatemap (issue5695)
Simon Whitaker <swhitaker@fb.com>
parents: 34339
diff changeset
1483
34332
b36881c68569 dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents: 34188
diff changeset
1484 def __iter__(self):
b36881c68569 dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents: 34188
diff changeset
1485 return iter(self._map)
b36881c68569 dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents: 34188
diff changeset
1486
b36881c68569 dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents: 34188
diff changeset
1487 def get(self, key, default=None):
b36881c68569 dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents: 34188
diff changeset
1488 return self._map.get(key, default)
b36881c68569 dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents: 34188
diff changeset
1489
b36881c68569 dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents: 34188
diff changeset
1490 def __contains__(self, key):
b36881c68569 dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents: 34188
diff changeset
1491 return key in self._map
b36881c68569 dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents: 34188
diff changeset
1492
b36881c68569 dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents: 34188
diff changeset
1493 def __getitem__(self, key):
b36881c68569 dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents: 34188
diff changeset
1494 return self._map[key]
b36881c68569 dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents: 34188
diff changeset
1495
b36881c68569 dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents: 34188
diff changeset
1496 def keys(self):
b36881c68569 dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents: 34188
diff changeset
1497 return self._map.keys()
34333
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents: 34332
diff changeset
1498
34935
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents: 34934
diff changeset
1499 def preload(self):
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents: 34934
diff changeset
1500 """Loads the underlying data, if it's not already loaded"""
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents: 34934
diff changeset
1501 self._map
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents: 34934
diff changeset
1502
35081
a947cf872799 dirstate: move management of the dirstate dirs into the dirstatemap
Mark Thomas <mbthomas@fb.com>
parents: 35080
diff changeset
1503 def addfile(self, f, oldstate, state, mode, size, mtime):
35079
853b7c41d19c dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents: 35078
diff changeset
1504 """Add a tracked file to the dirstate."""
43503
313e3a279828 cleanup: remove pointless r-prefixes on double-quoted strings
Augie Fackler <augie@google.com>
parents: 43456
diff changeset
1505 if oldstate in b"?r" and "_dirs" in self.__dict__:
35084
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
1506 self._dirs.addpath(f)
43503
313e3a279828 cleanup: remove pointless r-prefixes on double-quoted strings
Augie Fackler <augie@google.com>
parents: 43456
diff changeset
1507 if oldstate == b"?" and "_alldirs" in self.__dict__:
35084
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
1508 self._alldirs.addpath(f)
35079
853b7c41d19c dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents: 35078
diff changeset
1509 self._map[f] = dirstatetuple(state, mode, size, mtime)
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1510 if state != b'n' or mtime == -1:
35080
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents: 35079
diff changeset
1511 self.nonnormalset.add(f)
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents: 35079
diff changeset
1512 if size == -2:
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents: 35079
diff changeset
1513 self.otherparentset.add(f)
35079
853b7c41d19c dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents: 35078
diff changeset
1514
35081
a947cf872799 dirstate: move management of the dirstate dirs into the dirstatemap
Mark Thomas <mbthomas@fb.com>
parents: 35080
diff changeset
1515 def removefile(self, f, oldstate, size):
35079
853b7c41d19c dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents: 35078
diff changeset
1516 """
853b7c41d19c dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents: 35078
diff changeset
1517 Mark a file as removed in the dirstate.
853b7c41d19c dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents: 35078
diff changeset
1518
853b7c41d19c dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents: 35078
diff changeset
1519 The `size` parameter is used to store sentinel values that indicate
853b7c41d19c dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents: 35078
diff changeset
1520 the file's previous state. In the future, we should refactor this
853b7c41d19c dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents: 35078
diff changeset
1521 to be more explicit about what that state is.
853b7c41d19c dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents: 35078
diff changeset
1522 """
43503
313e3a279828 cleanup: remove pointless r-prefixes on double-quoted strings
Augie Fackler <augie@google.com>
parents: 43456
diff changeset
1523 if oldstate not in b"?r" and "_dirs" in self.__dict__:
35084
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
1524 self._dirs.delpath(f)
43503
313e3a279828 cleanup: remove pointless r-prefixes on double-quoted strings
Augie Fackler <augie@google.com>
parents: 43456
diff changeset
1525 if oldstate == b"?" and "_alldirs" in self.__dict__:
35084
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
1526 self._alldirs.addpath(f)
43503
313e3a279828 cleanup: remove pointless r-prefixes on double-quoted strings
Augie Fackler <augie@google.com>
parents: 43456
diff changeset
1527 if "filefoldmap" in self.__dict__:
35082
e6c64744781f dirstate: move dropping of folded filenames into the dirstate map
Mark Thomas <mbthomas@fb.com>
parents: 35081
diff changeset
1528 normed = util.normcase(f)
e6c64744781f dirstate: move dropping of folded filenames into the dirstate map
Mark Thomas <mbthomas@fb.com>
parents: 35081
diff changeset
1529 self.filefoldmap.pop(normed, None)
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1530 self._map[f] = dirstatetuple(b'r', 0, size, 0)
35080
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents: 35079
diff changeset
1531 self.nonnormalset.add(f)
35079
853b7c41d19c dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents: 35078
diff changeset
1532
35081
a947cf872799 dirstate: move management of the dirstate dirs into the dirstatemap
Mark Thomas <mbthomas@fb.com>
parents: 35080
diff changeset
1533 def dropfile(self, f, oldstate):
35079
853b7c41d19c dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents: 35078
diff changeset
1534 """
853b7c41d19c dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents: 35078
diff changeset
1535 Remove a file from the dirstate. Returns True if the file was
853b7c41d19c dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents: 35078
diff changeset
1536 previously recorded.
853b7c41d19c dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents: 35078
diff changeset
1537 """
35080
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents: 35079
diff changeset
1538 exists = self._map.pop(f, None) is not None
35081
a947cf872799 dirstate: move management of the dirstate dirs into the dirstatemap
Mark Thomas <mbthomas@fb.com>
parents: 35080
diff changeset
1539 if exists:
43503
313e3a279828 cleanup: remove pointless r-prefixes on double-quoted strings
Augie Fackler <augie@google.com>
parents: 43456
diff changeset
1540 if oldstate != b"r" and "_dirs" in self.__dict__:
35084
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
1541 self._dirs.delpath(f)
43503
313e3a279828 cleanup: remove pointless r-prefixes on double-quoted strings
Augie Fackler <augie@google.com>
parents: 43456
diff changeset
1542 if "_alldirs" in self.__dict__:
35084
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
1543 self._alldirs.delpath(f)
43503
313e3a279828 cleanup: remove pointless r-prefixes on double-quoted strings
Augie Fackler <augie@google.com>
parents: 43456
diff changeset
1544 if "filefoldmap" in self.__dict__:
35082
e6c64744781f dirstate: move dropping of folded filenames into the dirstate map
Mark Thomas <mbthomas@fb.com>
parents: 35081
diff changeset
1545 normed = util.normcase(f)
e6c64744781f dirstate: move dropping of folded filenames into the dirstate map
Mark Thomas <mbthomas@fb.com>
parents: 35081
diff changeset
1546 self.filefoldmap.pop(normed, None)
35080
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents: 35079
diff changeset
1547 self.nonnormalset.discard(f)
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents: 35079
diff changeset
1548 return exists
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents: 35079
diff changeset
1549
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents: 35079
diff changeset
1550 def clearambiguoustimes(self, files, now):
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents: 35079
diff changeset
1551 for f in files:
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents: 35079
diff changeset
1552 e = self.get(f)
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1553 if e is not None and e[0] == b'n' and e[3] == now:
35080
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents: 35079
diff changeset
1554 self._map[f] = dirstatetuple(e[0], e[1], e[2], -1)
19b75779b7c3 dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents: 35079
diff changeset
1555 self.nonnormalset.add(f)
35079
853b7c41d19c dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents: 35078
diff changeset
1556
34333
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents: 34332
diff changeset
1557 def nonnormalentries(self):
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents: 34332
diff changeset
1558 '''Compute the nonnormal dirstate entries from the dmap'''
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents: 34332
diff changeset
1559 try:
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents: 34332
diff changeset
1560 return parsers.nonnormalotherparententries(self._map)
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents: 34332
diff changeset
1561 except AttributeError:
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents: 34332
diff changeset
1562 nonnorm = set()
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents: 34332
diff changeset
1563 otherparent = set()
43106
d783f945a701 py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents: 43090
diff changeset
1564 for fname, e in pycompat.iteritems(self._map):
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1565 if e[0] != b'n' or e[3] == -1:
34333
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents: 34332
diff changeset
1566 nonnorm.add(fname)
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1567 if e[0] == b'n' and e[2] == -2:
34333
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents: 34332
diff changeset
1568 otherparent.add(fname)
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents: 34332
diff changeset
1569 return nonnorm, otherparent
4ac04418ce66 dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents: 34332
diff changeset
1570
34676
bfddc3d678ae dirstate: remove _filefoldmap property cache
Durham Goode <durham@fb.com>
parents: 34675
diff changeset
1571 @propertycache
34334
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34333
diff changeset
1572 def filefoldmap(self):
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34333
diff changeset
1573 """Returns a dictionary mapping normalized case paths to their
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34333
diff changeset
1574 non-normalized versions.
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34333
diff changeset
1575 """
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34333
diff changeset
1576 try:
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34333
diff changeset
1577 makefilefoldmap = parsers.make_file_foldmap
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34333
diff changeset
1578 except AttributeError:
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34333
diff changeset
1579 pass
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34333
diff changeset
1580 else:
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1581 return makefilefoldmap(
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1582 self._map, util.normcasespec, util.normcasefallback
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1583 )
34334
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34333
diff changeset
1584
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34333
diff changeset
1585 f = {}
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34333
diff changeset
1586 normcase = util.normcase
43106
d783f945a701 py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents: 43090
diff changeset
1587 for name, s in pycompat.iteritems(self._map):
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1588 if s[0] != b'r':
34334
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34333
diff changeset
1589 f[normcase(name)] = name
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1590 f[b'.'] = b'.' # prevents useless util.fspath() invocation
34334
d8b35920b7b1 dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34333
diff changeset
1591 return f
34335
af9722412ac3 dirstate: move _dirs to dirstatemap
Durham Goode <durham@fb.com>
parents: 34334
diff changeset
1592
35084
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
1593 def hastrackeddir(self, d):
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
1594 """
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
1595 Returns True if the dirstate contains a tracked (not removed) file
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
1596 in this directory.
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
1597 """
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
1598 return d in self._dirs
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
1599
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
1600 def hasdir(self, d):
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
1601 """
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
1602 Returns True if the dirstate contains a file (tracked or removed)
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
1603 in this directory.
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
1604 """
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
1605 return d in self._alldirs
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
1606
34677
014bd2a555c8 dirstate: remove _dirs property cache
Durham Goode <durham@fb.com>
parents: 34676
diff changeset
1607 @propertycache
35084
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
1608 def _dirs(self):
43523
c21aca51b392 utils: move the `dirs` definition in pathutil (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43506
diff changeset
1609 return pathutil.dirs(self._map, b'r')
34337
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents: 34336
diff changeset
1610
35084
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
1611 @propertycache
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
1612 def _alldirs(self):
43523
c21aca51b392 utils: move the `dirs` definition in pathutil (API)
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43506
diff changeset
1613 return pathutil.dirs(self._map)
35084
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
1614
34337
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents: 34336
diff changeset
1615 def _opendirstatefile(self):
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents: 34336
diff changeset
1616 fp, mode = txnutil.trypending(self._root, self._opener, self._filename)
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents: 34336
diff changeset
1617 if self._pendingmode is not None and self._pendingmode != mode:
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents: 34336
diff changeset
1618 fp.close()
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1619 raise error.Abort(
43117
8ff1ecfadcd1 cleanup: join string literals that are already on one line
Martin von Zweigbergk <martinvonz@google.com>
parents: 43106
diff changeset
1620 _(b'working directory state may be changed parallelly')
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1621 )
34337
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents: 34336
diff changeset
1622 self._pendingmode = mode
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents: 34336
diff changeset
1623 return fp
c36c3fa7d35b dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents: 34336
diff changeset
1624
34338
0c3e3810cdb6 dirstate: move parent reading to the dirstatemap class
Durham Goode <durham@fb.com>
parents: 34337
diff changeset
1625 def parents(self):
34339
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
1626 if not self._parents:
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
1627 try:
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
1628 fp = self._opendirstatefile()
45219
4f0e03d980f3 dirstate: isolate node len dependency for the pure version
Joerg Sonnenberger <joerg@bec.de>
parents: 44852
diff changeset
1629 st = fp.read(2 * self._nodelen)
34339
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
1630 fp.close()
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
1631 except IOError as err:
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
1632 if err.errno != errno.ENOENT:
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
1633 raise
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
1634 # File doesn't exist, so the current state is empty
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1635 st = b''
34339
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
1636
34338
0c3e3810cdb6 dirstate: move parent reading to the dirstatemap class
Durham Goode <durham@fb.com>
parents: 34337
diff changeset
1637 l = len(st)
45219
4f0e03d980f3 dirstate: isolate node len dependency for the pure version
Joerg Sonnenberger <joerg@bec.de>
parents: 44852
diff changeset
1638 if l == self._nodelen * 2:
4f0e03d980f3 dirstate: isolate node len dependency for the pure version
Joerg Sonnenberger <joerg@bec.de>
parents: 44852
diff changeset
1639 self._parents = (
4f0e03d980f3 dirstate: isolate node len dependency for the pure version
Joerg Sonnenberger <joerg@bec.de>
parents: 44852
diff changeset
1640 st[: self._nodelen],
4f0e03d980f3 dirstate: isolate node len dependency for the pure version
Joerg Sonnenberger <joerg@bec.de>
parents: 44852
diff changeset
1641 st[self._nodelen : 2 * self._nodelen],
4f0e03d980f3 dirstate: isolate node len dependency for the pure version
Joerg Sonnenberger <joerg@bec.de>
parents: 44852
diff changeset
1642 )
34339
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
1643 elif l == 0:
47012
d55b71393907 node: replace nullid and friends with nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 46819
diff changeset
1644 self._parents = (
d55b71393907 node: replace nullid and friends with nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 46819
diff changeset
1645 self._nodeconstants.nullid,
d55b71393907 node: replace nullid and friends with nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 46819
diff changeset
1646 self._nodeconstants.nullid,
d55b71393907 node: replace nullid and friends with nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 46819
diff changeset
1647 )
34339
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
1648 else:
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1649 raise error.Abort(
43117
8ff1ecfadcd1 cleanup: join string literals that are already on one line
Martin von Zweigbergk <martinvonz@google.com>
parents: 43106
diff changeset
1650 _(b'working directory state appears damaged!')
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1651 )
34339
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
1652
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
1653 return self._parents
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
1654
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
1655 def setparents(self, p1, p2):
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
1656 self._parents = (p1, p2)
ec769bba34d3 dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents: 34338
diff changeset
1657 self._dirtyparents = True
34672
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
1658
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
1659 def read(self):
34675
c6ef9a2498a5 dirstate: move identity to dirstatemap
Durham Goode <durham@fb.com>
parents: 34674
diff changeset
1660 # ignore HG_PENDING because identity is used only for writing
c6ef9a2498a5 dirstate: move identity to dirstatemap
Durham Goode <durham@fb.com>
parents: 34674
diff changeset
1661 self.identity = util.filestat.frompath(
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1662 self._opener.join(self._filename)
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1663 )
34675
c6ef9a2498a5 dirstate: move identity to dirstatemap
Durham Goode <durham@fb.com>
parents: 34674
diff changeset
1664
34672
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
1665 try:
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
1666 fp = self._opendirstatefile()
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
1667 try:
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
1668 st = fp.read()
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
1669 finally:
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
1670 fp.close()
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
1671 except IOError as err:
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
1672 if err.errno != errno.ENOENT:
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
1673 raise
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
1674 return
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
1675 if not st:
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
1676 return
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
1677
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1678 if util.safehasattr(parsers, b'dict_new_presized'):
34672
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
1679 # Make an estimate of the number of files in the dirstate based on
45243
ad7006830106 dirstate: restore original estimation and update comment
Joerg Sonnenberger <joerg@bec.de>
parents: 45241
diff changeset
1680 # its size. This trades wasting some memory for avoiding costly
ad7006830106 dirstate: restore original estimation and update comment
Joerg Sonnenberger <joerg@bec.de>
parents: 45241
diff changeset
1681 # resizes. Each entry have a prefix of 17 bytes followed by one or
ad7006830106 dirstate: restore original estimation and update comment
Joerg Sonnenberger <joerg@bec.de>
parents: 45241
diff changeset
1682 # two path names. Studies on various large-scale real-world repositories
ad7006830106 dirstate: restore original estimation and update comment
Joerg Sonnenberger <joerg@bec.de>
parents: 45241
diff changeset
1683 # found 54 bytes a reasonable upper limit for the average path names.
ad7006830106 dirstate: restore original estimation and update comment
Joerg Sonnenberger <joerg@bec.de>
parents: 45241
diff changeset
1684 # Copy entries are ignored for the sake of this estimate.
ad7006830106 dirstate: restore original estimation and update comment
Joerg Sonnenberger <joerg@bec.de>
parents: 45241
diff changeset
1685 self._map = parsers.dict_new_presized(len(st) // 71)
34672
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
1686
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
1687 # Python's garbage collector triggers a GC each time a certain number
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
1688 # of container objects (the number being defined by
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
1689 # gc.get_threshold()) are allocated. parse_dirstate creates a tuple
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
1690 # for each file in the dirstate. The C version then immediately marks
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
1691 # them as not to be tracked by the collector. However, this has no
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
1692 # effect on when GCs are triggered, only on what objects the GC looks
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
1693 # into. This means that O(number of files) GCs are unavoidable.
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
1694 # Depending on when in the process's lifetime the dirstate is parsed,
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
1695 # this can get very expensive. As a workaround, disable GC while
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
1696 # parsing the dirstate.
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
1697 #
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
1698 # (we cannot decorate the function directly since it is in a C module)
42747
760a7851e9ba rust-parsers: move parser bindings to their own file and Python module
Raphaël Gomès <rgomes@octobus.net>
parents: 42456
diff changeset
1699 parse_dirstate = util.nogc(parsers.parse_dirstate)
34672
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
1700 p = parse_dirstate(self._map, self.copymap, st)
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
1701 if not self._dirtyparents:
e159f217230e dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents: 34480
diff changeset
1702 self.setparents(*p)
34673
e2214632c3a2 dirstate: move write into dirstatemap
Durham Goode <durham@fb.com>
parents: 34672
diff changeset
1703
34935
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents: 34934
diff changeset
1704 # Avoid excess attribute lookups by fast pathing certain checks
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents: 34934
diff changeset
1705 self.__contains__ = self._map.__contains__
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents: 34934
diff changeset
1706 self.__getitem__ = self._map.__getitem__
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents: 34934
diff changeset
1707 self.get = self._map.get
ffeea2406276 dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents: 34934
diff changeset
1708
34673
e2214632c3a2 dirstate: move write into dirstatemap
Durham Goode <durham@fb.com>
parents: 34672
diff changeset
1709 def write(self, st, now):
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1710 st.write(
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1711 parsers.pack_dirstate(self._map, self.copymap, self.parents(), now)
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1712 )
34673
e2214632c3a2 dirstate: move write into dirstatemap
Durham Goode <durham@fb.com>
parents: 34672
diff changeset
1713 st.close()
e2214632c3a2 dirstate: move write into dirstatemap
Durham Goode <durham@fb.com>
parents: 34672
diff changeset
1714 self._dirtyparents = False
34674
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents: 34673
diff changeset
1715 self.nonnormalset, self.otherparentset = self.nonnormalentries()
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents: 34673
diff changeset
1716
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents: 34673
diff changeset
1717 @propertycache
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents: 34673
diff changeset
1718 def nonnormalset(self):
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents: 34673
diff changeset
1719 nonnorm, otherparents = self.nonnormalentries()
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents: 34673
diff changeset
1720 self.otherparentset = otherparents
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents: 34673
diff changeset
1721 return nonnorm
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents: 34673
diff changeset
1722
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents: 34673
diff changeset
1723 @propertycache
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents: 34673
diff changeset
1724 def otherparentset(self):
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents: 34673
diff changeset
1725 nonnorm, otherparents = self.nonnormalentries()
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents: 34673
diff changeset
1726 self.nonnormalset = nonnorm
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents: 34673
diff changeset
1727 return otherparents
60927b19ed65 dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents: 34673
diff changeset
1728
47094
e061a1df32a8 dirstate-tree: Abstract "non-normal" and "other parent" sets
Simon Sapin <simon.sapin@octobus.net>
parents: 47012
diff changeset
1729 def non_normal_or_other_parent_paths(self):
e061a1df32a8 dirstate-tree: Abstract "non-normal" and "other parent" sets
Simon Sapin <simon.sapin@octobus.net>
parents: 47012
diff changeset
1730 return self.nonnormalset.union(self.otherparentset)
e061a1df32a8 dirstate-tree: Abstract "non-normal" and "other parent" sets
Simon Sapin <simon.sapin@octobus.net>
parents: 47012
diff changeset
1731
34675
c6ef9a2498a5 dirstate: move identity to dirstatemap
Durham Goode <durham@fb.com>
parents: 34674
diff changeset
1732 @propertycache
c6ef9a2498a5 dirstate: move identity to dirstatemap
Durham Goode <durham@fb.com>
parents: 34674
diff changeset
1733 def identity(self):
34934
6e66033f91cc dirstate: avoid reading the map when possible (issue5713) (issue5717)
Durham Goode <durham@fb.com>
parents: 34933
diff changeset
1734 self._map
34675
c6ef9a2498a5 dirstate: move identity to dirstatemap
Durham Goode <durham@fb.com>
parents: 34674
diff changeset
1735 return self.identity
c6ef9a2498a5 dirstate: move identity to dirstatemap
Durham Goode <durham@fb.com>
parents: 34674
diff changeset
1736
34678
e8a89ed7ce96 dirstate: move the _dirfoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34677
diff changeset
1737 @propertycache
e8a89ed7ce96 dirstate: move the _dirfoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34677
diff changeset
1738 def dirfoldmap(self):
e8a89ed7ce96 dirstate: move the _dirfoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34677
diff changeset
1739 f = {}
e8a89ed7ce96 dirstate: move the _dirfoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34677
diff changeset
1740 normcase = util.normcase
35084
61888bd0b300 dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents: 35083
diff changeset
1741 for name in self._dirs:
34678
e8a89ed7ce96 dirstate: move the _dirfoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34677
diff changeset
1742 f[normcase(name)] = name
e8a89ed7ce96 dirstate: move the _dirfoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents: 34677
diff changeset
1743 return f
42755
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1744
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1745
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1746 if rustmod is not None:
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1747
42755
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1748 class dirstatemap(object):
46780
6266d19556ad node: introduce nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 45942
diff changeset
1749 def __init__(self, ui, opener, root, nodeconstants):
6266d19556ad node: introduce nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 45942
diff changeset
1750 self._nodeconstants = nodeconstants
42755
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1751 self._ui = ui
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1752 self._opener = opener
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1753 self._root = root
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1754 self._filename = b'dirstate'
47121
b6339a993b91 rust: Remove handling of `parents` in `DirstateMap`
Simon Sapin <simon.sapin@octobus.net>
parents: 47095
diff changeset
1755 self._nodelen = 20
42755
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1756 self._parents = None
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1757 self._dirtyparents = False
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1758
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1759 # for consistent view between _pl() and _read() invocations
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1760 self._pendingmode = None
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1761
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1762 def addfile(self, *args, **kwargs):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1763 return self._rustmap.addfile(*args, **kwargs)
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1764
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1765 def removefile(self, *args, **kwargs):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1766 return self._rustmap.removefile(*args, **kwargs)
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1767
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1768 def dropfile(self, *args, **kwargs):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1769 return self._rustmap.dropfile(*args, **kwargs)
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1770
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1771 def clearambiguoustimes(self, *args, **kwargs):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1772 return self._rustmap.clearambiguoustimes(*args, **kwargs)
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1773
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1774 def nonnormalentries(self):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1775 return self._rustmap.nonnormalentries()
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1776
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1777 def get(self, *args, **kwargs):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1778 return self._rustmap.get(*args, **kwargs)
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1779
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1780 @property
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1781 def copymap(self):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1782 return self._rustmap.copymap()
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1783
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1784 def preload(self):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1785 self._rustmap
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1786
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1787 def clear(self):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1788 self._rustmap.clear()
47012
d55b71393907 node: replace nullid and friends with nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 46819
diff changeset
1789 self.setparents(
d55b71393907 node: replace nullid and friends with nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 46819
diff changeset
1790 self._nodeconstants.nullid, self._nodeconstants.nullid
d55b71393907 node: replace nullid and friends with nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents: 46819
diff changeset
1791 )
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1792 util.clearcachedproperty(self, b"_dirs")
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1793 util.clearcachedproperty(self, b"_alldirs")
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1794 util.clearcachedproperty(self, b"dirfoldmap")
42755
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1795
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1796 def items(self):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1797 return self._rustmap.items()
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1798
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1799 def keys(self):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1800 return iter(self._rustmap)
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1801
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1802 def __contains__(self, key):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1803 return key in self._rustmap
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1804
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1805 def __getitem__(self, item):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1806 return self._rustmap[item]
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1807
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1808 def __len__(self):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1809 return len(self._rustmap)
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1810
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1811 def __iter__(self):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1812 return iter(self._rustmap)
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1813
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1814 # forward for python2,3 compat
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1815 iteritems = items
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1816
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1817 def _opendirstatefile(self):
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1818 fp, mode = txnutil.trypending(
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1819 self._root, self._opener, self._filename
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1820 )
42755
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1821 if self._pendingmode is not None and self._pendingmode != mode:
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1822 fp.close()
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1823 raise error.Abort(
43117
8ff1ecfadcd1 cleanup: join string literals that are already on one line
Martin von Zweigbergk <martinvonz@google.com>
parents: 43106
diff changeset
1824 _(b'working directory state may be changed parallelly')
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1825 )
42755
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1826 self._pendingmode = mode
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1827 return fp
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1828
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1829 def setparents(self, p1, p2):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1830 self._parents = (p1, p2)
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1831 self._dirtyparents = True
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1832
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1833 def parents(self):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1834 if not self._parents:
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1835 try:
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1836 fp = self._opendirstatefile()
45241
e0bfde04f957 dirstate: revert change to Rust binding
Joerg Sonnenberger <joerg@bec.de>
parents: 45219
diff changeset
1837 st = fp.read(40)
42755
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1838 fp.close()
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1839 except IOError as err:
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1840 if err.errno != errno.ENOENT:
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1841 raise
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1842 # File doesn't exist, so the current state is empty
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
1843 st = b''
42755
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1844
47121
b6339a993b91 rust: Remove handling of `parents` in `DirstateMap`
Simon Sapin <simon.sapin@octobus.net>
parents: 47095
diff changeset
1845 l = len(st)
b6339a993b91 rust: Remove handling of `parents` in `DirstateMap`
Simon Sapin <simon.sapin@octobus.net>
parents: 47095
diff changeset
1846 if l == self._nodelen * 2:
b6339a993b91 rust: Remove handling of `parents` in `DirstateMap`
Simon Sapin <simon.sapin@octobus.net>
parents: 47095
diff changeset
1847 self._parents = (
b6339a993b91 rust: Remove handling of `parents` in `DirstateMap`
Simon Sapin <simon.sapin@octobus.net>
parents: 47095
diff changeset
1848 st[: self._nodelen],
b6339a993b91 rust: Remove handling of `parents` in `DirstateMap`
Simon Sapin <simon.sapin@octobus.net>
parents: 47095
diff changeset
1849 st[self._nodelen : 2 * self._nodelen],
b6339a993b91 rust: Remove handling of `parents` in `DirstateMap`
Simon Sapin <simon.sapin@octobus.net>
parents: 47095
diff changeset
1850 )
b6339a993b91 rust: Remove handling of `parents` in `DirstateMap`
Simon Sapin <simon.sapin@octobus.net>
parents: 47095
diff changeset
1851 elif l == 0:
b6339a993b91 rust: Remove handling of `parents` in `DirstateMap`
Simon Sapin <simon.sapin@octobus.net>
parents: 47095
diff changeset
1852 self._parents = (
b6339a993b91 rust: Remove handling of `parents` in `DirstateMap`
Simon Sapin <simon.sapin@octobus.net>
parents: 47095
diff changeset
1853 self._nodeconstants.nullid,
b6339a993b91 rust: Remove handling of `parents` in `DirstateMap`
Simon Sapin <simon.sapin@octobus.net>
parents: 47095
diff changeset
1854 self._nodeconstants.nullid,
b6339a993b91 rust: Remove handling of `parents` in `DirstateMap`
Simon Sapin <simon.sapin@octobus.net>
parents: 47095
diff changeset
1855 )
b6339a993b91 rust: Remove handling of `parents` in `DirstateMap`
Simon Sapin <simon.sapin@octobus.net>
parents: 47095
diff changeset
1856 else:
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1857 raise error.Abort(
43117
8ff1ecfadcd1 cleanup: join string literals that are already on one line
Martin von Zweigbergk <martinvonz@google.com>
parents: 43106
diff changeset
1858 _(b'working directory state appears damaged!')
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1859 )
42755
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1860
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1861 return self._parents
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1862
47122
9aba0cde0ed9 rust: Read dirstate from disk in DirstateMap constructor
Simon Sapin <simon.sapin@octobus.net>
parents: 47121
diff changeset
1863 @propertycache
9aba0cde0ed9 rust: Read dirstate from disk in DirstateMap constructor
Simon Sapin <simon.sapin@octobus.net>
parents: 47121
diff changeset
1864 def _rustmap(self):
9aba0cde0ed9 rust: Read dirstate from disk in DirstateMap constructor
Simon Sapin <simon.sapin@octobus.net>
parents: 47121
diff changeset
1865 """
9aba0cde0ed9 rust: Read dirstate from disk in DirstateMap constructor
Simon Sapin <simon.sapin@octobus.net>
parents: 47121
diff changeset
1866 Fills the Dirstatemap when called.
9aba0cde0ed9 rust: Read dirstate from disk in DirstateMap constructor
Simon Sapin <simon.sapin@octobus.net>
parents: 47121
diff changeset
1867 """
42755
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1868 # ignore HG_PENDING because identity is used only for writing
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1869 self.identity = util.filestat.frompath(
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1870 self._opener.join(self._filename)
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1871 )
42755
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1872
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1873 try:
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1874 fp = self._opendirstatefile()
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1875 try:
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1876 st = fp.read()
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1877 finally:
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1878 fp.close()
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1879 except IOError as err:
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1880 if err.errno != errno.ENOENT:
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1881 raise
47122
9aba0cde0ed9 rust: Read dirstate from disk in DirstateMap constructor
Simon Sapin <simon.sapin@octobus.net>
parents: 47121
diff changeset
1882 st = b''
42755
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1883
47122
9aba0cde0ed9 rust: Read dirstate from disk in DirstateMap constructor
Simon Sapin <simon.sapin@octobus.net>
parents: 47121
diff changeset
1884 use_dirstate_tree = self._ui.configbool(
9aba0cde0ed9 rust: Read dirstate from disk in DirstateMap constructor
Simon Sapin <simon.sapin@octobus.net>
parents: 47121
diff changeset
1885 b"experimental",
9aba0cde0ed9 rust: Read dirstate from disk in DirstateMap constructor
Simon Sapin <simon.sapin@octobus.net>
parents: 47121
diff changeset
1886 b"dirstate-tree.in-memory",
9aba0cde0ed9 rust: Read dirstate from disk in DirstateMap constructor
Simon Sapin <simon.sapin@octobus.net>
parents: 47121
diff changeset
1887 False,
9aba0cde0ed9 rust: Read dirstate from disk in DirstateMap constructor
Simon Sapin <simon.sapin@octobus.net>
parents: 47121
diff changeset
1888 )
9aba0cde0ed9 rust: Read dirstate from disk in DirstateMap constructor
Simon Sapin <simon.sapin@octobus.net>
parents: 47121
diff changeset
1889 self._rustmap, parents = rustmod.DirstateMap.new(
9aba0cde0ed9 rust: Read dirstate from disk in DirstateMap constructor
Simon Sapin <simon.sapin@octobus.net>
parents: 47121
diff changeset
1890 use_dirstate_tree, st
9aba0cde0ed9 rust: Read dirstate from disk in DirstateMap constructor
Simon Sapin <simon.sapin@octobus.net>
parents: 47121
diff changeset
1891 )
9aba0cde0ed9 rust: Read dirstate from disk in DirstateMap constructor
Simon Sapin <simon.sapin@octobus.net>
parents: 47121
diff changeset
1892
42755
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1893 if parents and not self._dirtyparents:
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1894 self.setparents(*parents)
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1895
43280
5d4046594d6f rust-dirstatemap: remove additional lookups in dirstatemap
Raphaël Gomès <rgomes@octobus.net>
parents: 43274
diff changeset
1896 self.__contains__ = self._rustmap.__contains__
5d4046594d6f rust-dirstatemap: remove additional lookups in dirstatemap
Raphaël Gomès <rgomes@octobus.net>
parents: 43274
diff changeset
1897 self.__getitem__ = self._rustmap.__getitem__
5d4046594d6f rust-dirstatemap: remove additional lookups in dirstatemap
Raphaël Gomès <rgomes@octobus.net>
parents: 43274
diff changeset
1898 self.get = self._rustmap.get
47122
9aba0cde0ed9 rust: Read dirstate from disk in DirstateMap constructor
Simon Sapin <simon.sapin@octobus.net>
parents: 47121
diff changeset
1899 return self._rustmap
43280
5d4046594d6f rust-dirstatemap: remove additional lookups in dirstatemap
Raphaël Gomès <rgomes@octobus.net>
parents: 43274
diff changeset
1900
42755
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1901 def write(self, st, now):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1902 parents = self.parents()
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1903 st.write(self._rustmap.write(parents[0], parents[1], now))
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1904 st.close()
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1905 self._dirtyparents = False
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1906
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1907 @propertycache
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1908 def filefoldmap(self):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1909 """Returns a dictionary mapping normalized case paths to their
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1910 non-normalized versions.
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1911 """
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1912 return self._rustmap.filefoldmapasdict()
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1913
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1914 def hastrackeddir(self, d):
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1915 self._dirs # Trigger Python's propertycache
42755
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1916 return self._rustmap.hastrackeddir(d)
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1917
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1918 def hasdir(self, d):
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 42927
diff changeset
1919 self._dirs # Trigger Python's propertycache
42755
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1920 return self._rustmap.hasdir(d)
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1921
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1922 @propertycache
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1923 def _dirs(self):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1924 return self._rustmap.getdirs()
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1925
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1926 @propertycache
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1927 def _alldirs(self):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1928 return self._rustmap.getalldirs()
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1929
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1930 @propertycache
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1931 def identity(self):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1932 self._rustmap
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1933 return self.identity
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1934
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1935 @property
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1936 def nonnormalset(self):
44297
cf1f8660e568 rust-dirstatemap: add `NonNormalEntries` class
Raphaël Gomès <rgomes@octobus.net>
parents: 44227
diff changeset
1937 nonnorm = self._rustmap.non_normal_entries()
42755
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1938 return nonnorm
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1939
44227
7f5410dfc8a6 rust-dirstatemap: add missing @propertycache
Raphaël Gomès <rgomes@octobus.net>
parents: 44078
diff changeset
1940 @propertycache
42755
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1941 def otherparentset(self):
44297
cf1f8660e568 rust-dirstatemap: add `NonNormalEntries` class
Raphaël Gomès <rgomes@octobus.net>
parents: 44227
diff changeset
1942 otherparents = self._rustmap.other_parent_entries()
42755
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1943 return otherparents
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1944
47094
e061a1df32a8 dirstate-tree: Abstract "non-normal" and "other parent" sets
Simon Sapin <simon.sapin@octobus.net>
parents: 47012
diff changeset
1945 def non_normal_or_other_parent_paths(self):
e061a1df32a8 dirstate-tree: Abstract "non-normal" and "other parent" sets
Simon Sapin <simon.sapin@octobus.net>
parents: 47012
diff changeset
1946 return self._rustmap.non_normal_or_other_parent_paths()
e061a1df32a8 dirstate-tree: Abstract "non-normal" and "other parent" sets
Simon Sapin <simon.sapin@octobus.net>
parents: 47012
diff changeset
1947
42755
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1948 @propertycache
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1949 def dirfoldmap(self):
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1950 f = {}
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1951 normcase = util.normcase
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1952 for name in self._dirs:
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1953 f[normcase(name)] = name
749ef8c31187 rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents: 42747
diff changeset
1954 return f