Mercurial > hg-stable
annotate mercurial/dirstate.py @ 42771:749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Since Rust-backed Python classes cannot be used as baseclasses (for
rust-cpython anyway), we use composition rather than inheritance.
This also allows us to keep the IO operations in the Python side, removing
(for now) the need to rewrite VFS in Rust, which would be a heavy undertaking.
Differential Revision: https://phab.mercurial-scm.org/D6634
author | Raphaël Gomès <rgomes@octobus.net> |
---|---|
date | Wed, 10 Jul 2019 09:57:28 +0200 |
parents | 760a7851e9ba |
children | d459cd8ea42d |
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 # |
8b2cd04a6e97
put license and copyright info into comment blocks
Martin Geisler <mg@lazybytes.net>
parents:
8225
diff
changeset
|
3 # Copyright 2005-2007 Matt Mackall <mpm@selenic.com> |
8b2cd04a6e97
put license and copyright info into comment blocks
Martin Geisler <mg@lazybytes.net>
parents:
8225
diff
changeset
|
4 # |
8b2cd04a6e97
put license and copyright info into comment blocks
Martin Geisler <mg@lazybytes.net>
parents:
8225
diff
changeset
|
5 # This software may be used and distributed according to the terms of the |
10263 | 6 # GNU General Public License version 2 or any later version. |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
7 |
27503
0f4596622273
dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27399
diff
changeset
|
8 from __future__ import absolute_import |
0f4596622273
dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27399
diff
changeset
|
9 |
27670
4374f039d269
dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents:
27594
diff
changeset
|
10 import collections |
32385
73e67c4386ec
dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents:
32248
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 _ |
0f4596622273
dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27399
diff
changeset
|
17 from .node import nullid |
0f4596622273
dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27399
diff
changeset
|
18 from . import ( |
0f4596622273
dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27399
diff
changeset
|
19 encoding, |
0f4596622273
dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27399
diff
changeset
|
20 error, |
0f4596622273
dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27399
diff
changeset
|
21 match as matchmod, |
0f4596622273
dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27399
diff
changeset
|
22 pathutil, |
32411
df448de7cf3b
parsers: switch to policy importer
Yuya Nishihara <yuya@tcha.org>
parents:
32391
diff
changeset
|
23 policy, |
30317
ba2c04059317
py3: use pycompat.ossep at certain places
Pulkit Goyal <7895pulkit@gmail.com>
parents:
30224
diff
changeset
|
24 pycompat, |
27503
0f4596622273
dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27399
diff
changeset
|
25 scmutil, |
31070
206532700213
txnutil: factor out the logic to read file in according to HG_PENDING
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
30639
diff
changeset
|
26 txnutil, |
27503
0f4596622273
dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27399
diff
changeset
|
27 util, |
0f4596622273
dirstate: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents:
27399
diff
changeset
|
28 ) |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
29 |
42771
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
30 parsers = policy.importmod(r'parsers') |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
31 rustmod = policy.importrust(r'dirstate') |
32411
df448de7cf3b
parsers: switch to policy importer
Yuya Nishihara <yuya@tcha.org>
parents:
32391
diff
changeset
|
32 |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
33 propertycache = util.propertycache |
16201
fb7c4c14223f
dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents:
16200
diff
changeset
|
34 filecache = scmutil.filecache |
17733
3c775c5a6c03
dirstate: handle large dates and times with masking (issue2608)
Matt Mackall <mpm@selenic.com>
parents:
17197
diff
changeset
|
35 _rangemask = 0x7fffffff |
16201
fb7c4c14223f
dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents:
16200
diff
changeset
|
36 |
42771
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
37 dirstatetuple = parsers.dirstatetuple |
21808
7537e57f5dbd
dirstate: add dirstatetuple to create dirstate values
Siddharth Agarwal <sid0@fb.com>
parents:
21116
diff
changeset
|
38 |
16201
fb7c4c14223f
dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents:
16200
diff
changeset
|
39 class repocache(filecache): |
fb7c4c14223f
dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents:
16200
diff
changeset
|
40 """filecache for files in .hg/""" |
fb7c4c14223f
dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents:
16200
diff
changeset
|
41 def join(self, obj, fname): |
fb7c4c14223f
dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents:
16200
diff
changeset
|
42 return obj._opener.join(fname) |
4610 | 43 |
16202
53e2cd303ecf
dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents:
16201
diff
changeset
|
44 class rootcache(filecache): |
53e2cd303ecf
dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents:
16201
diff
changeset
|
45 """filecache for files in the repository root""" |
53e2cd303ecf
dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents:
16201
diff
changeset
|
46 def join(self, obj, fname): |
53e2cd303ecf
dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents:
16201
diff
changeset
|
47 return obj._join(fname) |
53e2cd303ecf
dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents:
16201
diff
changeset
|
48 |
26634
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
49 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
|
50 '''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
|
51 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
|
52 try: |
36789
ffa3026d4196
cleanup: use stat_result[stat.ST_MTIME] instead of stat_result.st_mtime
Augie Fackler <augie@google.com>
parents:
36651
diff
changeset
|
53 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
|
54 finally: |
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
55 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
|
56 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
|
57 |
1559
59b3639df0a9
Convert all classes to new-style classes by deriving them from object.
Eric Hopper <hopper@omnifarious.org>
parents:
1541
diff
changeset
|
58 class dirstate(object): |
2393
5083cba2a777
dirstate: refactor the dirstate binary format, remove magic numbers
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
2063
diff
changeset
|
59 |
33373
fb320398a21c
dirstate: expose a sparse matcher on dirstate (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33215
diff
changeset
|
60 def __init__(self, opener, ui, root, validate, sparsematchfn): |
10145
aec936051734
dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents:
9678
diff
changeset
|
61 '''Create a new dirstate object. |
aec936051734
dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents:
9678
diff
changeset
|
62 |
aec936051734
dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents:
9678
diff
changeset
|
63 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
|
64 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
|
65 the dirstate. |
aec936051734
dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents:
9678
diff
changeset
|
66 ''' |
4614
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
67 self._opener = opener |
13032
e41e2b79883d
dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents:
12907
diff
changeset
|
68 self._validate = validate |
4614
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
69 self._root = root |
33373
fb320398a21c
dirstate: expose a sparse matcher on dirstate (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33215
diff
changeset
|
70 self._sparsematchfn = sparsematchfn |
24198
3cc630be5f09
dirstate: make sure rootdir ends with directory separator (issue4557)
Yuya Nishihara <yuya@tcha.org>
parents:
23866
diff
changeset
|
71 # 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
|
72 # 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
|
73 self._rootdir = pathutil.normasprefix(root) |
4903
81078e177266
dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents:
4677
diff
changeset
|
74 self._dirty = False |
15791
a814f8fcc65a
Use explicit integer division
Martin Geisler <mg@aragost.com>
parents:
15670
diff
changeset
|
75 self._lastnormaltime = 0 |
4614
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
76 self._ui = ui |
16200
9d4a2942a732
dirstate: add filecache support
Idan Kamara <idankk86@gmail.com>
parents:
16143
diff
changeset
|
77 self._filecache = {} |
22404
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
78 self._parentwriters = 0 |
25226
00d426a38137
dirstate: use self._filename instead of immediate string `dirstate`
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
25216
diff
changeset
|
79 self._filename = 'dirstate' |
26633
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
80 self._pendingfilename = '%s.pending' % self._filename |
29783
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29687
diff
changeset
|
81 self._plchangecallbacks = {} |
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29687
diff
changeset
|
82 self._origpl = None |
31216
49e5491ed9bd
dirstate: track updated files to improve write time
Durham Goode <durham@fb.com>
parents:
31070
diff
changeset
|
83 self._updatedfiles = set() |
35109
8db4ca768416
dirstate: make map implementation overridable
Mark Thomas <mbthomas@fb.com>
parents:
35107
diff
changeset
|
84 self._mapcls = dirstatemap |
41685
e178b131906a
dirstate: call and cache os.getcwd() in constructor
Martin von Zweigbergk <martinvonz@google.com>
parents:
40493
diff
changeset
|
85 # 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:
40493
diff
changeset
|
86 # 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:
40493
diff
changeset
|
87 # raises an exception). |
e178b131906a
dirstate: call and cache os.getcwd() in constructor
Martin von Zweigbergk <martinvonz@google.com>
parents:
40493
diff
changeset
|
88 self._cwd |
22404
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
89 |
32385
73e67c4386ec
dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents:
32248
diff
changeset
|
90 @contextlib.contextmanager |
73e67c4386ec
dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents:
32248
diff
changeset
|
91 def parentchange(self): |
73e67c4386ec
dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents:
32248
diff
changeset
|
92 '''Context manager for handling dirstate parents. |
73e67c4386ec
dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents:
32248
diff
changeset
|
93 |
73e67c4386ec
dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents:
32248
diff
changeset
|
94 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:
32248
diff
changeset
|
95 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:
32248
diff
changeset
|
96 released. |
73e67c4386ec
dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents:
32248
diff
changeset
|
97 ''' |
73e67c4386ec
dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents:
32248
diff
changeset
|
98 self._parentwriters += 1 |
73e67c4386ec
dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents:
32248
diff
changeset
|
99 yield |
73e67c4386ec
dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents:
32248
diff
changeset
|
100 # 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:
32248
diff
changeset
|
101 # 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:
32248
diff
changeset
|
102 # 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:
32248
diff
changeset
|
103 # 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:
32248
diff
changeset
|
104 # 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:
32248
diff
changeset
|
105 self._parentwriters -= 1 |
73e67c4386ec
dirstate: introduce new context manager for marking dirstate parent changes
Augie Fackler <augie@google.com>
parents:
32248
diff
changeset
|
106 |
22404
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
107 def pendingparentchange(self): |
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
108 '''Returns true if the dirstate is in the middle of a set of changes |
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
109 that modify the dirstate parent. |
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
110 ''' |
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
111 return self._parentwriters > 0 |
723 | 112 |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
113 @propertycache |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
114 def _map(self): |
35101
a052022639cc
dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents:
35055
diff
changeset
|
115 """Return the dirstate contents (see documentation for dirstatemap).""" |
35109
8db4ca768416
dirstate: make map implementation overridable
Mark Thomas <mbthomas@fb.com>
parents:
35107
diff
changeset
|
116 self._map = self._mapcls(self._ui, self._opener, self._root) |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
117 return self._map |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
118 |
33373
fb320398a21c
dirstate: expose a sparse matcher on dirstate (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33215
diff
changeset
|
119 @property |
fb320398a21c
dirstate: expose a sparse matcher on dirstate (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33215
diff
changeset
|
120 def _sparsematcher(self): |
fb320398a21c
dirstate: expose a sparse matcher on dirstate (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33215
diff
changeset
|
121 """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
|
122 |
fb320398a21c
dirstate: expose a sparse matcher on dirstate (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33215
diff
changeset
|
123 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
|
124 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
|
125 included in the working directory. |
fb320398a21c
dirstate: expose a sparse matcher on dirstate (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33215
diff
changeset
|
126 """ |
fb320398a21c
dirstate: expose a sparse matcher on dirstate (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33215
diff
changeset
|
127 # 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
|
128 # 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
|
129 # 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
|
130 return self._sparsematchfn() |
fb320398a21c
dirstate: expose a sparse matcher on dirstate (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
33215
diff
changeset
|
131 |
16201
fb7c4c14223f
dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents:
16200
diff
changeset
|
132 @repocache('branch') |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
133 def _branch(self): |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
134 try: |
14168
135e244776f0
prevent transient leaks of file handle by using new helper functions
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
13974
diff
changeset
|
135 return self._opener.read("branch").strip() or "default" |
25660
328739ea70c3
global: mass rewrite to use modern exception syntax
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25658
diff
changeset
|
136 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
|
137 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
|
138 raise |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
139 return "default" |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
140 |
34346
ec769bba34d3
dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents:
34345
diff
changeset
|
141 @property |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
142 def _pl(self): |
34345
0c3e3810cdb6
dirstate: move parent reading to the dirstatemap class
Durham Goode <durham@fb.com>
parents:
34344
diff
changeset
|
143 return self._map.parents() |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
144 |
35107
61888bd0b300
dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents:
35106
diff
changeset
|
145 def hasdir(self, d): |
61888bd0b300
dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents:
35106
diff
changeset
|
146 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
|
147 |
16202
53e2cd303ecf
dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents:
16201
diff
changeset
|
148 @rootcache('.hgignore') |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
149 def _ignore(self): |
27594
0921caca7703
dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents:
27593
diff
changeset
|
150 files = self._ignorefiles() |
25216
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25163
diff
changeset
|
151 if not files: |
41687
0531dff73d0b
match: delete unused root and cwd arguments from {always,never,exact}() (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41685
diff
changeset
|
152 return matchmod.never() |
25216
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25163
diff
changeset
|
153 |
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25163
diff
changeset
|
154 pats = ['include:%s' % f for f in files] |
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25163
diff
changeset
|
155 return matchmod.match(self._root, '', [], pats, warn=self._ui.warn) |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
156 |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
157 @propertycache |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
158 def _slash(self): |
30317
ba2c04059317
py3: use pycompat.ossep at certain places
Pulkit Goyal <7895pulkit@gmail.com>
parents:
30224
diff
changeset
|
159 return self._ui.configbool('ui', 'slash') and pycompat.ossep != '/' |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
160 |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
161 @propertycache |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
162 def _checklink(self): |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
163 return util.checklink(self._root) |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
164 |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
165 @propertycache |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
166 def _checkexec(self): |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
167 return util.checkexec(self._root) |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
168 |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
169 @propertycache |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
170 def _checkcase(self): |
29893
6f447b9ec263
util: rename checkcase() to fscasesensitive() (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
29783
diff
changeset
|
171 return not util.fscasesensitive(self._join('.hg')) |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
172 |
4905
fc61495ea9cf
dirstate: make wjoin function private
Matt Mackall <mpm@selenic.com>
parents:
4904
diff
changeset
|
173 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
|
174 # 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
|
175 # 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
|
176 return self._rootdir + f |
723 | 177 |
15337
cf5f9df6406b
windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents:
15057
diff
changeset
|
178 def flagfunc(self, buildfallback): |
cf5f9df6406b
windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents:
15057
diff
changeset
|
179 if self._checklink and self._checkexec: |
cf5f9df6406b
windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents:
15057
diff
changeset
|
180 def f(x): |
18869
e8b4b139a545
dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents:
18815
diff
changeset
|
181 try: |
e8b4b139a545
dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents:
18815
diff
changeset
|
182 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
|
183 if util.statislink(st): |
e8b4b139a545
dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents:
18815
diff
changeset
|
184 return 'l' |
e8b4b139a545
dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents:
18815
diff
changeset
|
185 if util.statisexec(st): |
e8b4b139a545
dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents:
18815
diff
changeset
|
186 return 'x' |
e8b4b139a545
dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents:
18815
diff
changeset
|
187 except OSError: |
e8b4b139a545
dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents:
18815
diff
changeset
|
188 pass |
15337
cf5f9df6406b
windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents:
15057
diff
changeset
|
189 return '' |
cf5f9df6406b
windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents:
15057
diff
changeset
|
190 return f |
cf5f9df6406b
windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents:
15057
diff
changeset
|
191 |
cf5f9df6406b
windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents:
15057
diff
changeset
|
192 fallback = buildfallback() |
6743 | 193 if self._checklink: |
194 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
|
195 if os.path.islink(self._join(x)): |
6743 | 196 return 'l' |
197 if 'x' in fallback(x): | |
198 return 'x' | |
199 return '' | |
200 return f | |
201 if self._checkexec: | |
202 def f(x): | |
203 if 'l' in fallback(x): | |
204 return 'l' | |
14273
38af0f514134
rename util.is_exec to isexec
Adrian Buehlmann <adrian@cadifra.com>
parents:
14168
diff
changeset
|
205 if util.isexec(self._join(x)): |
6743 | 206 return 'x' |
207 return '' | |
208 return f | |
15337
cf5f9df6406b
windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents:
15057
diff
changeset
|
209 else: |
cf5f9df6406b
windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents:
15057
diff
changeset
|
210 return fallback |
6743 | 211 |
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
|
212 @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
|
213 def _cwd(self): |
33215
b7f6885cb055
dirstate: centralize _cwd handling into _cwd method
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
32792
diff
changeset
|
214 # internal config: ui.forcecwd |
b7f6885cb055
dirstate: centralize _cwd handling into _cwd method
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
32792
diff
changeset
|
215 forcecwd = self._ui.config('ui', 'forcecwd') |
b7f6885cb055
dirstate: centralize _cwd handling into _cwd method
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
32792
diff
changeset
|
216 if forcecwd: |
b7f6885cb055
dirstate: centralize _cwd handling into _cwd method
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
32792
diff
changeset
|
217 return forcecwd |
39823
24e493ec2229
py3: rename pycompat.getcwd() to encoding.getcwd() (API)
Matt Harbison <matt_harbison@yahoo.com>
parents:
39471
diff
changeset
|
218 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
|
219 |
870
a82eae840447
Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents:
839
diff
changeset
|
220 def getcwd(self): |
26293
3d24f31c6b8f
dirstate: state that getcwd() shouldn't be used to get real file path
Yuya Nishihara <yuya@tcha.org>
parents:
25877
diff
changeset
|
221 '''Return the path from which a canonical path is calculated. |
3d24f31c6b8f
dirstate: state that getcwd() shouldn't be used to get real file path
Yuya Nishihara <yuya@tcha.org>
parents:
25877
diff
changeset
|
222 |
3d24f31c6b8f
dirstate: state that getcwd() shouldn't be used to get real file path
Yuya Nishihara <yuya@tcha.org>
parents:
25877
diff
changeset
|
223 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
|
224 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
|
225 used to get real file paths. Use vfs functions instead. |
3d24f31c6b8f
dirstate: state that getcwd() shouldn't be used to get real file path
Yuya Nishihara <yuya@tcha.org>
parents:
25877
diff
changeset
|
226 ''' |
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
|
227 cwd = self._cwd |
10282
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
228 if cwd == self._root: |
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
229 return '' |
4614
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
230 # 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
|
231 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
|
232 if not util.endswithsep(rootsep): |
30619
cfe66dcf45c0
py3: replace os.sep with pycompat.ossep (part 2 of 4)
Pulkit Goyal <7895pulkit@gmail.com>
parents:
30528
diff
changeset
|
233 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
|
234 if cwd.startswith(rootsep): |
c93562fb12cc
Fix handling of paths when run outside the repo.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4229
diff
changeset
|
235 return cwd[len(rootsep):] |
c93562fb12cc
Fix handling of paths when run outside the repo.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4229
diff
changeset
|
236 else: |
c93562fb12cc
Fix handling of paths when run outside the repo.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4229
diff
changeset
|
237 # 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
|
238 return cwd |
870
a82eae840447
Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents:
839
diff
changeset
|
239 |
4525
78b6add1f966
Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4507
diff
changeset
|
240 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
|
241 if cwd is None: |
78b6add1f966
Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4507
diff
changeset
|
242 cwd = self.getcwd() |
4614
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
243 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
|
244 if self._slash: |
19210
865beb849720
dirstate: don't overnormalize for ui.slash
Matt Mackall <mpm@selenic.com>
parents:
19128
diff
changeset
|
245 return util.pconvert(path) |
4527
b422b558015b
Add ui.slash hgrc setting
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4525
diff
changeset
|
246 return path |
4525
78b6add1f966
Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4507
diff
changeset
|
247 |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
248 def __getitem__(self, key): |
9518
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
249 '''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
|
250 |
9518
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
251 States are: |
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
252 n normal |
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
253 m needs merging |
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
254 r marked for removal |
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
255 a marked for addition |
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
256 ? not tracked |
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
257 ''' |
4906
30847b8af7ca
dirstate: add __contains__ and make __getitem__ more useful
Matt Mackall <mpm@selenic.com>
parents:
4905
diff
changeset
|
258 return self._map.get(key, ("?",))[0] |
220 | 259 |
260 def __contains__(self, key): | |
4614
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
261 return key in self._map |
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
262 |
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
263 def __iter__(self): |
33733
36d216dcae6a
dirstate: simplify dirstate's __iter__
Alex Gaynor <agaynor@mozilla.com>
parents:
33440
diff
changeset
|
264 return iter(sorted(self._map)) |
220 | 265 |
32583
b98199a5c3e1
cleanup: rename all iteritems methods to items and add iteritems alias
Augie Fackler <raf@durin42.com>
parents:
32411
diff
changeset
|
266 def items(self): |
18792
10669e24eb6c
completion: add a debugpathcomplete command
Bryan O'Sullivan <bryano@fb.com>
parents:
18760
diff
changeset
|
267 return self._map.iteritems() |
10669e24eb6c
completion: add a debugpathcomplete command
Bryan O'Sullivan <bryano@fb.com>
parents:
18760
diff
changeset
|
268 |
32583
b98199a5c3e1
cleanup: rename all iteritems methods to items and add iteritems alias
Augie Fackler <raf@durin42.com>
parents:
32411
diff
changeset
|
269 iteritems = items |
b98199a5c3e1
cleanup: rename all iteritems methods to items and add iteritems alias
Augie Fackler <raf@durin42.com>
parents:
32411
diff
changeset
|
270 |
227 | 271 def parents(self): |
13032
e41e2b79883d
dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents:
12907
diff
changeset
|
272 return [self._validate(p) for p in self._pl] |
227 | 273 |
13876
10c7d92ac482
dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents:
13763
diff
changeset
|
274 def p1(self): |
10c7d92ac482
dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents:
13763
diff
changeset
|
275 return self._validate(self._pl[0]) |
10c7d92ac482
dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents:
13763
diff
changeset
|
276 |
10c7d92ac482
dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents:
13763
diff
changeset
|
277 def p2(self): |
10c7d92ac482
dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents:
13763
diff
changeset
|
278 return self._validate(self._pl[1]) |
10c7d92ac482
dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents:
13763
diff
changeset
|
279 |
4179
7e1c8a565a4f
Move branch read/write to dirstate where it belongs
Matt Mackall <mpm@selenic.com>
parents:
4172
diff
changeset
|
280 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
|
281 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
|
282 |
1062 | 283 def setparents(self, p1, p2=nullid): |
16551
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16542
diff
changeset
|
284 """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
|
285 |
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16542
diff
changeset
|
286 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
|
287 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
|
288 returned by the call. |
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16542
diff
changeset
|
289 |
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16542
diff
changeset
|
290 See localrepo.setparents() |
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16542
diff
changeset
|
291 """ |
22407
d259322a394b
dirstate: add exception when calling setparent without begin/end (API)
Durham Goode <durham@fb.com>
parents:
22404
diff
changeset
|
292 if self._parentwriters == 0: |
41956
42dd69985778
dirstate: remove obsolete reference to dirstate.beginparentchange
Martin von Zweigbergk <martinvonz@google.com>
parents:
41687
diff
changeset
|
293 raise ValueError("cannot set dirstate parent outside of " |
42dd69985778
dirstate: remove obsolete reference to dirstate.beginparentchange
Martin von Zweigbergk <martinvonz@google.com>
parents:
41687
diff
changeset
|
294 "dirstate.parentchange context manager") |
22407
d259322a394b
dirstate: add exception when calling setparent without begin/end (API)
Durham Goode <durham@fb.com>
parents:
22404
diff
changeset
|
295 |
34346
ec769bba34d3
dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents:
34345
diff
changeset
|
296 self._dirty = True |
16509
eab9119c5dee
rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents:
16472
diff
changeset
|
297 oldp2 = self._pl[1] |
29783
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29687
diff
changeset
|
298 if self._origpl is None: |
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29687
diff
changeset
|
299 self._origpl = self._pl |
34346
ec769bba34d3
dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents:
34345
diff
changeset
|
300 self._map.setparents(p1, p2) |
16551
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16542
diff
changeset
|
301 copies = {} |
16509
eab9119c5dee
rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents:
16472
diff
changeset
|
302 if oldp2 != nullid and p2 == nullid: |
34674
60927b19ed65
dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents:
34673
diff
changeset
|
303 candidatefiles = self._map.nonnormalset.union( |
60927b19ed65
dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents:
34673
diff
changeset
|
304 self._map.otherparentset) |
31287
1c97a91a18dc
dirstate: track otherparent files same as nonnormal
Durham Goode <durham@fb.com>
parents:
31218
diff
changeset
|
305 for f in candidatefiles: |
1c97a91a18dc
dirstate: track otherparent files same as nonnormal
Durham Goode <durham@fb.com>
parents:
31218
diff
changeset
|
306 s = self._map.get(f) |
1c97a91a18dc
dirstate: track otherparent files same as nonnormal
Durham Goode <durham@fb.com>
parents:
31218
diff
changeset
|
307 if s is None: |
1c97a91a18dc
dirstate: track otherparent files same as nonnormal
Durham Goode <durham@fb.com>
parents:
31218
diff
changeset
|
308 continue |
1c97a91a18dc
dirstate: track otherparent files same as nonnormal
Durham Goode <durham@fb.com>
parents:
31218
diff
changeset
|
309 |
22895
dfa44e25bb53
dirstate: properly clean-up some more merge state on setparents
Matt Mackall <mpm@selenic.com>
parents:
22782
diff
changeset
|
310 # Discard 'm' markers when moving away from a merge state |
16509
eab9119c5dee
rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents:
16472
diff
changeset
|
311 if s[0] == 'm': |
34343
0865d25e8a8a
dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34342
diff
changeset
|
312 source = self._map.copymap.get(f) |
33999
5cb0a8fe096e
dirstate: perform transactions with _copymap using single call, where possible
Michael Bolin <mbolin@fb.com>
parents:
33763
diff
changeset
|
313 if source: |
5cb0a8fe096e
dirstate: perform transactions with _copymap using single call, where possible
Michael Bolin <mbolin@fb.com>
parents:
33763
diff
changeset
|
314 copies[f] = source |
16509
eab9119c5dee
rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents:
16472
diff
changeset
|
315 self.normallookup(f) |
22895
dfa44e25bb53
dirstate: properly clean-up some more merge state on setparents
Matt Mackall <mpm@selenic.com>
parents:
22782
diff
changeset
|
316 # Also fix up otherparent markers |
dfa44e25bb53
dirstate: properly clean-up some more merge state on setparents
Matt Mackall <mpm@selenic.com>
parents:
22782
diff
changeset
|
317 elif s[0] == 'n' and s[2] == -2: |
34343
0865d25e8a8a
dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34342
diff
changeset
|
318 source = self._map.copymap.get(f) |
33999
5cb0a8fe096e
dirstate: perform transactions with _copymap using single call, where possible
Michael Bolin <mbolin@fb.com>
parents:
33763
diff
changeset
|
319 if source: |
5cb0a8fe096e
dirstate: perform transactions with _copymap using single call, where possible
Michael Bolin <mbolin@fb.com>
parents:
33763
diff
changeset
|
320 copies[f] = source |
22895
dfa44e25bb53
dirstate: properly clean-up some more merge state on setparents
Matt Mackall <mpm@selenic.com>
parents:
22782
diff
changeset
|
321 self.add(f) |
16551
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16542
diff
changeset
|
322 return copies |
227 | 323 |
4179
7e1c8a565a4f
Move branch read/write to dirstate where it belongs
Matt Mackall <mpm@selenic.com>
parents:
4172
diff
changeset
|
324 def setbranch(self, branch): |
40493
7caf632e30c3
filecache: unimplement __set__() and __delete__() (API)
Yuya Nishihara <yuya@tcha.org>
parents:
39823
diff
changeset
|
325 self.__class__._branch.set(self, encoding.fromlocal(branch)) |
29302
083e107adaac
dirstate: make writing branch file out avoid ambiguity of file stat
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
29301
diff
changeset
|
326 f = self._opener('branch', 'w', atomictemp=True, checkambig=True) |
16472
14a4e17f0817
dirstate: write branch file atomically
Idan Kamara <idankk86@gmail.com>
parents:
16323
diff
changeset
|
327 try: |
14a4e17f0817
dirstate: write branch file atomically
Idan Kamara <idankk86@gmail.com>
parents:
16323
diff
changeset
|
328 f.write(self._branch + '\n') |
14a4e17f0817
dirstate: write branch file atomically
Idan Kamara <idankk86@gmail.com>
parents:
16323
diff
changeset
|
329 f.close() |
18317
365fecd984c7
dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents:
18078
diff
changeset
|
330 |
365fecd984c7
dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents:
18078
diff
changeset
|
331 # 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
|
332 # replacing the underlying file |
365fecd984c7
dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents:
18078
diff
changeset
|
333 ce = self._filecache['_branch'] |
365fecd984c7
dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents:
18078
diff
changeset
|
334 if ce: |
365fecd984c7
dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents:
18078
diff
changeset
|
335 ce.refresh() |
18076
3bc21f6daac4
dirstate: don't rename branch file if writing it failed
Idan Kamara <idankk86@gmail.com>
parents:
17984
diff
changeset
|
336 except: # re-raises |
3bc21f6daac4
dirstate: don't rename branch file if writing it failed
Idan Kamara <idankk86@gmail.com>
parents:
17984
diff
changeset
|
337 f.discard() |
3bc21f6daac4
dirstate: don't rename branch file if writing it failed
Idan Kamara <idankk86@gmail.com>
parents:
17984
diff
changeset
|
338 raise |
4179
7e1c8a565a4f
Move branch read/write to dirstate where it belongs
Matt Mackall <mpm@selenic.com>
parents:
4172
diff
changeset
|
339 |
4613
3a645af7fb76
localrepo and dirstate: rename reload to invalidate
Matt Mackall <mpm@selenic.com>
parents:
4612
diff
changeset
|
340 def invalidate(self): |
32702
e696f597d02f
dirstate: add docstring for invalidate
Siddharth Agarwal <sid0@fb.com>
parents:
32631
diff
changeset
|
341 '''Causes the next access to reread the dirstate. |
e696f597d02f
dirstate: add docstring for invalidate
Siddharth Agarwal <sid0@fb.com>
parents:
32631
diff
changeset
|
342 |
e696f597d02f
dirstate: add docstring for invalidate
Siddharth Agarwal <sid0@fb.com>
parents:
32631
diff
changeset
|
343 This is different from localrepo.invalidatedirstate() because it always |
e696f597d02f
dirstate: add docstring for invalidate
Siddharth Agarwal <sid0@fb.com>
parents:
32631
diff
changeset
|
344 rereads the dirstate. Use localrepo.invalidatedirstate() if you want to |
e696f597d02f
dirstate: add docstring for invalidate
Siddharth Agarwal <sid0@fb.com>
parents:
32631
diff
changeset
|
345 check whether the dirstate has changed before rereading it.''' |
e696f597d02f
dirstate: add docstring for invalidate
Siddharth Agarwal <sid0@fb.com>
parents:
32631
diff
changeset
|
346 |
35875
bf367a93f000
dirstate: use native strings when peeking in __dict__
Augie Fackler <augie@google.com>
parents:
35109
diff
changeset
|
347 for a in (r"_map", r"_branch", r"_ignore"): |
4953
6b3ed43f77ba
dirstate.invalidate: avoid rebuilding _map
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4952
diff
changeset
|
348 if a in self.__dict__: |
6b3ed43f77ba
dirstate.invalidate: avoid rebuilding _map
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4952
diff
changeset
|
349 delattr(self, a) |
15791
a814f8fcc65a
Use explicit integer division
Martin Geisler <mg@aragost.com>
parents:
15670
diff
changeset
|
350 self._lastnormaltime = 0 |
4903
81078e177266
dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents:
4677
diff
changeset
|
351 self._dirty = False |
31216
49e5491ed9bd
dirstate: track updated files to improve write time
Durham Goode <durham@fb.com>
parents:
31070
diff
changeset
|
352 self._updatedfiles.clear() |
22404
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
353 self._parentwriters = 0 |
29783
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29687
diff
changeset
|
354 self._origpl = None |
4375
109077e7048d
When reloading the dirstate, recompute ignore information if needed.
Bryan O'Sullivan <bos@serpentine.com>
parents:
4374
diff
changeset
|
355 |
363 | 356 def copy(self, source, dest): |
10145
aec936051734
dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents:
9678
diff
changeset
|
357 """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
|
358 if source == dest: |
deda205a00e1
Ignore dummy copies in dirstate and localrepo.filecommit()
Patrick Mezard <pmezard@gmail.com>
parents:
6479
diff
changeset
|
359 return |
4903
81078e177266
dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents:
4677
diff
changeset
|
360 self._dirty = True |
7566
5f7e3f17aece
mq: drop copy records when refreshing regular patches (issue1441)
Patrick Mezard <pmezard@gmail.com>
parents:
7280
diff
changeset
|
361 if source is not None: |
34343
0865d25e8a8a
dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34342
diff
changeset
|
362 self._map.copymap[dest] = source |
31216
49e5491ed9bd
dirstate: track updated files to improve write time
Durham Goode <durham@fb.com>
parents:
31070
diff
changeset
|
363 self._updatedfiles.add(source) |
49e5491ed9bd
dirstate: track updated files to improve write time
Durham Goode <durham@fb.com>
parents:
31070
diff
changeset
|
364 self._updatedfiles.add(dest) |
34343
0865d25e8a8a
dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34342
diff
changeset
|
365 elif self._map.copymap.pop(dest, None): |
31216
49e5491ed9bd
dirstate: track updated files to improve write time
Durham Goode <durham@fb.com>
parents:
31070
diff
changeset
|
366 self._updatedfiles.add(dest) |
363 | 367 |
368 def copied(self, file): | |
34343
0865d25e8a8a
dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34342
diff
changeset
|
369 return self._map.copymap.get(file, None) |
3154
b1f10d3223c1
dirstate: add copies function
Matt Mackall <mpm@selenic.com>
parents:
2962
diff
changeset
|
370 |
b1f10d3223c1
dirstate: add copies function
Matt Mackall <mpm@selenic.com>
parents:
2962
diff
changeset
|
371 def copies(self): |
34343
0865d25e8a8a
dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34342
diff
changeset
|
372 return self._map.copymap |
515 | 373 |
17196
2abe975ffb94
dirstate: eliminate redundant check parameter on _addpath()
Adrian Buehlmann <adrian@cadifra.com>
parents:
17094
diff
changeset
|
374 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
|
375 oldstate = self[f] |
17196
2abe975ffb94
dirstate: eliminate redundant check parameter on _addpath()
Adrian Buehlmann <adrian@cadifra.com>
parents:
17094
diff
changeset
|
376 if state == 'a' or oldstate == 'r': |
13974
23f2736abce3
move checkfilename from util to scmutil
Adrian Buehlmann <adrian@cadifra.com>
parents:
13944
diff
changeset
|
377 scmutil.checkfilename(f) |
35107
61888bd0b300
dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents:
35106
diff
changeset
|
378 if self._map.hastrackeddir(f): |
36998
d5d42c170f4d
py3: use pycompat.bytestr() in dirstate.py
Pulkit Goyal <7895pulkit@gmail.com>
parents:
36789
diff
changeset
|
379 raise error.Abort(_('directory %r already in dirstate') % |
d5d42c170f4d
py3: use pycompat.bytestr() in dirstate.py
Pulkit Goyal <7895pulkit@gmail.com>
parents:
36789
diff
changeset
|
380 pycompat.bytestr(f)) |
6767
80605a8127e0
dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents:
6762
diff
changeset
|
381 # shadows |
24635
21e1ece30f8c
util: move dirs() and finddirs() from scmutil to util
Drew Gottlieb <drgott@google.com>
parents:
24632
diff
changeset
|
382 for d in util.finddirs(f): |
35107
61888bd0b300
dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents:
35106
diff
changeset
|
383 if self._map.hastrackeddir(d): |
6767
80605a8127e0
dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents:
6762
diff
changeset
|
384 break |
34200
1246acdad653
dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents:
34040
diff
changeset
|
385 entry = self._map.get(d) |
1246acdad653
dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents:
34040
diff
changeset
|
386 if entry is not None and entry[0] != 'r': |
26587
56b2bcea2529
error: get Abort from 'error' instead of 'util'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26521
diff
changeset
|
387 raise error.Abort( |
36998
d5d42c170f4d
py3: use pycompat.bytestr() in dirstate.py
Pulkit Goyal <7895pulkit@gmail.com>
parents:
36789
diff
changeset
|
388 _('file %r in dirstate clashes with %r') % |
d5d42c170f4d
py3: use pycompat.bytestr() in dirstate.py
Pulkit Goyal <7895pulkit@gmail.com>
parents:
36789
diff
changeset
|
389 (pycompat.bytestr(d), pycompat.bytestr(f))) |
17094
c2016bae3b97
dirstate: factor common update code into _addpath
Joshua Redstone <joshua.redstone@fb.com>
parents:
16955
diff
changeset
|
390 self._dirty = True |
31216
49e5491ed9bd
dirstate: track updated files to improve write time
Durham Goode <durham@fb.com>
parents:
31070
diff
changeset
|
391 self._updatedfiles.add(f) |
35104
a947cf872799
dirstate: move management of the dirstate dirs into the dirstatemap
Mark Thomas <mbthomas@fb.com>
parents:
35103
diff
changeset
|
392 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
|
393 |
42472
87a34c767384
merge: fix race that could cause wrong size in dirstate
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents:
42468
diff
changeset
|
394 def normal(self, f, parentfiledata=None): |
87a34c767384
merge: fix race that could cause wrong size in dirstate
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents:
42468
diff
changeset
|
395 '''Mark a file normal and clean. |
87a34c767384
merge: fix race that could cause wrong size in dirstate
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents:
42468
diff
changeset
|
396 |
87a34c767384
merge: fix race that could cause wrong size in dirstate
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents:
42468
diff
changeset
|
397 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:
42468
diff
changeset
|
398 |
87a34c767384
merge: fix race that could cause wrong size in dirstate
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents:
42468
diff
changeset
|
399 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:
42468
diff
changeset
|
400 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:
42468
diff
changeset
|
401 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:
42468
diff
changeset
|
402 file having been changed by an external process between the |
87a34c767384
merge: fix race that could cause wrong size in dirstate
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents:
42468
diff
changeset
|
403 moment where the file was determined to be clean and now.''' |
87a34c767384
merge: fix race that could cause wrong size in dirstate
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents:
42468
diff
changeset
|
404 if parentfiledata: |
87a34c767384
merge: fix race that could cause wrong size in dirstate
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents:
42468
diff
changeset
|
405 (mode, size, mtime) = parentfiledata |
87a34c767384
merge: fix race that could cause wrong size in dirstate
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents:
42468
diff
changeset
|
406 else: |
87a34c767384
merge: fix race that could cause wrong size in dirstate
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents:
42468
diff
changeset
|
407 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:
42468
diff
changeset
|
408 mode = s.st_mode |
87a34c767384
merge: fix race that could cause wrong size in dirstate
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents:
42468
diff
changeset
|
409 size = s.st_size |
87a34c767384
merge: fix race that could cause wrong size in dirstate
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents:
42468
diff
changeset
|
410 mtime = s[stat.ST_MTIME] |
87a34c767384
merge: fix race that could cause wrong size in dirstate
Valentin Gatien-Baron <valentin.gatienbaron@gmail.com>
parents:
42468
diff
changeset
|
411 self._addpath(f, 'n', mode, size & _rangemask, mtime & _rangemask) |
34343
0865d25e8a8a
dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34342
diff
changeset
|
412 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
|
413 if f in self._map.nonnormalset: |
60927b19ed65
dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents:
34673
diff
changeset
|
414 self._map.nonnormalset.remove(f) |
13763
7a73c406c0fd
dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents:
13754
diff
changeset
|
415 if mtime > self._lastnormaltime: |
7a73c406c0fd
dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents:
13754
diff
changeset
|
416 # 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
|
417 # 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
|
418 # modifications that happen within the same timeslot. |
13763
7a73c406c0fd
dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents:
13754
diff
changeset
|
419 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
|
420 |
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
|
421 def normallookup(self, f): |
10145
aec936051734
dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents:
9678
diff
changeset
|
422 '''Mark a file normal, but possibly dirty.''' |
34200
1246acdad653
dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents:
34040
diff
changeset
|
423 if self._pl[1] != nullid: |
6298
53cbb33e1269
normallookup: during merges, restore the state saved by remove
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
6297
diff
changeset
|
424 # 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
|
425 # 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
|
426 # being removed, restore that state. |
34200
1246acdad653
dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents:
34040
diff
changeset
|
427 entry = self._map.get(f) |
1246acdad653
dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents:
34040
diff
changeset
|
428 if entry is not None: |
1246acdad653
dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents:
34040
diff
changeset
|
429 if entry[0] == 'r' and entry[2] in (-1, -2): |
34343
0865d25e8a8a
dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34342
diff
changeset
|
430 source = self._map.copymap.get(f) |
34200
1246acdad653
dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents:
34040
diff
changeset
|
431 if entry[2] == -1: |
1246acdad653
dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents:
34040
diff
changeset
|
432 self.merge(f) |
1246acdad653
dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents:
34040
diff
changeset
|
433 elif entry[2] == -2: |
1246acdad653
dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents:
34040
diff
changeset
|
434 self.otherparent(f) |
1246acdad653
dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents:
34040
diff
changeset
|
435 if source: |
1246acdad653
dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents:
34040
diff
changeset
|
436 self.copy(source, f) |
1246acdad653
dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents:
34040
diff
changeset
|
437 return |
1246acdad653
dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents:
34040
diff
changeset
|
438 if entry[0] == 'm' or entry[0] == 'n' and entry[2] == -2: |
1246acdad653
dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents:
34040
diff
changeset
|
439 return |
17094
c2016bae3b97
dirstate: factor common update code into _addpath
Joshua Redstone <joshua.redstone@fb.com>
parents:
16955
diff
changeset
|
440 self._addpath(f, 'n', 0, -1, -1) |
34343
0865d25e8a8a
dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34342
diff
changeset
|
441 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
|
442 |
10968
7a0d096e221e
dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10935
diff
changeset
|
443 def otherparent(self, f): |
7a0d096e221e
dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10935
diff
changeset
|
444 '''Mark as coming from the other parent, always dirty.''' |
7a0d096e221e
dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10935
diff
changeset
|
445 if self._pl[1] == nullid: |
26587
56b2bcea2529
error: get Abort from 'error' instead of 'util'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26521
diff
changeset
|
446 raise error.Abort(_("setting %r to other parent " |
10968
7a0d096e221e
dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10935
diff
changeset
|
447 "only allowed in merges") % f) |
22896
7e9cbb9c6053
dirstate: use 'm' state in otherparent to reduce ambiguity
Matt Mackall <mpm@selenic.com>
parents:
22895
diff
changeset
|
448 if f in self and self[f] == 'n': |
7e9cbb9c6053
dirstate: use 'm' state in otherparent to reduce ambiguity
Matt Mackall <mpm@selenic.com>
parents:
22895
diff
changeset
|
449 # merge-like |
7e9cbb9c6053
dirstate: use 'm' state in otherparent to reduce ambiguity
Matt Mackall <mpm@selenic.com>
parents:
22895
diff
changeset
|
450 self._addpath(f, 'm', 0, -2, -1) |
7e9cbb9c6053
dirstate: use 'm' state in otherparent to reduce ambiguity
Matt Mackall <mpm@selenic.com>
parents:
22895
diff
changeset
|
451 else: |
7e9cbb9c6053
dirstate: use 'm' state in otherparent to reduce ambiguity
Matt Mackall <mpm@selenic.com>
parents:
22895
diff
changeset
|
452 # add-like |
7e9cbb9c6053
dirstate: use 'm' state in otherparent to reduce ambiguity
Matt Mackall <mpm@selenic.com>
parents:
22895
diff
changeset
|
453 self._addpath(f, 'n', 0, -2, -1) |
34343
0865d25e8a8a
dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34342
diff
changeset
|
454 self._map.copymap.pop(f, None) |
4904
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4903
diff
changeset
|
455 |
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4903
diff
changeset
|
456 def add(self, f): |
10145
aec936051734
dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents:
9678
diff
changeset
|
457 '''Mark a file added.''' |
17196
2abe975ffb94
dirstate: eliminate redundant check parameter on _addpath()
Adrian Buehlmann <adrian@cadifra.com>
parents:
17094
diff
changeset
|
458 self._addpath(f, 'a', 0, -1, -1) |
34343
0865d25e8a8a
dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34342
diff
changeset
|
459 self._map.copymap.pop(f, None) |
4616
70352337934e
dirstate: refactor checkinterfering
Matt Mackall <mpm@selenic.com>
parents:
4615
diff
changeset
|
460 |
4904
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4903
diff
changeset
|
461 def remove(self, f): |
10145
aec936051734
dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents:
9678
diff
changeset
|
462 '''Mark a file removed.''' |
4904
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4903
diff
changeset
|
463 self._dirty = True |
35104
a947cf872799
dirstate: move management of the dirstate dirs into the dirstatemap
Mark Thomas <mbthomas@fb.com>
parents:
35103
diff
changeset
|
464 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
|
465 size = 0 |
34200
1246acdad653
dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents:
34040
diff
changeset
|
466 if self._pl[1] != nullid: |
1246acdad653
dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents:
34040
diff
changeset
|
467 entry = self._map.get(f) |
1246acdad653
dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents:
34040
diff
changeset
|
468 if entry is not None: |
1246acdad653
dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents:
34040
diff
changeset
|
469 # backup the previous state |
1246acdad653
dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents:
34040
diff
changeset
|
470 if entry[0] == 'm': # merge |
1246acdad653
dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents:
34040
diff
changeset
|
471 size = -1 |
1246acdad653
dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents:
34040
diff
changeset
|
472 elif entry[0] == 'n' and entry[2] == -2: # other parent |
1246acdad653
dirstate: perform transactions with _map using single call, where possible
Michael Bolin <mbolin@fb.com>
parents:
34040
diff
changeset
|
473 size = -2 |
34674
60927b19ed65
dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents:
34673
diff
changeset
|
474 self._map.otherparentset.add(f) |
35106
e8ae0b2d88a8
dirstate: remove _droppath method
Mark Thomas <mbthomas@fb.com>
parents:
35105
diff
changeset
|
475 self._updatedfiles.add(f) |
35104
a947cf872799
dirstate: move management of the dirstate dirs into the dirstatemap
Mark Thomas <mbthomas@fb.com>
parents:
35103
diff
changeset
|
476 self._map.removefile(f, oldstate, size) |
33999
5cb0a8fe096e
dirstate: perform transactions with _copymap using single call, where possible
Michael Bolin <mbolin@fb.com>
parents:
33763
diff
changeset
|
477 if size == 0: |
34343
0865d25e8a8a
dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34342
diff
changeset
|
478 self._map.copymap.pop(f, None) |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
479 |
4904
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4903
diff
changeset
|
480 def merge(self, f): |
10145
aec936051734
dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents:
9678
diff
changeset
|
481 '''Mark a file merged.''' |
16509
eab9119c5dee
rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents:
16472
diff
changeset
|
482 if self._pl[1] == nullid: |
eab9119c5dee
rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents:
16472
diff
changeset
|
483 return self.normallookup(f) |
22897
8fe74328f700
dirstate: merge falls through to otherparent
Matt Mackall <mpm@selenic.com>
parents:
22896
diff
changeset
|
484 return self.otherparent(f) |
4904
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4903
diff
changeset
|
485 |
14434
cc8c09855d19
dirstate: rename forget to drop
Matt Mackall <mpm@selenic.com>
parents:
14273
diff
changeset
|
486 def drop(self, f): |
cc8c09855d19
dirstate: rename forget to drop
Matt Mackall <mpm@selenic.com>
parents:
14273
diff
changeset
|
487 '''Drop a file from the dirstate''' |
35104
a947cf872799
dirstate: move management of the dirstate dirs into the dirstatemap
Mark Thomas <mbthomas@fb.com>
parents:
35103
diff
changeset
|
488 oldstate = self[f] |
a947cf872799
dirstate: move management of the dirstate dirs into the dirstatemap
Mark Thomas <mbthomas@fb.com>
parents:
35103
diff
changeset
|
489 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
|
490 self._dirty = True |
35106
e8ae0b2d88a8
dirstate: remove _droppath method
Mark Thomas <mbthomas@fb.com>
parents:
35105
diff
changeset
|
491 self._updatedfiles.add(f) |
34343
0865d25e8a8a
dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34342
diff
changeset
|
492 self._map.copymap.pop(f, None) |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
493 |
24538
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
494 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
|
495 if exists is None: |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
496 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
|
497 if not exists: |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
498 # Maybe a path component exists |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
499 if not ignoremissing and '/' in path: |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
500 d, f = path.rsplit('/', 1) |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
501 d = self._normalize(d, False, ignoremissing, None) |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
502 folded = d + "/" + f |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
503 else: |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
504 # No path components, preserve original case |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
505 folded = path |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
506 else: |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
507 # recursively normalize leading directory components |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
508 # against dirstate |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
509 if '/' in normed: |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
510 d, f = normed.rsplit('/', 1) |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
511 d = self._normalize(d, False, ignoremissing, True) |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
512 r = self._root + "/" + d |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
513 folded = d + "/" + util.fspath(f, r) |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
514 else: |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
515 folded = util.fspath(normed, self._root) |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
516 storemap[normed] = folded |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
517 |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
518 return folded |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
519 |
24539
3a8eba78803e
dirstate: introduce function to normalize just filenames
Siddharth Agarwal <sid0@fb.com>
parents:
24538
diff
changeset
|
520 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
|
521 normed = util.normcase(path) |
34676
bfddc3d678ae
dirstate: remove _filefoldmap property cache
Durham Goode <durham@fb.com>
parents:
34675
diff
changeset
|
522 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
|
523 if folded is None: |
16542
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
524 if isknown: |
13717
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
525 folded = path |
7068
57377fa7eda2
issue 1286: dirstat regression on case folding systems
Petr Kodl <petrkodl@gmail.com>
parents:
7034
diff
changeset
|
526 else: |
24539
3a8eba78803e
dirstate: introduce function to normalize just filenames
Siddharth Agarwal <sid0@fb.com>
parents:
24538
diff
changeset
|
527 folded = self._discoverpath(path, normed, ignoremissing, exists, |
34676
bfddc3d678ae
dirstate: remove _filefoldmap property cache
Durham Goode <durham@fb.com>
parents:
34675
diff
changeset
|
528 self._map.filefoldmap) |
24539
3a8eba78803e
dirstate: introduce function to normalize just filenames
Siddharth Agarwal <sid0@fb.com>
parents:
24538
diff
changeset
|
529 return folded |
16302
49b54f1ae053
dirstate: normalize case of directory components
Matt Mackall <mpm@selenic.com>
parents:
16258
diff
changeset
|
530 |
16542
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
531 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
|
532 normed = util.normcase(path) |
34676
bfddc3d678ae
dirstate: remove _filefoldmap property cache
Durham Goode <durham@fb.com>
parents:
34675
diff
changeset
|
533 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
|
534 if folded is None: |
34678
e8a89ed7ce96
dirstate: move the _dirfoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34677
diff
changeset
|
535 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
|
536 if folded is None: |
16542
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
537 if isknown: |
13717
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
538 folded = path |
7068
57377fa7eda2
issue 1286: dirstat regression on case folding systems
Petr Kodl <petrkodl@gmail.com>
parents:
7034
diff
changeset
|
539 else: |
24540
25c1d3ca5ff6
dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents:
24539
diff
changeset
|
540 # 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
|
541 # normalizefile calls don't start matching directories |
24538
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
542 folded = self._discoverpath(path, normed, ignoremissing, exists, |
34678
e8a89ed7ce96
dirstate: move the _dirfoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34677
diff
changeset
|
543 self._map.dirfoldmap) |
13717
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
544 return folded |
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
545 |
16542
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
546 def normalize(self, path, isknown=False, ignoremissing=False): |
13717
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
547 ''' |
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
548 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
|
549 |
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
550 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
|
551 disk, to avoid extra filesystem access. |
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
552 |
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
553 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
|
554 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
|
555 existing path components. |
13717
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
556 |
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
557 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
|
558 |
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
559 - 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
|
560 - version of name stored on disk |
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
561 - version provided via command arguments |
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
562 ''' |
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
563 |
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
564 if self._checkcase: |
16542
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
565 return self._normalize(path, isknown, ignoremissing) |
13717
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
566 return path |
6677
9865e15febd0
Add a normalize() method to dirstate
Paul Moore <p.f.moore@gmail.com>
parents:
6675
diff
changeset
|
567 |
5065
b304c2496f52
dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4953
diff
changeset
|
568 def clear(self): |
34933
0217f75b6e59
dirstate: move clear onto dirstatemap class
Durham Goode <durham@fb.com>
parents:
34678
diff
changeset
|
569 self._map.clear() |
15791
a814f8fcc65a
Use explicit integer division
Martin Geisler <mg@aragost.com>
parents:
15670
diff
changeset
|
570 self._lastnormaltime = 0 |
31216
49e5491ed9bd
dirstate: track updated files to improve write time
Durham Goode <durham@fb.com>
parents:
31070
diff
changeset
|
571 self._updatedfiles.clear() |
5123 | 572 self._dirty = True |
5065
b304c2496f52
dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4953
diff
changeset
|
573 |
18760
e74704c33e24
strip: make --keep option not set all dirstate times to 0
Durham Goode <durham@fb.com>
parents:
18663
diff
changeset
|
574 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
|
575 if changedfiles is None: |
27176
54ace3372f84
dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents:
27016
diff
changeset
|
576 # Rebuild entire dirstate |
25448
2bbfc2042d93
dirstate: avoid invalidating every entries when list is empty
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25275
diff
changeset
|
577 changedfiles = allfiles |
27176
54ace3372f84
dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents:
27016
diff
changeset
|
578 lastnormaltime = self._lastnormaltime |
54ace3372f84
dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents:
27016
diff
changeset
|
579 self.clear() |
54ace3372f84
dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents:
27016
diff
changeset
|
580 self._lastnormaltime = lastnormaltime |
54ace3372f84
dirstate: change debugrebuilddirstate --minimal to use dirstate.rebuild
Christian Delahousse <cdelahousse@fb.com>
parents:
27016
diff
changeset
|
581 |
29783
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29687
diff
changeset
|
582 if self._origpl is None: |
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29687
diff
changeset
|
583 self._origpl = self._pl |
34346
ec769bba34d3
dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents:
34345
diff
changeset
|
584 self._map.setparents(parent, nullid) |
30028
ba06562a06a2
dirstate: rebuild should update dirstate properly
Mateusz Kwapich <mitrandir@fb.com>
parents:
29893
diff
changeset
|
585 for f in changedfiles: |
ba06562a06a2
dirstate: rebuild should update dirstate properly
Mateusz Kwapich <mitrandir@fb.com>
parents:
29893
diff
changeset
|
586 if f in allfiles: |
ba06562a06a2
dirstate: rebuild should update dirstate properly
Mateusz Kwapich <mitrandir@fb.com>
parents:
29893
diff
changeset
|
587 self.normallookup(f) |
ba06562a06a2
dirstate: rebuild should update dirstate properly
Mateusz Kwapich <mitrandir@fb.com>
parents:
29893
diff
changeset
|
588 else: |
ba06562a06a2
dirstate: rebuild should update dirstate properly
Mateusz Kwapich <mitrandir@fb.com>
parents:
29893
diff
changeset
|
589 self.drop(f) |
ba06562a06a2
dirstate: rebuild should update dirstate properly
Mateusz Kwapich <mitrandir@fb.com>
parents:
29893
diff
changeset
|
590 |
4903
81078e177266
dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents:
4677
diff
changeset
|
591 self._dirty = True |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
592 |
32770
b698921ee137
dirstate: add identity information to detect simultaneous changing in storage
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
32702
diff
changeset
|
593 def identity(self): |
b698921ee137
dirstate: add identity information to detect simultaneous changing in storage
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
32702
diff
changeset
|
594 '''Return identity of dirstate itself to detect changing in storage |
b698921ee137
dirstate: add identity information to detect simultaneous changing in storage
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
32702
diff
changeset
|
595 |
b698921ee137
dirstate: add identity information to detect simultaneous changing in storage
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
32702
diff
changeset
|
596 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:
32702
diff
changeset
|
597 changes based on the former dirstate out can keep consistency. |
b698921ee137
dirstate: add identity information to detect simultaneous changing in storage
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
32702
diff
changeset
|
598 ''' |
34675
c6ef9a2498a5
dirstate: move identity to dirstatemap
Durham Goode <durham@fb.com>
parents:
34674
diff
changeset
|
599 return self._map.identity |
32770
b698921ee137
dirstate: add identity information to detect simultaneous changing in storage
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
32702
diff
changeset
|
600 |
29687
52ff07e1de91
deprecation: enforce thew 'tr' argument of 'dirstate.write' (API)
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
29351
diff
changeset
|
601 def write(self, tr): |
4612
17ee7407097f
dirstate: simplify dirty handling
Matt Mackall <mpm@selenic.com>
parents:
4611
diff
changeset
|
602 if not self._dirty: |
1794
98b6c1cad58b
only write the dirstate when something changed
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1755
diff
changeset
|
603 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
|
604 |
26634
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
605 filename = self._filename |
29687
52ff07e1de91
deprecation: enforce thew 'tr' argument of 'dirstate.write' (API)
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
29351
diff
changeset
|
606 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
|
607 # '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
|
608 # 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
|
609 # 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
|
610 # 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
|
611 # 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
|
612 |
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
613 # 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
|
614 now = _getfsnow(self._opener) |
35103
19b75779b7c3
dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents:
35102
diff
changeset
|
615 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
|
616 |
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
617 # 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
|
618 self._lastnormaltime = 0 |
31216
49e5491ed9bd
dirstate: track updated files to improve write time
Durham Goode <durham@fb.com>
parents:
31070
diff
changeset
|
619 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
|
620 |
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
621 # delay writing in-memory changes out |
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
622 tr.addfilegenerator('dirstate', (self._filename,), |
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
623 self._writedirstate, location='plain') |
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
624 return |
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
625 |
29301
28f37ffc0a91
dirstate: make writing dirstate file out avoid ambiguity of file stat
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
29273
diff
changeset
|
626 st = self._opener(filename, "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
|
627 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
|
628 |
29783
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29687
diff
changeset
|
629 def addparentchangecallback(self, category, callback): |
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29687
diff
changeset
|
630 """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:
29687
diff
changeset
|
631 |
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29687
diff
changeset
|
632 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:
29687
diff
changeset
|
633 dirstate, (oldp1, oldp2), (newp1, newp2) |
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29687
diff
changeset
|
634 |
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29687
diff
changeset
|
635 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:
29687
diff
changeset
|
636 with a newer callback. |
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29687
diff
changeset
|
637 """ |
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29687
diff
changeset
|
638 self._plchangecallbacks[category] = callback |
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29687
diff
changeset
|
639 |
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
|
640 def _writedirstate(self, st): |
29783
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29687
diff
changeset
|
641 # notify callbacks about parents change |
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29687
diff
changeset
|
642 if self._origpl is not None and self._origpl != self._pl: |
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29687
diff
changeset
|
643 for c, callback in sorted(self._plchangecallbacks.iteritems()): |
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29687
diff
changeset
|
644 callback(self, self._origpl, self._pl) |
2ebd507e5ac3
dirstate: add callback to notify extensions about wd parent change
Mateusz Kwapich <mitrandir@fb.com>
parents:
29687
diff
changeset
|
645 self._origpl = None |
9509
e4ca8c258d9b
dirstate: kill dirstate.granularity config option
Adrian Buehlmann <adrian@cadifra.com>
parents:
9379
diff
changeset
|
646 # 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
|
647 # filesystem's notion of 'now' |
36789
ffa3026d4196
cleanup: use stat_result[stat.ST_MTIME] instead of stat_result.st_mtime
Augie Fackler <augie@google.com>
parents:
36651
diff
changeset
|
648 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
|
649 |
6c6b48aca328
dirstate: move delaywrite logic from write to _write
Matt Mackall <mpm@selenic.com>
parents:
27176
diff
changeset
|
650 # 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
|
651 # timestamp of each entries in dirstate, because of 'now > mtime' |
34481
cbda631c1dde
configitems: register the 'debug.dirstate.delaywrite' config
Boris Feld <boris.feld@octobus.net>
parents:
34409
diff
changeset
|
652 delaywrite = self._ui.configint('debug', 'dirstate.delaywrite') |
27397
6c6b48aca328
dirstate: move delaywrite logic from write to _write
Matt Mackall <mpm@selenic.com>
parents:
27176
diff
changeset
|
653 if delaywrite > 0: |
27398
c81675776c95
dirstate: only invoke delaywrite if relevant
Matt Mackall <mpm@selenic.com>
parents:
27397
diff
changeset
|
654 # do we have any files to delay for? |
42771
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
655 items = self._map.iteritems() |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
656 for f, e in items: |
27398
c81675776c95
dirstate: only invoke delaywrite if relevant
Matt Mackall <mpm@selenic.com>
parents:
27397
diff
changeset
|
657 if e[0] == 'n' and e[3] == now: |
c81675776c95
dirstate: only invoke delaywrite if relevant
Matt Mackall <mpm@selenic.com>
parents:
27397
diff
changeset
|
658 import time # to avoid useless import |
27399
425dc70037f7
dirstate: make delaywrite sleep until the next multiple of n seconds
Matt Mackall <mpm@selenic.com>
parents:
27398
diff
changeset
|
659 # 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
|
660 # 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
|
661 clock = time.time() |
425dc70037f7
dirstate: make delaywrite sleep until the next multiple of n seconds
Matt Mackall <mpm@selenic.com>
parents:
27398
diff
changeset
|
662 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
|
663 end = start + delaywrite |
425dc70037f7
dirstate: make delaywrite sleep until the next multiple of n seconds
Matt Mackall <mpm@selenic.com>
parents:
27398
diff
changeset
|
664 time.sleep(end - clock) |
30224
ad56071b37d4
dirstate: fix debug.dirstate.delaywrite to use the new "now" after sleeping
Mads Kiilerich <madski@unity3d.com>
parents:
30028
diff
changeset
|
665 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
|
666 break |
42771
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
667 # since the iterator is potentially not deleted, |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
668 # delete the iterator to release the reference for the Rust |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
669 # implementation. |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
670 # TODO make the Rust implementation behave like Python |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
671 # since this would not work with a non ref-counting GC. |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
672 del items |
27397
6c6b48aca328
dirstate: move delaywrite logic from write to _write
Matt Mackall <mpm@selenic.com>
parents:
27176
diff
changeset
|
673 |
34673
e2214632c3a2
dirstate: move write into dirstatemap
Durham Goode <durham@fb.com>
parents:
34672
diff
changeset
|
674 self._map.write(st, now) |
21026
7ee03e190c1d
dirstate: inline local finish function
Mads Kiilerich <madski@unity3d.com>
parents:
20632
diff
changeset
|
675 self._lastnormaltime = 0 |
34673
e2214632c3a2
dirstate: move write into dirstatemap
Durham Goode <durham@fb.com>
parents:
34672
diff
changeset
|
676 self._dirty = False |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
677 |
6032
b41f0d6a74fc
dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5516
diff
changeset
|
678 def _dirignore(self, f): |
b41f0d6a74fc
dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5516
diff
changeset
|
679 if self._ignore(f): |
b41f0d6a74fc
dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5516
diff
changeset
|
680 return True |
24635
21e1ece30f8c
util: move dirs() and finddirs() from scmutil to util
Drew Gottlieb <drgott@google.com>
parents:
24632
diff
changeset
|
681 for p in util.finddirs(f): |
6767
80605a8127e0
dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents:
6762
diff
changeset
|
682 if self._ignore(p): |
6032
b41f0d6a74fc
dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5516
diff
changeset
|
683 return True |
b41f0d6a74fc
dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5516
diff
changeset
|
684 return False |
b41f0d6a74fc
dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5516
diff
changeset
|
685 |
27594
0921caca7703
dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents:
27593
diff
changeset
|
686 def _ignorefiles(self): |
0921caca7703
dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents:
27593
diff
changeset
|
687 files = [] |
0921caca7703
dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents:
27593
diff
changeset
|
688 if os.path.exists(self._join('.hgignore')): |
0921caca7703
dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents:
27593
diff
changeset
|
689 files.append(self._join('.hgignore')) |
0921caca7703
dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents:
27593
diff
changeset
|
690 for name, path in self._ui.configitems("ui"): |
0921caca7703
dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents:
27593
diff
changeset
|
691 if name == 'ignore' or name.startswith('ignore.'): |
0921caca7703
dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents:
27593
diff
changeset
|
692 # 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
|
693 # 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
|
694 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
|
695 return files |
0921caca7703
dirstate: extract logic to compute the list of ignorefiles
Laurent Charignon <lcharignon@fb.com>
parents:
27593
diff
changeset
|
696 |
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
|
697 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
|
698 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
|
699 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
|
700 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
|
701 i = files.popleft() |
4374f039d269
dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents:
27594
diff
changeset
|
702 patterns = matchmod.readpatternfile(i, self._ui.warn, |
4374f039d269
dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents:
27594
diff
changeset
|
703 sourceinfo=True) |
4374f039d269
dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents:
27594
diff
changeset
|
704 for pattern, lineno, line in patterns: |
4374f039d269
dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents:
27594
diff
changeset
|
705 kind, p = matchmod._patsplit(pattern, 'glob') |
4374f039d269
dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents:
27594
diff
changeset
|
706 if kind == "subinclude": |
4374f039d269
dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents:
27594
diff
changeset
|
707 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
|
708 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
|
709 continue |
4374f039d269
dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents:
27594
diff
changeset
|
710 m = matchmod.match(self._root, '', [], [pattern], |
4374f039d269
dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents:
27594
diff
changeset
|
711 warn=self._ui.warn) |
4374f039d269
dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents:
27594
diff
changeset
|
712 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
|
713 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
|
714 visited.add(i) |
4374f039d269
dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents:
27594
diff
changeset
|
715 return (None, -1, "") |
4374f039d269
dirstate: add a way to get the ignore file/line matching an ignored file
Laurent Charignon <lcharignon@fb.com>
parents:
27594
diff
changeset
|
716 |
19173
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
717 def _walkexplicit(self, match, subrepos): |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
718 '''Get stat data about the files explicitly specified by match. |
3529 | 719 |
19174
022256ef47b8
dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents:
19173
diff
changeset
|
720 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
|
721 - 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
|
722 listings mapping subrepos and .hg to None. |
19174
022256ef47b8
dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents:
19173
diff
changeset
|
723 - 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
|
724 - dirsnotfound is a list of files that the dirstate thinks are |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
725 directories and that were not found.''' |
6578
f242d3684f83
walk: begin refactoring badmatch handling
Matt Mackall <mpm@selenic.com>
parents:
6577
diff
changeset
|
726 |
8681
26f133267cd7
walk: use match.bad callback for filetype messages
Matt Mackall <mpm@selenic.com>
parents:
8680
diff
changeset
|
727 def badtype(mode): |
8310
8417d82d3969
dirstate: translate forgotten string
Simon Heimberg <simohe@besonet.ch>
parents:
8261
diff
changeset
|
728 kind = _('unknown') |
10282
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
729 if stat.S_ISCHR(mode): |
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
730 kind = _('character device') |
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
731 elif stat.S_ISBLK(mode): |
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
732 kind = _('block device') |
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
733 elif stat.S_ISFIFO(mode): |
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
734 kind = _('fifo') |
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
735 elif stat.S_ISSOCK(mode): |
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
736 kind = _('socket') |
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
737 elif stat.S_ISDIR(mode): |
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
738 kind = _('directory') |
8681
26f133267cd7
walk: use match.bad callback for filetype messages
Matt Mackall <mpm@selenic.com>
parents:
8680
diff
changeset
|
739 return _('unsupported file type (type is %s)') % kind |
6830
2cf4cda64727
dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents:
6829
diff
changeset
|
740 |
19142
c3d3e4d75ec3
dirstate.walk: cache match.explicitdir and traversedir locally
Siddharth Agarwal <sid0@fb.com>
parents:
19137
diff
changeset
|
741 matchedir = match.explicitdir |
8676
acd69fc201a5
walk: we always have a badfn
Matt Mackall <mpm@selenic.com>
parents:
8675
diff
changeset
|
742 badfn = match.bad |
6831
2b663f542bd3
dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents:
6830
diff
changeset
|
743 dmap = self._map |
5000
46facb73ba8b
dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents:
4965
diff
changeset
|
744 lstat = os.lstat |
6830
2cf4cda64727
dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents:
6829
diff
changeset
|
745 getkind = stat.S_IFMT |
6828
55d65a33da52
dirstate.walk: minor cleanups
Matt Mackall <mpm@selenic.com>
parents:
6827
diff
changeset
|
746 dirkind = stat.S_IFDIR |
6830
2cf4cda64727
dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents:
6829
diff
changeset
|
747 regkind = stat.S_IFREG |
2cf4cda64727
dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents:
6829
diff
changeset
|
748 lnkkind = stat.S_IFLNK |
6831
2b663f542bd3
dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents:
6830
diff
changeset
|
749 join = self._join |
19174
022256ef47b8
dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents:
19173
diff
changeset
|
750 dirsfound = [] |
022256ef47b8
dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents:
19173
diff
changeset
|
751 foundadd = dirsfound.append |
19173
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
752 dirsnotfound = [] |
19175
63f7bd2e1a46
dirstate._walkexplicit: inline dirsnotfound.append
Siddharth Agarwal <sid0@fb.com>
parents:
19174
diff
changeset
|
753 notfoundadd = dirsnotfound.append |
6820
639d9cb95509
dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents:
6819
diff
changeset
|
754 |
24448
55c449345b10
match: add isexact() method to hide internals
Martin von Zweigbergk <martinvonz@google.com>
parents:
24212
diff
changeset
|
755 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
|
756 normalize = self._normalize |
e255a5dc29e6
dirstate: skip optimization on case-folding FS (issue2440)
Matt Mackall <mpm@selenic.com>
parents:
12401
diff
changeset
|
757 else: |
18032
a9e623bb440e
dirstate: test normalize is truthy instead of using a no-op lambda
Siddharth Agarwal <sid0@fb.com>
parents:
18018
diff
changeset
|
758 normalize = None |
12907
e255a5dc29e6
dirstate: skip optimization on case-folding FS (issue2440)
Matt Mackall <mpm@selenic.com>
parents:
12401
diff
changeset
|
759 |
12211
798d72f3621c
dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12164
diff
changeset
|
760 files = sorted(match.files()) |
798d72f3621c
dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12164
diff
changeset
|
761 subrepos.sort() |
798d72f3621c
dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12164
diff
changeset
|
762 i, j = 0, 0 |
798d72f3621c
dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12164
diff
changeset
|
763 while i < len(files) and j < len(subrepos): |
798d72f3621c
dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12164
diff
changeset
|
764 subpath = subrepos[j] + "/" |
13233
0b30e6148ec5
subrepo: do not report known files inside repositories as unknown
Oleg Stepanov <oleg.stepanov@jetbrains.com>
parents:
12907
diff
changeset
|
765 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
|
766 i += 1 |
798d72f3621c
dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12164
diff
changeset
|
767 continue |
13339
22167be007ed
subrepo: fix pruning of subrepo filenames in dirstate (issue2619)
trbs <trbs@trbs.net>
parents:
13233
diff
changeset
|
768 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
|
769 del files[i] |
798d72f3621c
dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12164
diff
changeset
|
770 j += 1 |
798d72f3621c
dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12164
diff
changeset
|
771 |
42363
27d6956d386b
match: use '' instead of '.' for root directory (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42362
diff
changeset
|
772 if not files or '' in files: |
27d6956d386b
match: use '' instead of '.' for root directory (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42362
diff
changeset
|
773 files = [''] |
42362
7ada598941d2
dirstate: move special handling of files==['.'] together
Martin von Zweigbergk <martinvonz@google.com>
parents:
42331
diff
changeset
|
774 # constructing the foldmap is expensive, so don't do it for the |
42363
27d6956d386b
match: use '' instead of '.' for root directory (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42362
diff
changeset
|
775 # common case where files is [''] |
42362
7ada598941d2
dirstate: move special handling of files==['.'] together
Martin von Zweigbergk <martinvonz@google.com>
parents:
42331
diff
changeset
|
776 normalize = None |
10176
24ce8f0c0a39
dirstate: don't check state of subrepo directories
Augie Fackler <durin42@gmail.com>
parents:
10145
diff
changeset
|
777 results = dict.fromkeys(subrepos) |
24ce8f0c0a39
dirstate: don't check state of subrepo directories
Augie Fackler <durin42@gmail.com>
parents:
10145
diff
changeset
|
778 results['.hg'] = None |
5000
46facb73ba8b
dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents:
4965
diff
changeset
|
779 |
12211
798d72f3621c
dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12164
diff
changeset
|
780 for ff in files: |
42362
7ada598941d2
dirstate: move special handling of files==['.'] together
Martin von Zweigbergk <martinvonz@google.com>
parents:
42331
diff
changeset
|
781 if normalize: |
24522
18085e46caa9
dirstate._walkexplicit: drop normpath calls
Siddharth Agarwal <sid0@fb.com>
parents:
24521
diff
changeset
|
782 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
|
783 else: |
24522
18085e46caa9
dirstate._walkexplicit: drop normpath calls
Siddharth Agarwal <sid0@fb.com>
parents:
24521
diff
changeset
|
784 nf = ff |
6829
fec1da46006e
dirstate.walk: build a dict rather than yield
Matt Mackall <mpm@selenic.com>
parents:
6828
diff
changeset
|
785 if nf in results: |
6820
639d9cb95509
dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents:
6819
diff
changeset
|
786 continue |
639d9cb95509
dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents:
6819
diff
changeset
|
787 |
639d9cb95509
dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents:
6819
diff
changeset
|
788 try: |
6831
2b663f542bd3
dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents:
6830
diff
changeset
|
789 st = lstat(join(nf)) |
6830
2cf4cda64727
dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents:
6829
diff
changeset
|
790 kind = getkind(st.st_mode) |
2cf4cda64727
dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents:
6829
diff
changeset
|
791 if kind == dirkind: |
8588
2624f485b9bc
dirstate: set more states in step 1 of walk
Simon Heimberg <simohe@besonet.ch>
parents:
8521
diff
changeset
|
792 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
|
793 # 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
|
794 results[nf] = None |
19143
3cb9468535bd
match: make explicitdir and traversedir None by default
Siddharth Agarwal <sid0@fb.com>
parents:
19142
diff
changeset
|
795 if matchedir: |
3cb9468535bd
match: make explicitdir and traversedir None by default
Siddharth Agarwal <sid0@fb.com>
parents:
19142
diff
changeset
|
796 matchedir(nf) |
24537
2bb13f2b778c
dirstate: don't require exact case when adding dirs on icasefs (issue4578)
Matt Harbison <matt_harbison@yahoo.com>
parents:
24198
diff
changeset
|
797 foundadd((nf, ff)) |
12401
4cdaf1adafc8
backout most of 4f8067c94729
Matt Mackall <mpm@selenic.com>
parents:
12387
diff
changeset
|
798 elif kind == regkind or kind == lnkkind: |
6830
2cf4cda64727
dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents:
6829
diff
changeset
|
799 results[nf] = st |
6828
55d65a33da52
dirstate.walk: minor cleanups
Matt Mackall <mpm@selenic.com>
parents:
6827
diff
changeset
|
800 else: |
8681
26f133267cd7
walk: use match.bad callback for filetype messages
Matt Mackall <mpm@selenic.com>
parents:
8680
diff
changeset
|
801 badfn(ff, badtype(kind)) |
6830
2cf4cda64727
dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents:
6829
diff
changeset
|
802 if nf in dmap: |
6829
fec1da46006e
dirstate.walk: build a dict rather than yield
Matt Mackall <mpm@selenic.com>
parents:
6828
diff
changeset
|
803 results[nf] = None |
25660
328739ea70c3
global: mass rewrite to use modern exception syntax
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25658
diff
changeset
|
804 except OSError as inst: # nf not found on disk - it is dirstate only |
21115
1b6e37f44250
dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents:
21026
diff
changeset
|
805 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
|
806 results[nf] = None |
21115
1b6e37f44250
dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents:
21026
diff
changeset
|
807 else: # does it match a missing directory? |
35107
61888bd0b300
dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents:
35106
diff
changeset
|
808 if self._map.hasdir(nf): |
23375
a179db3db9b9
dirstate: speed up repeated missing directory checks
Martin von Zweigbergk <martinvonz@google.com>
parents:
22915
diff
changeset
|
809 if matchedir: |
a179db3db9b9
dirstate: speed up repeated missing directory checks
Martin von Zweigbergk <martinvonz@google.com>
parents:
22915
diff
changeset
|
810 matchedir(nf) |
a179db3db9b9
dirstate: speed up repeated missing directory checks
Martin von Zweigbergk <martinvonz@google.com>
parents:
22915
diff
changeset
|
811 notfoundadd(nf) |
8677
34df078b8b1b
walk: simplify logic for badfn clause
Matt Mackall <mpm@selenic.com>
parents:
8676
diff
changeset
|
812 else: |
34040
d5b2beca16c0
python3: wrap all uses of <exception>.strerror with strtolocal
Augie Fackler <raf@durin42.com>
parents:
33999
diff
changeset
|
813 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
|
814 |
36238
deb851914fd7
dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents:
35935
diff
changeset
|
815 # 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:
35935
diff
changeset
|
816 # 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:
35935
diff
changeset
|
817 # 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:
35935
diff
changeset
|
818 if match.anypats(): |
deb851914fd7
dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents:
35935
diff
changeset
|
819 for f in list(results): |
deb851914fd7
dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents:
35935
diff
changeset
|
820 if f == '.hg' or f in subrepos: |
deb851914fd7
dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents:
35935
diff
changeset
|
821 # 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:
35935
diff
changeset
|
822 continue |
deb851914fd7
dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents:
35935
diff
changeset
|
823 if not match(f): |
deb851914fd7
dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents:
35935
diff
changeset
|
824 del results[f] |
deb851914fd7
dirstate: drop explicit files that shouldn't match (BC) (issue4679)
Yuya Nishihara <yuya@tcha.org>
parents:
35935
diff
changeset
|
825 |
25877
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
826 # 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
|
827 # 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
|
828 # 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
|
829 # 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
|
830 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
|
831 normed = {} |
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
832 |
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
833 for f, st in results.iteritems(): |
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
834 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
|
835 continue |
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
836 |
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
837 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
|
838 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
|
839 |
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
840 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
|
841 paths = set() |
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
842 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
|
843 |
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
844 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
|
845 |
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
846 for norm, paths in normed.iteritems(): |
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
847 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
|
848 for path in paths: |
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
849 folded = self._discoverpath(path, norm, True, None, |
34678
e8a89ed7ce96
dirstate: move the _dirfoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34677
diff
changeset
|
850 self._map.dirfoldmap) |
25877
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
851 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
|
852 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
|
853 |
19174
022256ef47b8
dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents:
19173
diff
changeset
|
854 return results, dirsfound, dirsnotfound |
19173
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
855 |
19190
b03952ee634d
dirstate.walk: add a flag to let extensions avoid full walks
Siddharth Agarwal <sid0@fb.com>
parents:
19175
diff
changeset
|
856 def walk(self, match, subrepos, unknown, ignored, full=True): |
19173
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
857 ''' |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
858 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
|
859 matched by match. |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
860 |
19190
b03952ee634d
dirstate.walk: add a flag to let extensions avoid full walks
Siddharth Agarwal <sid0@fb.com>
parents:
19175
diff
changeset
|
861 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
|
862 |
19173
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
863 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
|
864 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
|
865 |
19173
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
866 ''' |
19190
b03952ee634d
dirstate.walk: add a flag to let extensions avoid full walks
Siddharth Agarwal <sid0@fb.com>
parents:
19175
diff
changeset
|
867 # 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
|
868 # 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
|
869 # 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
|
870 |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
871 if ignored: |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
872 ignore = util.never |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
873 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
|
874 elif unknown: |
1b6e37f44250
dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents:
21026
diff
changeset
|
875 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
|
876 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
|
877 else: |
1b6e37f44250
dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents:
21026
diff
changeset
|
878 # 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
|
879 ignore = util.always |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
880 dirignore = util.always |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
881 |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
882 matchfn = match.matchfn |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
883 matchalways = match.always() |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
884 matchtdir = match.traversedir |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
885 dmap = self._map |
32248
d74b0cff94a9
osutil: proxy through util (and platform) modules (API)
Yuya Nishihara <yuya@tcha.org>
parents:
32226
diff
changeset
|
886 listdir = util.listdir |
19173
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
887 lstat = os.lstat |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
888 dirkind = stat.S_IFDIR |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
889 regkind = stat.S_IFREG |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
890 lnkkind = stat.S_IFLNK |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
891 join = self._join |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
892 |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
893 exact = skipstep3 = False |
24448
55c449345b10
match: add isexact() method to hide internals
Martin von Zweigbergk <martinvonz@google.com>
parents:
24212
diff
changeset
|
894 if match.isexact(): # match.exact |
19173
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
895 exact = True |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
896 dirignore = util.always # skip step 2 |
25234
3c346969c321
dirstate: avoid match.files() in walk()
Martin von Zweigbergk <martinvonz@google.com>
parents:
25227
diff
changeset
|
897 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
|
898 skipstep3 = True |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
899 |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
900 if not exact and self._checkcase: |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
901 normalize = self._normalize |
24541
e235b5dc5cf9
dirstate.walk: use the file foldmap to normalize
Siddharth Agarwal <sid0@fb.com>
parents:
24540
diff
changeset
|
902 normalizefile = self._normalizefile |
19173
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
903 skipstep3 = False |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
904 else: |
24560
b38bcf18993c
dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents:
24559
diff
changeset
|
905 normalize = self._normalize |
24541
e235b5dc5cf9
dirstate.walk: use the file foldmap to normalize
Siddharth Agarwal <sid0@fb.com>
parents:
24540
diff
changeset
|
906 normalizefile = None |
19173
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
907 |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
908 # step 1: find all explicit files |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
909 results, work, dirsnotfound = self._walkexplicit(match, subrepos) |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
910 |
19172
c6cea2e2031b
dirstate.walk: pull skipstep3 out of the explicit walk code
Siddharth Agarwal <sid0@fb.com>
parents:
19171
diff
changeset
|
911 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
|
912 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
|
913 |
6826
eca20fee0728
dirstate.walk: pull directory scanning into top-level loop
Matt Mackall <mpm@selenic.com>
parents:
6825
diff
changeset
|
914 # 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
|
915 def traverse(work, alreadynormed): |
24559
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
916 wadd = work.append |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
917 while work: |
24560
b38bcf18993c
dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents:
24559
diff
changeset
|
918 nd = work.pop() |
38994
a3cabe9415e1
dirstate: use visitchildrenset in traverse
Kyle Lippincott <spectral@google.com>
parents:
36998
diff
changeset
|
919 visitentries = match.visitchildrenset(nd) |
a3cabe9415e1
dirstate: use visitchildrenset in traverse
Kyle Lippincott <spectral@google.com>
parents:
36998
diff
changeset
|
920 if not visitentries: |
32226
8f1a2b848b52
dirstate: optimize walk() by using match.visitdir()
Martin von Zweigbergk <martinvonz@google.com>
parents:
31553
diff
changeset
|
921 continue |
38994
a3cabe9415e1
dirstate: use visitchildrenset in traverse
Kyle Lippincott <spectral@google.com>
parents:
36998
diff
changeset
|
922 if visitentries == 'this' or visitentries == 'all': |
a3cabe9415e1
dirstate: use visitchildrenset in traverse
Kyle Lippincott <spectral@google.com>
parents:
36998
diff
changeset
|
923 visitentries = None |
24559
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
924 skip = None |
42363
27d6956d386b
match: use '' instead of '.' for root directory (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
42362
diff
changeset
|
925 if nd != '': |
24559
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
926 skip = '.hg' |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
927 try: |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
928 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
|
929 except OSError as inst: |
24559
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
930 if inst.errno in (errno.EACCES, errno.ENOENT): |
34040
d5b2beca16c0
python3: wrap all uses of <exception>.strerror with strtolocal
Augie Fackler <raf@durin42.com>
parents:
33999
diff
changeset
|
931 match.bad(self.pathto(nd), |
d5b2beca16c0
python3: wrap all uses of <exception>.strerror with strtolocal
Augie Fackler <raf@durin42.com>
parents:
33999
diff
changeset
|
932 encoding.strtolocal(inst.strerror)) |
24559
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
933 continue |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
934 raise |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
935 for f, kind, st in entries: |
39288
27946fca8a05
match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents:
38997
diff
changeset
|
936 # Some matchers may return files in the visitentries set, |
27946fca8a05
match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents:
38997
diff
changeset
|
937 # instead of 'this', if the matcher explicitly mentions them |
27946fca8a05
match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents:
38997
diff
changeset
|
938 # 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:
38997
diff
changeset
|
939 # make any hard assumptions about file-or-directory below |
27946fca8a05
match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents:
38997
diff
changeset
|
940 # based on the presence of `f` in visitentries. If |
27946fca8a05
match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents:
38997
diff
changeset
|
941 # visitchildrenset returned a set, we can always skip the |
27946fca8a05
match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents:
38997
diff
changeset
|
942 # entries *not* in the set it provided regardless of whether |
27946fca8a05
match: document that visitchildrenset might return files
Kyle Lippincott <spectral@google.com>
parents:
38997
diff
changeset
|
943 # they're actually a file or a directory. |
38994
a3cabe9415e1
dirstate: use visitchildrenset in traverse
Kyle Lippincott <spectral@google.com>
parents:
36998
diff
changeset
|
944 if visitentries and f not in visitentries: |
a3cabe9415e1
dirstate: use visitchildrenset in traverse
Kyle Lippincott <spectral@google.com>
parents:
36998
diff
changeset
|
945 continue |
24559
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
946 if normalizefile: |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
947 # 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
|
948 # 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
|
949 # dmap -- therefore normalizefile is enough |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
950 nf = normalizefile(nd and (nd + "/" + f) or f, True, |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
951 True) |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
952 else: |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
953 nf = nd and (nd + "/" + f) or f |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
954 if nf not in results: |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
955 if kind == dirkind: |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
956 if not ignore(nf): |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
957 if matchtdir: |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
958 matchtdir(nf) |
24560
b38bcf18993c
dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents:
24559
diff
changeset
|
959 wadd(nf) |
24559
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
960 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
|
961 results[nf] = None |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
962 elif kind == regkind or kind == lnkkind: |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
963 if nf in dmap: |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
964 if matchalways or matchfn(nf): |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
965 results[nf] = st |
24560
b38bcf18993c
dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents:
24559
diff
changeset
|
966 elif ((matchalways or matchfn(nf)) |
b38bcf18993c
dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents:
24559
diff
changeset
|
967 and not ignore(nf)): |
b38bcf18993c
dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents:
24559
diff
changeset
|
968 # 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
|
969 if not alreadynormed: |
b38bcf18993c
dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents:
24559
diff
changeset
|
970 nf = normalize(nf, False, True) |
24559
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
971 results[nf] = st |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
972 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
|
973 results[nf] = None |
24559
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
974 |
24560
b38bcf18993c
dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents:
24559
diff
changeset
|
975 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
|
976 # 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
|
977 # expensive directory normalization |
b38bcf18993c
dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents:
24559
diff
changeset
|
978 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
|
979 traverse([d], alreadynormed) |
536 | 980 |
18812
1c40526da52a
dirstate.walk: remove subrepo and .hg from results before step 3
Siddharth Agarwal <sid0@fb.com>
parents:
18792
diff
changeset
|
981 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
|
982 del results[s] |
1c40526da52a
dirstate.walk: remove subrepo and .hg from results before step 3
Siddharth Agarwal <sid0@fb.com>
parents:
18792
diff
changeset
|
983 del results['.hg'] |
1c40526da52a
dirstate.walk: remove subrepo and .hg from results before step 3
Siddharth Agarwal <sid0@fb.com>
parents:
18792
diff
changeset
|
984 |
21115
1b6e37f44250
dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents:
21026
diff
changeset
|
985 # 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
|
986 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
|
987 # 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
|
988 # 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
|
989 # 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
|
990 if not results and matchalways: |
31431
2e38a88bbc6c
dirstate: use list comprehension to get a list of keys
Pulkit Goyal <7895pulkit@gmail.com>
parents:
31287
diff
changeset
|
991 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
|
992 else: |
a18919de61e5
dirstate.walk: fast path none-seen + match-always case for step 3
Siddharth Agarwal <sid0@fb.com>
parents:
18814
diff
changeset
|
993 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
|
994 visit.sort() |
a18919de61e5
dirstate.walk: fast path none-seen + match-always case for step 3
Siddharth Agarwal <sid0@fb.com>
parents:
18814
diff
changeset
|
995 |
18625
2cbd27f4f3c4
dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents:
18567
diff
changeset
|
996 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
|
997 # 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
|
998 # 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
|
999 # 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
|
1000 # The rest must thus be ignored or under a symlink. |
33647
377e8ddaebef
pathauditor: disable cache of audited paths by default (issue5628)
Yuya Nishihara <yuya@tcha.org>
parents:
33440
diff
changeset
|
1001 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
|
1002 |
2cbd27f4f3c4
dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents:
18567
diff
changeset
|
1003 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
|
1004 # 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
|
1005 # 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
|
1006 # 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
|
1007 # on disk. |
24632 | 1008 if (normalizefile and |
1009 normalizefile(nf, True, True) in results): | |
24621
1784ca148392
dirstate.walk: don't report same file stat multiple times
Martin von Zweigbergk <martinvonz@google.com>
parents:
24537
diff
changeset
|
1010 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
|
1011 # 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
|
1012 # 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
|
1013 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
|
1014 try: |
05cf40f9b0ec
dirstate: fix generator/list error when using python 2.7
Durham Goode <durham@fb.com>
parents:
18653
diff
changeset
|
1015 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
|
1016 # 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
|
1017 except OSError: |
05cf40f9b0ec
dirstate: fix generator/list error when using python 2.7
Durham Goode <durham@fb.com>
parents:
18653
diff
changeset
|
1018 # file doesn't exist |
05cf40f9b0ec
dirstate: fix generator/list error when using python 2.7
Durham Goode <durham@fb.com>
parents:
18653
diff
changeset
|
1019 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
|
1020 else: |
2cbd27f4f3c4
dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents:
18567
diff
changeset
|
1021 # 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
|
1022 # 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
|
1023 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
|
1024 else: |
2cbd27f4f3c4
dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents:
18567
diff
changeset
|
1025 # 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
|
1026 # so stat and check everything we missed. |
31514
4d1dd9cf0dca
dirstate: use future-proof next(iter) instead of iter.next
Augie Fackler <augie@google.com>
parents:
31431
diff
changeset
|
1027 iv = iter(visit) |
26984
af2663680e95
dirstate: back out 502b56a9e897
Bryan O'Sullivan <bos@serpentine.com>
parents:
26887
diff
changeset
|
1028 for st in util.statfiles([join(i) for i in visit]): |
31514
4d1dd9cf0dca
dirstate: use future-proof next(iter) instead of iter.next
Augie Fackler <augie@google.com>
parents:
31431
diff
changeset
|
1029 results[next(iv)] = st |
6829
fec1da46006e
dirstate.walk: build a dict rather than yield
Matt Mackall <mpm@selenic.com>
parents:
6828
diff
changeset
|
1030 return results |
669
8aa2a282eda4
.hgignore speedups patch incorporating Matt's feedback.
mwilli2@localhost.localdomain
parents:
667
diff
changeset
|
1031 |
10176
24ce8f0c0a39
dirstate: don't check state of subrepo directories
Augie Fackler <durin42@gmail.com>
parents:
10145
diff
changeset
|
1032 def status(self, match, subrepos, ignored, clean, unknown): |
9518
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
1033 '''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
|
1034 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
|
1035 scmutil.status and: |
9518
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
1036 |
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
1037 unsure: |
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
1038 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
|
1039 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
|
1040 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
|
1041 status.modified: |
9518
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
1042 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
|
1043 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
|
1044 status.clean: |
9518
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
1045 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
|
1046 dirstate was written |
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
1047 ''' |
6753
ed5ffb2c12f3
repo.status: eliminate list_
Matt Mackall <mpm@selenic.com>
parents:
6750
diff
changeset
|
1048 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
|
1049 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
|
1050 removed, deleted, clean = [], [], [] |
723 | 1051 |
5003
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
1052 dmap = self._map |
34935
ffeea2406276
dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents:
34934
diff
changeset
|
1053 dmap.preload() |
ffeea2406276
dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents:
34934
diff
changeset
|
1054 dcontains = dmap.__contains__ |
ffeea2406276
dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents:
34934
diff
changeset
|
1055 dget = dmap.__getitem__ |
9518
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
1056 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
|
1057 madd = modified.append |
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
1058 aadd = added.append |
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
1059 uadd = unknown.append |
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
1060 iadd = ignored.append |
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
1061 radd = removed.append |
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
1062 dadd = deleted.append |
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
1063 cadd = clean.append |
18034
1a570f04de07
dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents:
18032
diff
changeset
|
1064 mexact = match.exact |
1a570f04de07
dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents:
18032
diff
changeset
|
1065 dirignore = self._dirignore |
1a570f04de07
dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents:
18032
diff
changeset
|
1066 checkexec = self._checkexec |
34343
0865d25e8a8a
dirstate: move _copymap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34342
diff
changeset
|
1067 copymap = self._map.copymap |
18034
1a570f04de07
dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents:
18032
diff
changeset
|
1068 lastnormaltime = self._lastnormaltime |
5003
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
1069 |
19191
ab9de1e8fc36
dirstate.status: avoid full walks when possible
Siddharth Agarwal <sid0@fb.com>
parents:
19190
diff
changeset
|
1070 # 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
|
1071 # - we're listing all clean files, or |
ab9de1e8fc36
dirstate.status: avoid full walks when possible
Siddharth Agarwal <sid0@fb.com>
parents:
19190
diff
changeset
|
1072 # - 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
|
1073 # 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
|
1074 full = listclean or match.traversedir is not None |
ab9de1e8fc36
dirstate.status: avoid full walks when possible
Siddharth Agarwal <sid0@fb.com>
parents:
19190
diff
changeset
|
1075 for fn, st in self.walk(match, subrepos, listunknown, listignored, |
ab9de1e8fc36
dirstate.status: avoid full walks when possible
Siddharth Agarwal <sid0@fb.com>
parents:
19190
diff
changeset
|
1076 full=full).iteritems(): |
34935
ffeea2406276
dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents:
34934
diff
changeset
|
1077 if not dcontains(fn): |
18034
1a570f04de07
dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents:
18032
diff
changeset
|
1078 if (listignored or mexact(fn)) and dirignore(fn): |
6753
ed5ffb2c12f3
repo.status: eliminate list_
Matt Mackall <mpm@selenic.com>
parents:
6750
diff
changeset
|
1079 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
|
1080 iadd(fn) |
19910
601944f41257
dirstate.status: return explicit unknown files even when not asked
Siddharth Agarwal <sid0@fb.com>
parents:
19651
diff
changeset
|
1081 else: |
5003
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
1082 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
|
1083 continue |
6591
eda3fd322a7f
dirstate: minor status cleanups
Matt Mackall <mpm@selenic.com>
parents:
6590
diff
changeset
|
1084 |
21810
4b2ebd3187a1
dirstate.status: assign members one by one instead of unpacking the tuple
Siddharth Agarwal <sid0@fb.com>
parents:
21809
diff
changeset
|
1085 # 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
|
1086 # 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
|
1087 # 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
|
1088 # 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
|
1089 # 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
|
1090 # 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
|
1091 # 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
|
1092 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
|
1093 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
|
1094 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
|
1095 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
|
1096 time = t[3] |
6591
eda3fd322a7f
dirstate: minor status cleanups
Matt Mackall <mpm@selenic.com>
parents:
6590
diff
changeset
|
1097 |
6818
6e93fbd847ef
dirstate.walk: eliminate src from yield
Matt Mackall <mpm@selenic.com>
parents:
6811
diff
changeset
|
1098 if not st and state in "nma": |
6e93fbd847ef
dirstate.walk: eliminate src from yield
Matt Mackall <mpm@selenic.com>
parents:
6811
diff
changeset
|
1099 dadd(fn) |
6e93fbd847ef
dirstate.walk: eliminate src from yield
Matt Mackall <mpm@selenic.com>
parents:
6811
diff
changeset
|
1100 elif state == 'n': |
6257
bfd49ce0db64
dirstate: ignore mode changes if the fs does not supports the exec bit
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
6212
diff
changeset
|
1101 if (size >= 0 and |
17733
3c775c5a6c03
dirstate: handle large dates and times with masking (issue2608)
Matt Mackall <mpm@selenic.com>
parents:
17197
diff
changeset
|
1102 ((size != st.st_size and size != st.st_size & _rangemask) |
25658
e93036747902
global: mass rewrite to use modern octal syntax
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25585
diff
changeset
|
1103 or ((mode ^ st.st_mode) & 0o100 and checkexec)) |
10968
7a0d096e221e
dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10935
diff
changeset
|
1104 or size == -2 # other parent |
18034
1a570f04de07
dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents:
18032
diff
changeset
|
1105 or fn in copymap): |
5003
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
1106 madd(fn) |
36789
ffa3026d4196
cleanup: use stat_result[stat.ST_MTIME] instead of stat_result.st_mtime
Augie Fackler <augie@google.com>
parents:
36651
diff
changeset
|
1107 elif (time != st[stat.ST_MTIME] |
ffa3026d4196
cleanup: use stat_result[stat.ST_MTIME] instead of stat_result.st_mtime
Augie Fackler <augie@google.com>
parents:
36651
diff
changeset
|
1108 and time != st[stat.ST_MTIME] & _rangemask): |
5003
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
1109 ladd(fn) |
36789
ffa3026d4196
cleanup: use stat_result[stat.ST_MTIME] instead of stat_result.st_mtime
Augie Fackler <augie@google.com>
parents:
36651
diff
changeset
|
1110 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
|
1111 # 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
|
1112 # 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
|
1113 # This can happen if we quickly do multiple commits. |
13763
7a73c406c0fd
dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents:
13754
diff
changeset
|
1114 # 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
|
1115 ladd(fn) |
6753
ed5ffb2c12f3
repo.status: eliminate list_
Matt Mackall <mpm@selenic.com>
parents:
6750
diff
changeset
|
1116 elif listclean: |
5003
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
1117 cadd(fn) |
6590
9f80e062d71c
status: rename type_ to state
Matt Mackall <mpm@selenic.com>
parents:
6589
diff
changeset
|
1118 elif state == 'm': |
5003
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
1119 madd(fn) |
6590
9f80e062d71c
status: rename type_ to state
Matt Mackall <mpm@selenic.com>
parents:
6589
diff
changeset
|
1120 elif state == 'a': |
5003
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
1121 aadd(fn) |
6590
9f80e062d71c
status: rename type_ to state
Matt Mackall <mpm@selenic.com>
parents:
6589
diff
changeset
|
1122 elif state == 'r': |
5003
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
1123 radd(fn) |
1183 | 1124 |
22913
cb4449921a1d
status: create class for status lists
Martin von Zweigbergk <martinvonz@gmail.com>
parents:
22911
diff
changeset
|
1125 return (lookup, scmutil.status(modified, added, removed, deleted, |
cb4449921a1d
status: create class for status lists
Martin von Zweigbergk <martinvonz@gmail.com>
parents:
22911
diff
changeset
|
1126 unknown, ignored, clean)) |
21984
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
1127 |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
1128 def matches(self, match): |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
1129 ''' |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
1130 return files in the dirstate (in whatever state) filtered by match |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
1131 ''' |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
1132 dmap = self._map |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
1133 if match.always(): |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
1134 return dmap.keys() |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
1135 files = match.files() |
24448
55c449345b10
match: add isexact() method to hide internals
Martin von Zweigbergk <martinvonz@google.com>
parents:
24212
diff
changeset
|
1136 if match.isexact(): |
21984
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
1137 # 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
|
1138 # much smaller than dmap |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
1139 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
|
1140 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
|
1141 # 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
|
1142 # that |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
1143 return list(files) |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
1144 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
|
1145 |
26746
3c1d297fe929
dirstateguard: remove layering violation around saving/restoring backup
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26635
diff
changeset
|
1146 def _actualfilename(self, tr): |
3c1d297fe929
dirstateguard: remove layering violation around saving/restoring backup
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26635
diff
changeset
|
1147 if tr: |
26633
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1148 return self._pendingfilename |
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1149 else: |
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1150 return self._filename |
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1151 |
33440
ec306bc6915b
dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents:
33373
diff
changeset
|
1152 def savebackup(self, tr, backupname): |
ec306bc6915b
dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents:
33373
diff
changeset
|
1153 '''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
|
1154 filename = self._actualfilename(tr) |
33440
ec306bc6915b
dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents:
33373
diff
changeset
|
1155 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
|
1156 |
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1157 # 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
|
1158 # 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
|
1159 # output file will be used to create backup of dirstate at this point. |
31218
fc57a8b95f1b
dirstate: avoid unnecessary load+dump during backup
Jun Wu <quark@fb.com>
parents:
31217
diff
changeset
|
1160 if self._dirty or not self._opener.exists(filename): |
fc57a8b95f1b
dirstate: avoid unnecessary load+dump during backup
Jun Wu <quark@fb.com>
parents:
31217
diff
changeset
|
1161 self._writedirstate(self._opener(filename, "w", atomictemp=True, |
fc57a8b95f1b
dirstate: avoid unnecessary load+dump during backup
Jun Wu <quark@fb.com>
parents:
31217
diff
changeset
|
1162 checkambig=True)) |
26633
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1163 |
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1164 if tr: |
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1165 # 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
|
1166 # 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
|
1167 # changed after this |
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1168 tr.addfilegenerator('dirstate', (self._filename,), |
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1169 self._writedirstate, location='plain') |
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1170 |
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1171 # 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
|
1172 # 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
|
1173 # end of this transaction |
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1174 tr.registertmp(filename, location='plain') |
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1175 |
31553 | 1176 self._opener.tryunlink(backupname) |
31217
1ef37b16b8e8
dirstate: try to use hardlink to backup dirstate
Jun Wu <quark@fb.com>
parents:
31216
diff
changeset
|
1177 # hardlink backup is okay because _writedirstate is always called |
1ef37b16b8e8
dirstate: try to use hardlink to backup dirstate
Jun Wu <quark@fb.com>
parents:
31216
diff
changeset
|
1178 # with an "atomictemp=True" file. |
1ef37b16b8e8
dirstate: try to use hardlink to backup dirstate
Jun Wu <quark@fb.com>
parents:
31216
diff
changeset
|
1179 util.copyfile(self._opener.join(filename), |
1ef37b16b8e8
dirstate: try to use hardlink to backup dirstate
Jun Wu <quark@fb.com>
parents:
31216
diff
changeset
|
1180 self._opener.join(backupname), hardlink=True) |
26632
59b5e8844eb0
dirstate: move code paths for backup from dirstateguard to dirstate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26630
diff
changeset
|
1181 |
33440
ec306bc6915b
dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents:
33373
diff
changeset
|
1182 def restorebackup(self, tr, backupname): |
ec306bc6915b
dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents:
33373
diff
changeset
|
1183 '''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
|
1184 # 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
|
1185 # 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
|
1186 self.invalidate() |
26746
3c1d297fe929
dirstateguard: remove layering violation around saving/restoring backup
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26635
diff
changeset
|
1187 filename = self._actualfilename(tr) |
34940
c2b30348930f
dirstate: clean up when restoring identical backups
Mark Thomas <mbthomas@fb.com>
parents:
34935
diff
changeset
|
1188 o = self._opener |
c2b30348930f
dirstate: clean up when restoring identical backups
Mark Thomas <mbthomas@fb.com>
parents:
34935
diff
changeset
|
1189 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
|
1190 o.unlink(backupname) |
c2b30348930f
dirstate: clean up when restoring identical backups
Mark Thomas <mbthomas@fb.com>
parents:
34935
diff
changeset
|
1191 else: |
c2b30348930f
dirstate: clean up when restoring identical backups
Mark Thomas <mbthomas@fb.com>
parents:
34935
diff
changeset
|
1192 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
|
1193 |
33440
ec306bc6915b
dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents:
33373
diff
changeset
|
1194 def clearbackup(self, tr, backupname): |
ec306bc6915b
dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents:
33373
diff
changeset
|
1195 '''Clear backup file''' |
ec306bc6915b
dirstate: update backup functions to take full backup filename
Adam Simpkins <simpkins@fb.com>
parents:
33373
diff
changeset
|
1196 self._opener.unlink(backupname) |
34339
b36881c68569
dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents:
34200
diff
changeset
|
1197 |
b36881c68569
dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents:
34200
diff
changeset
|
1198 class dirstatemap(object): |
35101
a052022639cc
dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents:
35055
diff
changeset
|
1199 """Map encapsulating the dirstate's contents. |
a052022639cc
dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents:
35055
diff
changeset
|
1200 |
a052022639cc
dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents:
35055
diff
changeset
|
1201 The dirstate contains the following state: |
a052022639cc
dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents:
35055
diff
changeset
|
1202 |
a052022639cc
dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents:
35055
diff
changeset
|
1203 - `identity` is the identity of the dirstate file, which can be used to |
a052022639cc
dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents:
35055
diff
changeset
|
1204 detect when changes have occurred to the dirstate file. |
a052022639cc
dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents:
35055
diff
changeset
|
1205 |
a052022639cc
dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents:
35055
diff
changeset
|
1206 - `parents` is a pair containing the parents of the working copy. The |
a052022639cc
dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents:
35055
diff
changeset
|
1207 parents are updated by calling `setparents`. |
a052022639cc
dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents:
35055
diff
changeset
|
1208 |
a052022639cc
dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents:
35055
diff
changeset
|
1209 - the state map maps filenames to tuples of (state, mode, size, mtime), |
a052022639cc
dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents:
35055
diff
changeset
|
1210 where state is a single character representing 'normal', 'added', |
35102
853b7c41d19c
dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents:
35101
diff
changeset
|
1211 '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:
35101
diff
changeset
|
1212 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:
35101
diff
changeset
|
1213 `dropfile` methods. |
35101
a052022639cc
dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents:
35055
diff
changeset
|
1214 |
a052022639cc
dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents:
35055
diff
changeset
|
1215 - `copymap` maps destination filenames to their source filename. |
a052022639cc
dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents:
35055
diff
changeset
|
1216 |
a052022639cc
dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents:
35055
diff
changeset
|
1217 The dirstate also provides the following views onto the state: |
a052022639cc
dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents:
35055
diff
changeset
|
1218 |
a052022639cc
dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents:
35055
diff
changeset
|
1219 - `nonnormalset` is a set of the filenames that have state other |
a052022639cc
dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents:
35055
diff
changeset
|
1220 than 'normal', or are normal but have an mtime of -1 ('normallookup'). |
a052022639cc
dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents:
35055
diff
changeset
|
1221 |
a052022639cc
dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents:
35055
diff
changeset
|
1222 - `otherparentset` is a set of the filenames that are marked as coming |
a052022639cc
dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents:
35055
diff
changeset
|
1223 from the second parent when the dirstate is currently being merged. |
a052022639cc
dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents:
35055
diff
changeset
|
1224 |
a052022639cc
dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents:
35055
diff
changeset
|
1225 - `filefoldmap` is a dict mapping normalized filenames to the denormalized |
a052022639cc
dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents:
35055
diff
changeset
|
1226 form that they appear as in the dirstate. |
a052022639cc
dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents:
35055
diff
changeset
|
1227 |
a052022639cc
dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents:
35055
diff
changeset
|
1228 - `dirfoldmap` is a dict mapping normalized directory names to the |
a052022639cc
dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents:
35055
diff
changeset
|
1229 denormalized form that they appear as in the dirstate. |
a052022639cc
dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents:
35055
diff
changeset
|
1230 """ |
a052022639cc
dirstate: document dirstatemap interface
Mark Thomas <mbthomas@fb.com>
parents:
35055
diff
changeset
|
1231 |
34344
c36c3fa7d35b
dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents:
34343
diff
changeset
|
1232 def __init__(self, ui, opener, root): |
c36c3fa7d35b
dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents:
34343
diff
changeset
|
1233 self._ui = ui |
c36c3fa7d35b
dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents:
34343
diff
changeset
|
1234 self._opener = opener |
c36c3fa7d35b
dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents:
34343
diff
changeset
|
1235 self._root = root |
c36c3fa7d35b
dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents:
34343
diff
changeset
|
1236 self._filename = 'dirstate' |
c36c3fa7d35b
dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents:
34343
diff
changeset
|
1237 |
34346
ec769bba34d3
dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents:
34345
diff
changeset
|
1238 self._parents = None |
ec769bba34d3
dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents:
34345
diff
changeset
|
1239 self._dirtyparents = False |
34339
b36881c68569
dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents:
34200
diff
changeset
|
1240 |
34344
c36c3fa7d35b
dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents:
34343
diff
changeset
|
1241 # for consistent view between _pl() and _read() invocations |
c36c3fa7d35b
dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents:
34343
diff
changeset
|
1242 self._pendingmode = None |
c36c3fa7d35b
dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents:
34343
diff
changeset
|
1243 |
34934
6e66033f91cc
dirstate: avoid reading the map when possible (issue5713) (issue5717)
Durham Goode <durham@fb.com>
parents:
34933
diff
changeset
|
1244 @propertycache |
6e66033f91cc
dirstate: avoid reading the map when possible (issue5713) (issue5717)
Durham Goode <durham@fb.com>
parents:
34933
diff
changeset
|
1245 def _map(self): |
6e66033f91cc
dirstate: avoid reading the map when possible (issue5713) (issue5717)
Durham Goode <durham@fb.com>
parents:
34933
diff
changeset
|
1246 self._map = {} |
6e66033f91cc
dirstate: avoid reading the map when possible (issue5713) (issue5717)
Durham Goode <durham@fb.com>
parents:
34933
diff
changeset
|
1247 self.read() |
6e66033f91cc
dirstate: avoid reading the map when possible (issue5713) (issue5717)
Durham Goode <durham@fb.com>
parents:
34933
diff
changeset
|
1248 return self._map |
6e66033f91cc
dirstate: avoid reading the map when possible (issue5713) (issue5717)
Durham Goode <durham@fb.com>
parents:
34933
diff
changeset
|
1249 |
6e66033f91cc
dirstate: avoid reading the map when possible (issue5713) (issue5717)
Durham Goode <durham@fb.com>
parents:
34933
diff
changeset
|
1250 @propertycache |
6e66033f91cc
dirstate: avoid reading the map when possible (issue5713) (issue5717)
Durham Goode <durham@fb.com>
parents:
34933
diff
changeset
|
1251 def copymap(self): |
6e66033f91cc
dirstate: avoid reading the map when possible (issue5713) (issue5717)
Durham Goode <durham@fb.com>
parents:
34933
diff
changeset
|
1252 self.copymap = {} |
6e66033f91cc
dirstate: avoid reading the map when possible (issue5713) (issue5717)
Durham Goode <durham@fb.com>
parents:
34933
diff
changeset
|
1253 self._map |
6e66033f91cc
dirstate: avoid reading the map when possible (issue5713) (issue5717)
Durham Goode <durham@fb.com>
parents:
34933
diff
changeset
|
1254 return self.copymap |
6e66033f91cc
dirstate: avoid reading the map when possible (issue5713) (issue5717)
Durham Goode <durham@fb.com>
parents:
34933
diff
changeset
|
1255 |
34933
0217f75b6e59
dirstate: move clear onto dirstatemap class
Durham Goode <durham@fb.com>
parents:
34678
diff
changeset
|
1256 def clear(self): |
34935
ffeea2406276
dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents:
34934
diff
changeset
|
1257 self._map.clear() |
ffeea2406276
dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents:
34934
diff
changeset
|
1258 self.copymap.clear() |
34933
0217f75b6e59
dirstate: move clear onto dirstatemap class
Durham Goode <durham@fb.com>
parents:
34678
diff
changeset
|
1259 self.setparents(nullid, nullid) |
35107
61888bd0b300
dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents:
35106
diff
changeset
|
1260 util.clearcachedproperty(self, "_dirs") |
61888bd0b300
dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents:
35106
diff
changeset
|
1261 util.clearcachedproperty(self, "_alldirs") |
35054
ecede5263adb
dirstate: clear map cached properties when clearing the map
Mark Thomas <mbthomas@fb.com>
parents:
34940
diff
changeset
|
1262 util.clearcachedproperty(self, "filefoldmap") |
ecede5263adb
dirstate: clear map cached properties when clearing the map
Mark Thomas <mbthomas@fb.com>
parents:
34940
diff
changeset
|
1263 util.clearcachedproperty(self, "dirfoldmap") |
ecede5263adb
dirstate: clear map cached properties when clearing the map
Mark Thomas <mbthomas@fb.com>
parents:
34940
diff
changeset
|
1264 util.clearcachedproperty(self, "nonnormalset") |
ecede5263adb
dirstate: clear map cached properties when clearing the map
Mark Thomas <mbthomas@fb.com>
parents:
34940
diff
changeset
|
1265 util.clearcachedproperty(self, "otherparentset") |
34933
0217f75b6e59
dirstate: move clear onto dirstatemap class
Durham Goode <durham@fb.com>
parents:
34678
diff
changeset
|
1266 |
35918
6e7fae8f1c6c
contrib: fix dirstatenonnormalcheck to work in Python 3
Augie Fackler <augie@google.com>
parents:
35875
diff
changeset
|
1267 def items(self): |
34339
b36881c68569
dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents:
34200
diff
changeset
|
1268 return self._map.iteritems() |
b36881c68569
dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents:
34200
diff
changeset
|
1269 |
35918
6e7fae8f1c6c
contrib: fix dirstatenonnormalcheck to work in Python 3
Augie Fackler <augie@google.com>
parents:
35875
diff
changeset
|
1270 # forward for python2,3 compat |
6e7fae8f1c6c
contrib: fix dirstatenonnormalcheck to work in Python 3
Augie Fackler <augie@google.com>
parents:
35875
diff
changeset
|
1271 iteritems = items |
6e7fae8f1c6c
contrib: fix dirstatenonnormalcheck to work in Python 3
Augie Fackler <augie@google.com>
parents:
35875
diff
changeset
|
1272 |
34409
7d2f71b7bc31
dirstate: implement __len__ on dirstatemap (issue5695)
Simon Whitaker <swhitaker@fb.com>
parents:
34346
diff
changeset
|
1273 def __len__(self): |
7d2f71b7bc31
dirstate: implement __len__ on dirstatemap (issue5695)
Simon Whitaker <swhitaker@fb.com>
parents:
34346
diff
changeset
|
1274 return len(self._map) |
7d2f71b7bc31
dirstate: implement __len__ on dirstatemap (issue5695)
Simon Whitaker <swhitaker@fb.com>
parents:
34346
diff
changeset
|
1275 |
34339
b36881c68569
dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents:
34200
diff
changeset
|
1276 def __iter__(self): |
b36881c68569
dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents:
34200
diff
changeset
|
1277 return iter(self._map) |
b36881c68569
dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents:
34200
diff
changeset
|
1278 |
b36881c68569
dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents:
34200
diff
changeset
|
1279 def get(self, key, default=None): |
b36881c68569
dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents:
34200
diff
changeset
|
1280 return self._map.get(key, default) |
b36881c68569
dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents:
34200
diff
changeset
|
1281 |
b36881c68569
dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents:
34200
diff
changeset
|
1282 def __contains__(self, key): |
b36881c68569
dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents:
34200
diff
changeset
|
1283 return key in self._map |
b36881c68569
dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents:
34200
diff
changeset
|
1284 |
b36881c68569
dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents:
34200
diff
changeset
|
1285 def __getitem__(self, key): |
b36881c68569
dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents:
34200
diff
changeset
|
1286 return self._map[key] |
b36881c68569
dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents:
34200
diff
changeset
|
1287 |
b36881c68569
dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents:
34200
diff
changeset
|
1288 def keys(self): |
b36881c68569
dirstate: create new dirstatemap class
Durham Goode <durham@fb.com>
parents:
34200
diff
changeset
|
1289 return self._map.keys() |
34340
4ac04418ce66
dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents:
34339
diff
changeset
|
1290 |
34935
ffeea2406276
dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents:
34934
diff
changeset
|
1291 def preload(self): |
ffeea2406276
dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents:
34934
diff
changeset
|
1292 """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
|
1293 self._map |
ffeea2406276
dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents:
34934
diff
changeset
|
1294 |
35104
a947cf872799
dirstate: move management of the dirstate dirs into the dirstatemap
Mark Thomas <mbthomas@fb.com>
parents:
35103
diff
changeset
|
1295 def addfile(self, f, oldstate, state, mode, size, mtime): |
35102
853b7c41d19c
dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents:
35101
diff
changeset
|
1296 """Add a tracked file to the dirstate.""" |
35875
bf367a93f000
dirstate: use native strings when peeking in __dict__
Augie Fackler <augie@google.com>
parents:
35109
diff
changeset
|
1297 if oldstate in "?r" and r"_dirs" in self.__dict__: |
35107
61888bd0b300
dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents:
35106
diff
changeset
|
1298 self._dirs.addpath(f) |
35875
bf367a93f000
dirstate: use native strings when peeking in __dict__
Augie Fackler <augie@google.com>
parents:
35109
diff
changeset
|
1299 if oldstate == "?" and r"_alldirs" in self.__dict__: |
35107
61888bd0b300
dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents:
35106
diff
changeset
|
1300 self._alldirs.addpath(f) |
35102
853b7c41d19c
dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents:
35101
diff
changeset
|
1301 self._map[f] = dirstatetuple(state, mode, size, mtime) |
35103
19b75779b7c3
dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents:
35102
diff
changeset
|
1302 if state != 'n' or mtime == -1: |
19b75779b7c3
dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents:
35102
diff
changeset
|
1303 self.nonnormalset.add(f) |
19b75779b7c3
dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents:
35102
diff
changeset
|
1304 if size == -2: |
19b75779b7c3
dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents:
35102
diff
changeset
|
1305 self.otherparentset.add(f) |
35102
853b7c41d19c
dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents:
35101
diff
changeset
|
1306 |
35104
a947cf872799
dirstate: move management of the dirstate dirs into the dirstatemap
Mark Thomas <mbthomas@fb.com>
parents:
35103
diff
changeset
|
1307 def removefile(self, f, oldstate, size): |
35102
853b7c41d19c
dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents:
35101
diff
changeset
|
1308 """ |
853b7c41d19c
dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents:
35101
diff
changeset
|
1309 Mark a file as removed in the dirstate. |
853b7c41d19c
dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents:
35101
diff
changeset
|
1310 |
853b7c41d19c
dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents:
35101
diff
changeset
|
1311 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:
35101
diff
changeset
|
1312 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:
35101
diff
changeset
|
1313 to be more explicit about what that state is. |
853b7c41d19c
dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents:
35101
diff
changeset
|
1314 """ |
35875
bf367a93f000
dirstate: use native strings when peeking in __dict__
Augie Fackler <augie@google.com>
parents:
35109
diff
changeset
|
1315 if oldstate not in "?r" and r"_dirs" in self.__dict__: |
35107
61888bd0b300
dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents:
35106
diff
changeset
|
1316 self._dirs.delpath(f) |
35875
bf367a93f000
dirstate: use native strings when peeking in __dict__
Augie Fackler <augie@google.com>
parents:
35109
diff
changeset
|
1317 if oldstate == "?" and r"_alldirs" in self.__dict__: |
35107
61888bd0b300
dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents:
35106
diff
changeset
|
1318 self._alldirs.addpath(f) |
35875
bf367a93f000
dirstate: use native strings when peeking in __dict__
Augie Fackler <augie@google.com>
parents:
35109
diff
changeset
|
1319 if r"filefoldmap" in self.__dict__: |
35105
e6c64744781f
dirstate: move dropping of folded filenames into the dirstate map
Mark Thomas <mbthomas@fb.com>
parents:
35104
diff
changeset
|
1320 normed = util.normcase(f) |
e6c64744781f
dirstate: move dropping of folded filenames into the dirstate map
Mark Thomas <mbthomas@fb.com>
parents:
35104
diff
changeset
|
1321 self.filefoldmap.pop(normed, None) |
35102
853b7c41d19c
dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents:
35101
diff
changeset
|
1322 self._map[f] = dirstatetuple('r', 0, size, 0) |
35103
19b75779b7c3
dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents:
35102
diff
changeset
|
1323 self.nonnormalset.add(f) |
35102
853b7c41d19c
dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents:
35101
diff
changeset
|
1324 |
35104
a947cf872799
dirstate: move management of the dirstate dirs into the dirstatemap
Mark Thomas <mbthomas@fb.com>
parents:
35103
diff
changeset
|
1325 def dropfile(self, f, oldstate): |
35102
853b7c41d19c
dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents:
35101
diff
changeset
|
1326 """ |
853b7c41d19c
dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents:
35101
diff
changeset
|
1327 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:
35101
diff
changeset
|
1328 previously recorded. |
853b7c41d19c
dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents:
35101
diff
changeset
|
1329 """ |
35103
19b75779b7c3
dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents:
35102
diff
changeset
|
1330 exists = self._map.pop(f, None) is not None |
35104
a947cf872799
dirstate: move management of the dirstate dirs into the dirstatemap
Mark Thomas <mbthomas@fb.com>
parents:
35103
diff
changeset
|
1331 if exists: |
35875
bf367a93f000
dirstate: use native strings when peeking in __dict__
Augie Fackler <augie@google.com>
parents:
35109
diff
changeset
|
1332 if oldstate != "r" and r"_dirs" in self.__dict__: |
35107
61888bd0b300
dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents:
35106
diff
changeset
|
1333 self._dirs.delpath(f) |
35875
bf367a93f000
dirstate: use native strings when peeking in __dict__
Augie Fackler <augie@google.com>
parents:
35109
diff
changeset
|
1334 if r"_alldirs" in self.__dict__: |
35107
61888bd0b300
dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents:
35106
diff
changeset
|
1335 self._alldirs.delpath(f) |
35875
bf367a93f000
dirstate: use native strings when peeking in __dict__
Augie Fackler <augie@google.com>
parents:
35109
diff
changeset
|
1336 if r"filefoldmap" in self.__dict__: |
35105
e6c64744781f
dirstate: move dropping of folded filenames into the dirstate map
Mark Thomas <mbthomas@fb.com>
parents:
35104
diff
changeset
|
1337 normed = util.normcase(f) |
e6c64744781f
dirstate: move dropping of folded filenames into the dirstate map
Mark Thomas <mbthomas@fb.com>
parents:
35104
diff
changeset
|
1338 self.filefoldmap.pop(normed, None) |
35103
19b75779b7c3
dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents:
35102
diff
changeset
|
1339 self.nonnormalset.discard(f) |
19b75779b7c3
dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents:
35102
diff
changeset
|
1340 return exists |
19b75779b7c3
dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents:
35102
diff
changeset
|
1341 |
19b75779b7c3
dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents:
35102
diff
changeset
|
1342 def clearambiguoustimes(self, files, now): |
19b75779b7c3
dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents:
35102
diff
changeset
|
1343 for f in files: |
19b75779b7c3
dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents:
35102
diff
changeset
|
1344 e = self.get(f) |
19b75779b7c3
dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents:
35102
diff
changeset
|
1345 if e is not None and e[0] == 'n' and e[3] == now: |
19b75779b7c3
dirstate: move management of nonnormal sets into dirstate map
Mark Thomas <mbthomas@fb.com>
parents:
35102
diff
changeset
|
1346 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:
35102
diff
changeset
|
1347 self.nonnormalset.add(f) |
35102
853b7c41d19c
dirstate: add explicit methods for modifying dirstate
Mark Thomas <mbthomas@fb.com>
parents:
35101
diff
changeset
|
1348 |
34340
4ac04418ce66
dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents:
34339
diff
changeset
|
1349 def nonnormalentries(self): |
4ac04418ce66
dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents:
34339
diff
changeset
|
1350 '''Compute the nonnormal dirstate entries from the dmap''' |
4ac04418ce66
dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents:
34339
diff
changeset
|
1351 try: |
4ac04418ce66
dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents:
34339
diff
changeset
|
1352 return parsers.nonnormalotherparententries(self._map) |
4ac04418ce66
dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents:
34339
diff
changeset
|
1353 except AttributeError: |
4ac04418ce66
dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents:
34339
diff
changeset
|
1354 nonnorm = set() |
4ac04418ce66
dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents:
34339
diff
changeset
|
1355 otherparent = set() |
4ac04418ce66
dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents:
34339
diff
changeset
|
1356 for fname, e in self._map.iteritems(): |
4ac04418ce66
dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents:
34339
diff
changeset
|
1357 if e[0] != 'n' or e[3] == -1: |
4ac04418ce66
dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents:
34339
diff
changeset
|
1358 nonnorm.add(fname) |
4ac04418ce66
dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents:
34339
diff
changeset
|
1359 if e[0] == 'n' and e[2] == -2: |
4ac04418ce66
dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents:
34339
diff
changeset
|
1360 otherparent.add(fname) |
4ac04418ce66
dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents:
34339
diff
changeset
|
1361 return nonnorm, otherparent |
4ac04418ce66
dirstate: move nonnormalentries to dirstatemap
Durham Goode <durham@fb.com>
parents:
34339
diff
changeset
|
1362 |
34676
bfddc3d678ae
dirstate: remove _filefoldmap property cache
Durham Goode <durham@fb.com>
parents:
34675
diff
changeset
|
1363 @propertycache |
34341
d8b35920b7b1
dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34340
diff
changeset
|
1364 def filefoldmap(self): |
d8b35920b7b1
dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34340
diff
changeset
|
1365 """Returns a dictionary mapping normalized case paths to their |
d8b35920b7b1
dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34340
diff
changeset
|
1366 non-normalized versions. |
d8b35920b7b1
dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34340
diff
changeset
|
1367 """ |
d8b35920b7b1
dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34340
diff
changeset
|
1368 try: |
d8b35920b7b1
dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34340
diff
changeset
|
1369 makefilefoldmap = parsers.make_file_foldmap |
d8b35920b7b1
dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34340
diff
changeset
|
1370 except AttributeError: |
d8b35920b7b1
dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34340
diff
changeset
|
1371 pass |
d8b35920b7b1
dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34340
diff
changeset
|
1372 else: |
d8b35920b7b1
dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34340
diff
changeset
|
1373 return makefilefoldmap(self._map, util.normcasespec, |
d8b35920b7b1
dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34340
diff
changeset
|
1374 util.normcasefallback) |
d8b35920b7b1
dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34340
diff
changeset
|
1375 |
d8b35920b7b1
dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34340
diff
changeset
|
1376 f = {} |
d8b35920b7b1
dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34340
diff
changeset
|
1377 normcase = util.normcase |
d8b35920b7b1
dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34340
diff
changeset
|
1378 for name, s in self._map.iteritems(): |
d8b35920b7b1
dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34340
diff
changeset
|
1379 if s[0] != 'r': |
d8b35920b7b1
dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34340
diff
changeset
|
1380 f[normcase(name)] = name |
d8b35920b7b1
dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34340
diff
changeset
|
1381 f['.'] = '.' # prevents useless util.fspath() invocation |
d8b35920b7b1
dirstate: move filefoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34340
diff
changeset
|
1382 return f |
34342
af9722412ac3
dirstate: move _dirs to dirstatemap
Durham Goode <durham@fb.com>
parents:
34341
diff
changeset
|
1383 |
35107
61888bd0b300
dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents:
35106
diff
changeset
|
1384 def hastrackeddir(self, d): |
61888bd0b300
dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents:
35106
diff
changeset
|
1385 """ |
61888bd0b300
dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents:
35106
diff
changeset
|
1386 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:
35106
diff
changeset
|
1387 in this directory. |
61888bd0b300
dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents:
35106
diff
changeset
|
1388 """ |
61888bd0b300
dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents:
35106
diff
changeset
|
1389 return d in self._dirs |
61888bd0b300
dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents:
35106
diff
changeset
|
1390 |
61888bd0b300
dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents:
35106
diff
changeset
|
1391 def hasdir(self, d): |
61888bd0b300
dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents:
35106
diff
changeset
|
1392 """ |
61888bd0b300
dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents:
35106
diff
changeset
|
1393 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:
35106
diff
changeset
|
1394 in this directory. |
61888bd0b300
dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents:
35106
diff
changeset
|
1395 """ |
61888bd0b300
dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents:
35106
diff
changeset
|
1396 return d in self._alldirs |
61888bd0b300
dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents:
35106
diff
changeset
|
1397 |
34677
014bd2a555c8
dirstate: remove _dirs property cache
Durham Goode <durham@fb.com>
parents:
34676
diff
changeset
|
1398 @propertycache |
35107
61888bd0b300
dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents:
35106
diff
changeset
|
1399 def _dirs(self): |
34342
af9722412ac3
dirstate: move _dirs to dirstatemap
Durham Goode <durham@fb.com>
parents:
34341
diff
changeset
|
1400 return util.dirs(self._map, 'r') |
34344
c36c3fa7d35b
dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents:
34343
diff
changeset
|
1401 |
35107
61888bd0b300
dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents:
35106
diff
changeset
|
1402 @propertycache |
61888bd0b300
dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents:
35106
diff
changeset
|
1403 def _alldirs(self): |
61888bd0b300
dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents:
35106
diff
changeset
|
1404 return util.dirs(self._map) |
61888bd0b300
dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents:
35106
diff
changeset
|
1405 |
34344
c36c3fa7d35b
dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents:
34343
diff
changeset
|
1406 def _opendirstatefile(self): |
c36c3fa7d35b
dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents:
34343
diff
changeset
|
1407 fp, mode = txnutil.trypending(self._root, self._opener, self._filename) |
c36c3fa7d35b
dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents:
34343
diff
changeset
|
1408 if self._pendingmode is not None and self._pendingmode != mode: |
c36c3fa7d35b
dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents:
34343
diff
changeset
|
1409 fp.close() |
c36c3fa7d35b
dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents:
34343
diff
changeset
|
1410 raise error.Abort(_('working directory state may be ' |
c36c3fa7d35b
dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents:
34343
diff
changeset
|
1411 'changed parallelly')) |
c36c3fa7d35b
dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents:
34343
diff
changeset
|
1412 self._pendingmode = mode |
c36c3fa7d35b
dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents:
34343
diff
changeset
|
1413 return fp |
c36c3fa7d35b
dirstate: move opendirstatefile to dirstatemap
Durham Goode <durham@fb.com>
parents:
34343
diff
changeset
|
1414 |
34345
0c3e3810cdb6
dirstate: move parent reading to the dirstatemap class
Durham Goode <durham@fb.com>
parents:
34344
diff
changeset
|
1415 def parents(self): |
34346
ec769bba34d3
dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents:
34345
diff
changeset
|
1416 if not self._parents: |
ec769bba34d3
dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents:
34345
diff
changeset
|
1417 try: |
ec769bba34d3
dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents:
34345
diff
changeset
|
1418 fp = self._opendirstatefile() |
ec769bba34d3
dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents:
34345
diff
changeset
|
1419 st = fp.read(40) |
ec769bba34d3
dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents:
34345
diff
changeset
|
1420 fp.close() |
ec769bba34d3
dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents:
34345
diff
changeset
|
1421 except IOError as err: |
ec769bba34d3
dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents:
34345
diff
changeset
|
1422 if err.errno != errno.ENOENT: |
ec769bba34d3
dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents:
34345
diff
changeset
|
1423 raise |
ec769bba34d3
dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents:
34345
diff
changeset
|
1424 # File doesn't exist, so the current state is empty |
ec769bba34d3
dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents:
34345
diff
changeset
|
1425 st = '' |
ec769bba34d3
dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents:
34345
diff
changeset
|
1426 |
34345
0c3e3810cdb6
dirstate: move parent reading to the dirstatemap class
Durham Goode <durham@fb.com>
parents:
34344
diff
changeset
|
1427 l = len(st) |
0c3e3810cdb6
dirstate: move parent reading to the dirstatemap class
Durham Goode <durham@fb.com>
parents:
34344
diff
changeset
|
1428 if l == 40: |
38785
adacefb0b7ea
dirstate: use tuple interface to fix leak in pack_dirstate()
Yuya Nishihara <yuya@tcha.org>
parents:
36998
diff
changeset
|
1429 self._parents = (st[:20], st[20:40]) |
34346
ec769bba34d3
dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents:
34345
diff
changeset
|
1430 elif l == 0: |
38785
adacefb0b7ea
dirstate: use tuple interface to fix leak in pack_dirstate()
Yuya Nishihara <yuya@tcha.org>
parents:
36998
diff
changeset
|
1431 self._parents = (nullid, nullid) |
34346
ec769bba34d3
dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents:
34345
diff
changeset
|
1432 else: |
ec769bba34d3
dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents:
34345
diff
changeset
|
1433 raise error.Abort(_('working directory state appears ' |
ec769bba34d3
dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents:
34345
diff
changeset
|
1434 'damaged!')) |
ec769bba34d3
dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents:
34345
diff
changeset
|
1435 |
ec769bba34d3
dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents:
34345
diff
changeset
|
1436 return self._parents |
ec769bba34d3
dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents:
34345
diff
changeset
|
1437 |
ec769bba34d3
dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents:
34345
diff
changeset
|
1438 def setparents(self, p1, p2): |
ec769bba34d3
dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents:
34345
diff
changeset
|
1439 self._parents = (p1, p2) |
ec769bba34d3
dirstate: move parents source of truth to dirstatemap
Durham Goode <durham@fb.com>
parents:
34345
diff
changeset
|
1440 self._dirtyparents = True |
34672
e159f217230e
dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents:
34481
diff
changeset
|
1441 |
e159f217230e
dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents:
34481
diff
changeset
|
1442 def read(self): |
34675
c6ef9a2498a5
dirstate: move identity to dirstatemap
Durham Goode <durham@fb.com>
parents:
34674
diff
changeset
|
1443 # 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
|
1444 self.identity = util.filestat.frompath( |
c6ef9a2498a5
dirstate: move identity to dirstatemap
Durham Goode <durham@fb.com>
parents:
34674
diff
changeset
|
1445 self._opener.join(self._filename)) |
c6ef9a2498a5
dirstate: move identity to dirstatemap
Durham Goode <durham@fb.com>
parents:
34674
diff
changeset
|
1446 |
34672
e159f217230e
dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents:
34481
diff
changeset
|
1447 try: |
e159f217230e
dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents:
34481
diff
changeset
|
1448 fp = self._opendirstatefile() |
e159f217230e
dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents:
34481
diff
changeset
|
1449 try: |
e159f217230e
dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents:
34481
diff
changeset
|
1450 st = fp.read() |
e159f217230e
dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents:
34481
diff
changeset
|
1451 finally: |
e159f217230e
dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents:
34481
diff
changeset
|
1452 fp.close() |
e159f217230e
dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents:
34481
diff
changeset
|
1453 except IOError as err: |
e159f217230e
dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents:
34481
diff
changeset
|
1454 if err.errno != errno.ENOENT: |
e159f217230e
dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents:
34481
diff
changeset
|
1455 raise |
e159f217230e
dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents:
34481
diff
changeset
|
1456 return |
e159f217230e
dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents:
34481
diff
changeset
|
1457 if not st: |
e159f217230e
dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents:
34481
diff
changeset
|
1458 return |
e159f217230e
dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents:
34481
diff
changeset
|
1459 |
e159f217230e
dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents:
34481
diff
changeset
|
1460 if util.safehasattr(parsers, 'dict_new_presized'): |
e159f217230e
dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents:
34481
diff
changeset
|
1461 # Make an estimate of the number of files in the dirstate based on |
e159f217230e
dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents:
34481
diff
changeset
|
1462 # its size. From a linear regression on a set of real-world repos, |
e159f217230e
dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents:
34481
diff
changeset
|
1463 # all over 10,000 files, the size of a dirstate entry is 85 |
e159f217230e
dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents:
34481
diff
changeset
|
1464 # bytes. The cost of resizing is significantly higher than the cost |
e159f217230e
dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents:
34481
diff
changeset
|
1465 # of filling in a larger presized dict, so subtract 20% from the |
e159f217230e
dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents:
34481
diff
changeset
|
1466 # size. |
e159f217230e
dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents:
34481
diff
changeset
|
1467 # |
e159f217230e
dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents:
34481
diff
changeset
|
1468 # This heuristic is imperfect in many ways, so in a future dirstate |
e159f217230e
dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents:
34481
diff
changeset
|
1469 # format update it makes sense to just record the number of entries |
e159f217230e
dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents:
34481
diff
changeset
|
1470 # on write. |
36651
0297f9c4caee
py3: do not pass a float to dict_new_presized()
Yuya Nishihara <yuya@tcha.org>
parents:
36238
diff
changeset
|
1471 self._map = parsers.dict_new_presized(len(st) // 71) |
34672
e159f217230e
dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents:
34481
diff
changeset
|
1472 |
e159f217230e
dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents:
34481
diff
changeset
|
1473 # Python's garbage collector triggers a GC each time a certain number |
e159f217230e
dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents:
34481
diff
changeset
|
1474 # of container objects (the number being defined by |
e159f217230e
dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents:
34481
diff
changeset
|
1475 # gc.get_threshold()) are allocated. parse_dirstate creates a tuple |
e159f217230e
dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents:
34481
diff
changeset
|
1476 # for each file in the dirstate. The C version then immediately marks |
e159f217230e
dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents:
34481
diff
changeset
|
1477 # 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:
34481
diff
changeset
|
1478 # 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:
34481
diff
changeset
|
1479 # into. This means that O(number of files) GCs are unavoidable. |
e159f217230e
dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents:
34481
diff
changeset
|
1480 # Depending on when in the process's lifetime the dirstate is parsed, |
e159f217230e
dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents:
34481
diff
changeset
|
1481 # this can get very expensive. As a workaround, disable GC while |
e159f217230e
dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents:
34481
diff
changeset
|
1482 # parsing the dirstate. |
e159f217230e
dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents:
34481
diff
changeset
|
1483 # |
e159f217230e
dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents:
34481
diff
changeset
|
1484 # (we cannot decorate the function directly since it is in a C module) |
42763
760a7851e9ba
rust-parsers: move parser bindings to their own file and Python module
Raphaël Gomès <rgomes@octobus.net>
parents:
42472
diff
changeset
|
1485 parse_dirstate = util.nogc(parsers.parse_dirstate) |
34672
e159f217230e
dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents:
34481
diff
changeset
|
1486 p = parse_dirstate(self._map, self.copymap, st) |
e159f217230e
dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents:
34481
diff
changeset
|
1487 if not self._dirtyparents: |
e159f217230e
dirstate: move _read into dirstatemap
Durham Goode <durham@fb.com>
parents:
34481
diff
changeset
|
1488 self.setparents(*p) |
34673
e2214632c3a2
dirstate: move write into dirstatemap
Durham Goode <durham@fb.com>
parents:
34672
diff
changeset
|
1489 |
34935
ffeea2406276
dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents:
34934
diff
changeset
|
1490 # 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
|
1491 self.__contains__ = self._map.__contains__ |
ffeea2406276
dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents:
34934
diff
changeset
|
1492 self.__getitem__ = self._map.__getitem__ |
ffeea2406276
dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents:
34934
diff
changeset
|
1493 self.get = self._map.get |
ffeea2406276
dirstate: remove excess attribute lookups for dirstate.status (issue5714)
Durham Goode <durham@fb.com>
parents:
34934
diff
changeset
|
1494 |
34673
e2214632c3a2
dirstate: move write into dirstatemap
Durham Goode <durham@fb.com>
parents:
34672
diff
changeset
|
1495 def write(self, st, now): |
42763
760a7851e9ba
rust-parsers: move parser bindings to their own file and Python module
Raphaël Gomès <rgomes@octobus.net>
parents:
42472
diff
changeset
|
1496 st.write(parsers.pack_dirstate(self._map, self.copymap, |
760a7851e9ba
rust-parsers: move parser bindings to their own file and Python module
Raphaël Gomès <rgomes@octobus.net>
parents:
42472
diff
changeset
|
1497 self.parents(), now)) |
34673
e2214632c3a2
dirstate: move write into dirstatemap
Durham Goode <durham@fb.com>
parents:
34672
diff
changeset
|
1498 st.close() |
e2214632c3a2
dirstate: move write into dirstatemap
Durham Goode <durham@fb.com>
parents:
34672
diff
changeset
|
1499 self._dirtyparents = False |
34674
60927b19ed65
dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents:
34673
diff
changeset
|
1500 self.nonnormalset, self.otherparentset = self.nonnormalentries() |
60927b19ed65
dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents:
34673
diff
changeset
|
1501 |
60927b19ed65
dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents:
34673
diff
changeset
|
1502 @propertycache |
60927b19ed65
dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents:
34673
diff
changeset
|
1503 def nonnormalset(self): |
60927b19ed65
dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents:
34673
diff
changeset
|
1504 nonnorm, otherparents = self.nonnormalentries() |
60927b19ed65
dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents:
34673
diff
changeset
|
1505 self.otherparentset = otherparents |
60927b19ed65
dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents:
34673
diff
changeset
|
1506 return nonnorm |
60927b19ed65
dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents:
34673
diff
changeset
|
1507 |
60927b19ed65
dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents:
34673
diff
changeset
|
1508 @propertycache |
60927b19ed65
dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents:
34673
diff
changeset
|
1509 def otherparentset(self): |
60927b19ed65
dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents:
34673
diff
changeset
|
1510 nonnorm, otherparents = self.nonnormalentries() |
60927b19ed65
dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents:
34673
diff
changeset
|
1511 self.nonnormalset = nonnorm |
60927b19ed65
dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents:
34673
diff
changeset
|
1512 return otherparents |
60927b19ed65
dirstate: move nonnormal and otherparent sets to dirstatemap
Durham Goode <durham@fb.com>
parents:
34673
diff
changeset
|
1513 |
34675
c6ef9a2498a5
dirstate: move identity to dirstatemap
Durham Goode <durham@fb.com>
parents:
34674
diff
changeset
|
1514 @propertycache |
c6ef9a2498a5
dirstate: move identity to dirstatemap
Durham Goode <durham@fb.com>
parents:
34674
diff
changeset
|
1515 def identity(self): |
34934
6e66033f91cc
dirstate: avoid reading the map when possible (issue5713) (issue5717)
Durham Goode <durham@fb.com>
parents:
34933
diff
changeset
|
1516 self._map |
34675
c6ef9a2498a5
dirstate: move identity to dirstatemap
Durham Goode <durham@fb.com>
parents:
34674
diff
changeset
|
1517 return self.identity |
c6ef9a2498a5
dirstate: move identity to dirstatemap
Durham Goode <durham@fb.com>
parents:
34674
diff
changeset
|
1518 |
34678
e8a89ed7ce96
dirstate: move the _dirfoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34677
diff
changeset
|
1519 @propertycache |
e8a89ed7ce96
dirstate: move the _dirfoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34677
diff
changeset
|
1520 def dirfoldmap(self): |
e8a89ed7ce96
dirstate: move the _dirfoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34677
diff
changeset
|
1521 f = {} |
e8a89ed7ce96
dirstate: move the _dirfoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34677
diff
changeset
|
1522 normcase = util.normcase |
35107
61888bd0b300
dirstate: add explicit methods for querying directories (API)
Mark Thomas <mbthomas@fb.com>
parents:
35106
diff
changeset
|
1523 for name in self._dirs: |
34678
e8a89ed7ce96
dirstate: move the _dirfoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34677
diff
changeset
|
1524 f[normcase(name)] = name |
e8a89ed7ce96
dirstate: move the _dirfoldmap to dirstatemap
Durham Goode <durham@fb.com>
parents:
34677
diff
changeset
|
1525 return f |
42771
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1526 |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1527 |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1528 if rustmod is not None: |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1529 class dirstatemap(object): |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1530 def __init__(self, ui, opener, root): |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1531 self._ui = ui |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1532 self._opener = opener |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1533 self._root = root |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1534 self._filename = 'dirstate' |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1535 self._parents = None |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1536 self._dirtyparents = False |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1537 |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1538 # for consistent view between _pl() and _read() invocations |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1539 self._pendingmode = None |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1540 |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1541 def addfile(self, *args, **kwargs): |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1542 return self._rustmap.addfile(*args, **kwargs) |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1543 |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1544 def removefile(self, *args, **kwargs): |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1545 return self._rustmap.removefile(*args, **kwargs) |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1546 |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1547 def dropfile(self, *args, **kwargs): |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1548 return self._rustmap.dropfile(*args, **kwargs) |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1549 |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1550 def clearambiguoustimes(self, *args, **kwargs): |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1551 return self._rustmap.clearambiguoustimes(*args, **kwargs) |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1552 |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1553 def nonnormalentries(self): |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1554 return self._rustmap.nonnormalentries() |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1555 |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1556 def get(self, *args, **kwargs): |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1557 return self._rustmap.get(*args, **kwargs) |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1558 |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1559 @propertycache |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1560 def _rustmap(self): |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1561 self._rustmap = rustmod.DirstateMap(self._root) |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1562 self.read() |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1563 return self._rustmap |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1564 |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1565 @property |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1566 def copymap(self): |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1567 return self._rustmap.copymap() |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1568 |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1569 def preload(self): |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1570 self._rustmap |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1571 |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1572 def clear(self): |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1573 self._rustmap.clear() |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1574 self.setparents(nullid, nullid) |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1575 util.clearcachedproperty(self, "_dirs") |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1576 util.clearcachedproperty(self, "_alldirs") |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1577 util.clearcachedproperty(self, "dirfoldmap") |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1578 |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1579 def items(self): |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1580 return self._rustmap.items() |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1581 |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1582 def keys(self): |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1583 return iter(self._rustmap) |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1584 |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1585 def __contains__(self, key): |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1586 return key in self._rustmap |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1587 |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1588 def __getitem__(self, item): |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1589 return self._rustmap[item] |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1590 |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1591 def __len__(self): |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1592 return len(self._rustmap) |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1593 |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1594 def __iter__(self): |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1595 return iter(self._rustmap) |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1596 |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1597 # forward for python2,3 compat |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1598 iteritems = items |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1599 |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1600 def _opendirstatefile(self): |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1601 fp, mode = txnutil.trypending(self._root, self._opener, |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1602 self._filename) |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1603 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:
42763
diff
changeset
|
1604 fp.close() |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1605 raise error.Abort(_('working directory state may be ' |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1606 'changed parallelly')) |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1607 self._pendingmode = mode |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1608 return fp |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1609 |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1610 def setparents(self, p1, p2): |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1611 self._rustmap.setparents(p1, p2) |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1612 self._parents = (p1, p2) |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1613 self._dirtyparents = True |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1614 |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1615 def parents(self): |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1616 if not self._parents: |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1617 try: |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1618 fp = self._opendirstatefile() |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1619 st = fp.read(40) |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1620 fp.close() |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1621 except IOError as err: |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1622 if err.errno != errno.ENOENT: |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1623 raise |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1624 # File doesn't exist, so the current state is empty |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1625 st = '' |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1626 |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1627 try: |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1628 self._parents = self._rustmap.parents(st) |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1629 except ValueError: |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1630 raise error.Abort(_('working directory state appears ' |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1631 'damaged!')) |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1632 |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1633 return self._parents |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1634 |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1635 def read(self): |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1636 # 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:
42763
diff
changeset
|
1637 self.identity = util.filestat.frompath( |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1638 self._opener.join(self._filename)) |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1639 |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1640 try: |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1641 fp = self._opendirstatefile() |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1642 try: |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1643 st = fp.read() |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1644 finally: |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1645 fp.close() |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1646 except IOError as err: |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1647 if err.errno != errno.ENOENT: |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1648 raise |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1649 return |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1650 if not st: |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1651 return |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1652 |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1653 parse_dirstate = util.nogc(self._rustmap.read) |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1654 parents = parse_dirstate(st) |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1655 if parents and not self._dirtyparents: |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1656 self.setparents(*parents) |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1657 |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1658 def write(self, st, now): |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1659 parents = self.parents() |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1660 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:
42763
diff
changeset
|
1661 st.close() |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1662 self._dirtyparents = False |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1663 |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1664 @propertycache |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1665 def filefoldmap(self): |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1666 """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:
42763
diff
changeset
|
1667 non-normalized versions. |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1668 """ |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1669 return self._rustmap.filefoldmapasdict() |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1670 |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1671 def hastrackeddir(self, d): |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1672 self._dirs # Trigger Python's propertycache |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1673 return self._rustmap.hastrackeddir(d) |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1674 |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1675 def hasdir(self, d): |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1676 self._dirs # Trigger Python's propertycache |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1677 return self._rustmap.hasdir(d) |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1678 |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1679 @propertycache |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1680 def _dirs(self): |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1681 return self._rustmap.getdirs() |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1682 |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1683 @propertycache |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1684 def _alldirs(self): |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1685 return self._rustmap.getalldirs() |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1686 |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1687 @propertycache |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1688 def identity(self): |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1689 self._rustmap |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1690 return self.identity |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1691 |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1692 @property |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1693 def nonnormalset(self): |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1694 nonnorm, otherparents = self._rustmap.nonnormalentries() |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1695 return nonnorm |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1696 |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1697 @property |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1698 def otherparentset(self): |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1699 nonnorm, otherparents = self._rustmap.nonnormalentries() |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1700 return otherparents |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1701 |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1702 @propertycache |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1703 def dirfoldmap(self): |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1704 f = {} |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1705 normcase = util.normcase |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1706 for name in self._dirs: |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1707 f[normcase(name)] = name |
749ef8c31187
rust-dirstate: call rust dirstatemap from Python
Raphaël Gomès <rgomes@octobus.net>
parents:
42763
diff
changeset
|
1708 return f |