Mercurial > hg
annotate mercurial/dirstate.py @ 26878:d7e83f106459
encoding: use getutf8char in toutf8b
This correctly avoids the ambiguity of U+FFFD already present in the
input and similar confusion by working a character at a time.
author | Matt Mackall <mpm@selenic.com> |
---|---|
date | Thu, 05 Nov 2015 17:21:43 -0600 |
parents | cbd04ce641b9 |
children | 663eff02a876 |
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 |
6211
f89fd07fc51d
Expand import * to allow Pyflakes to find problems
Joel Rosdahl <joel@rosdahl.net>
parents:
6201
diff
changeset
|
8 from node import nullid |
3891 | 9 from i18n import _ |
26587
56b2bcea2529
error: get Abort from 'error' instead of 'util'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26521
diff
changeset
|
10 import scmutil, util, osutil, parsers, encoding, pathutil, error |
23496
ee5a4ed4c8b1
dirstate: use the 'nogc' decorator
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23375
diff
changeset
|
11 import os, stat, errno |
25216
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25163
diff
changeset
|
12 import match as matchmod |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
13 |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
14 propertycache = util.propertycache |
16201
fb7c4c14223f
dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents:
16200
diff
changeset
|
15 filecache = scmutil.filecache |
17733
3c775c5a6c03
dirstate: handle large dates and times with masking (issue2608)
Matt Mackall <mpm@selenic.com>
parents:
17197
diff
changeset
|
16 _rangemask = 0x7fffffff |
16201
fb7c4c14223f
dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents:
16200
diff
changeset
|
17 |
21809
e250b8300e6e
parsers: inline fields of dirstate values in C version
Siddharth Agarwal <sid0@fb.com>
parents:
21808
diff
changeset
|
18 dirstatetuple = parsers.dirstatetuple |
21808
7537e57f5dbd
dirstate: add dirstatetuple to create dirstate values
Siddharth Agarwal <sid0@fb.com>
parents:
21116
diff
changeset
|
19 |
16201
fb7c4c14223f
dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents:
16200
diff
changeset
|
20 class repocache(filecache): |
fb7c4c14223f
dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents:
16200
diff
changeset
|
21 """filecache for files in .hg/""" |
fb7c4c14223f
dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents:
16200
diff
changeset
|
22 def join(self, obj, fname): |
fb7c4c14223f
dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents:
16200
diff
changeset
|
23 return obj._opener.join(fname) |
4610 | 24 |
16202
53e2cd303ecf
dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents:
16201
diff
changeset
|
25 class rootcache(filecache): |
53e2cd303ecf
dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents:
16201
diff
changeset
|
26 """filecache for files in the repository root""" |
53e2cd303ecf
dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents:
16201
diff
changeset
|
27 def join(self, obj, fname): |
53e2cd303ecf
dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents:
16201
diff
changeset
|
28 return obj._join(fname) |
53e2cd303ecf
dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents:
16201
diff
changeset
|
29 |
26634
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
30 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
|
31 '''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
|
32 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
|
33 try: |
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
34 return util.statmtimesec(os.fstat(tmpfd)) |
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
35 finally: |
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
36 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
|
37 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
|
38 |
26635
79d86ab65c9d
dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26634
diff
changeset
|
39 def _trypending(root, vfs, filename): |
79d86ab65c9d
dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26634
diff
changeset
|
40 '''Open file to be read according to HG_PENDING environment variable |
79d86ab65c9d
dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26634
diff
changeset
|
41 |
79d86ab65c9d
dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26634
diff
changeset
|
42 This opens '.pending' of specified 'filename' only when HG_PENDING |
79d86ab65c9d
dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26634
diff
changeset
|
43 is equal to 'root'. |
79d86ab65c9d
dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26634
diff
changeset
|
44 |
79d86ab65c9d
dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26634
diff
changeset
|
45 This returns '(fp, is_pending_opened)' tuple. |
79d86ab65c9d
dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26634
diff
changeset
|
46 ''' |
79d86ab65c9d
dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26634
diff
changeset
|
47 if root == os.environ.get('HG_PENDING'): |
79d86ab65c9d
dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26634
diff
changeset
|
48 try: |
79d86ab65c9d
dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26634
diff
changeset
|
49 return (vfs('%s.pending' % filename), True) |
79d86ab65c9d
dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26634
diff
changeset
|
50 except IOError as inst: |
79d86ab65c9d
dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26634
diff
changeset
|
51 if inst.errno != errno.ENOENT: |
79d86ab65c9d
dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26634
diff
changeset
|
52 raise |
79d86ab65c9d
dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26634
diff
changeset
|
53 return (vfs(filename), False) |
79d86ab65c9d
dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26634
diff
changeset
|
54 |
1559
59b3639df0a9
Convert all classes to new-style classes by deriving them from object.
Eric Hopper <hopper@omnifarious.org>
parents:
1541
diff
changeset
|
55 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
|
56 |
13032
e41e2b79883d
dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents:
12907
diff
changeset
|
57 def __init__(self, opener, ui, root, validate): |
10145
aec936051734
dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents:
9678
diff
changeset
|
58 '''Create a new dirstate object. |
aec936051734
dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents:
9678
diff
changeset
|
59 |
aec936051734
dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents:
9678
diff
changeset
|
60 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
|
61 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
|
62 the dirstate. |
aec936051734
dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents:
9678
diff
changeset
|
63 ''' |
4614
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
64 self._opener = opener |
13032
e41e2b79883d
dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents:
12907
diff
changeset
|
65 self._validate = validate |
4614
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
66 self._root = root |
24198
3cc630be5f09
dirstate: make sure rootdir ends with directory separator (issue4557)
Yuya Nishihara <yuya@tcha.org>
parents:
23866
diff
changeset
|
67 # 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
|
68 # 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
|
69 self._rootdir = pathutil.normasprefix(root) |
26294
1ffc61c4e32e
hgweb: overwrite cwd to resolve file patterns relative to repo (issue4568)
Yuya Nishihara <yuya@tcha.org>
parents:
26293
diff
changeset
|
70 # internal config: ui.forcecwd |
1ffc61c4e32e
hgweb: overwrite cwd to resolve file patterns relative to repo (issue4568)
Yuya Nishihara <yuya@tcha.org>
parents:
26293
diff
changeset
|
71 forcecwd = ui.config('ui', 'forcecwd') |
1ffc61c4e32e
hgweb: overwrite cwd to resolve file patterns relative to repo (issue4568)
Yuya Nishihara <yuya@tcha.org>
parents:
26293
diff
changeset
|
72 if forcecwd: |
1ffc61c4e32e
hgweb: overwrite cwd to resolve file patterns relative to repo (issue4568)
Yuya Nishihara <yuya@tcha.org>
parents:
26293
diff
changeset
|
73 self._cwd = forcecwd |
4903
81078e177266
dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents:
4677
diff
changeset
|
74 self._dirty = False |
4965 | 75 self._dirtypl = False |
15791
a814f8fcc65a
Use explicit integer division
Martin Geisler <mg@aragost.com>
parents:
15670
diff
changeset
|
76 self._lastnormaltime = 0 |
4614
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
77 self._ui = ui |
16200
9d4a2942a732
dirstate: add filecache support
Idan Kamara <idankk86@gmail.com>
parents:
16143
diff
changeset
|
78 self._filecache = {} |
22404
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
79 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
|
80 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
|
81 self._pendingfilename = '%s.pending' % self._filename |
22404
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
82 |
26781
1aee2ab0f902
spelling: trivial spell checking
Mads Kiilerich <madski@unity3d.com>
parents:
26749
diff
changeset
|
83 # for consistent view between _pl() and _read() invocations |
26635
79d86ab65c9d
dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26634
diff
changeset
|
84 self._pendingmode = None |
79d86ab65c9d
dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26634
diff
changeset
|
85 |
22404
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
86 def beginparentchange(self): |
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
87 '''Marks the beginning of a set of changes that involve changing |
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
88 the dirstate parents. If there is an exception during this time, |
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
89 the dirstate will not be written when the wlock is released. This |
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
90 prevents writing an incoherent dirstate where the parent doesn't |
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
91 match the contents. |
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
92 ''' |
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
93 self._parentwriters += 1 |
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
94 |
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
95 def endparentchange(self): |
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
96 '''Marks the end of a set of changes that involve changing the |
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
97 dirstate parents. Once all parent changes have been marked done, |
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
98 the wlock will be free to write the dirstate on release. |
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
99 ''' |
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
100 if self._parentwriters > 0: |
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
101 self._parentwriters -= 1 |
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
102 |
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
103 def pendingparentchange(self): |
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
104 '''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
|
105 that modify the dirstate parent. |
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
106 ''' |
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
107 return self._parentwriters > 0 |
723 | 108 |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
109 @propertycache |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
110 def _map(self): |
9518
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
111 '''Return the dirstate contents as a map from filename to |
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
112 (state, mode, size, time).''' |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
113 self._read() |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
114 return self._map |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
115 |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
116 @propertycache |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
117 def _copymap(self): |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
118 self._read() |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
119 return self._copymap |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
120 |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
121 @propertycache |
24540
25c1d3ca5ff6
dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents:
24539
diff
changeset
|
122 def _filefoldmap(self): |
24610
4a4018831d2e
dirstate: use parsers.make_file_foldmap when available
Siddharth Agarwal <sid0@fb.com>
parents:
24561
diff
changeset
|
123 try: |
4a4018831d2e
dirstate: use parsers.make_file_foldmap when available
Siddharth Agarwal <sid0@fb.com>
parents:
24561
diff
changeset
|
124 makefilefoldmap = parsers.make_file_foldmap |
4a4018831d2e
dirstate: use parsers.make_file_foldmap when available
Siddharth Agarwal <sid0@fb.com>
parents:
24561
diff
changeset
|
125 except AttributeError: |
4a4018831d2e
dirstate: use parsers.make_file_foldmap when available
Siddharth Agarwal <sid0@fb.com>
parents:
24561
diff
changeset
|
126 pass |
4a4018831d2e
dirstate: use parsers.make_file_foldmap when available
Siddharth Agarwal <sid0@fb.com>
parents:
24561
diff
changeset
|
127 else: |
4a4018831d2e
dirstate: use parsers.make_file_foldmap when available
Siddharth Agarwal <sid0@fb.com>
parents:
24561
diff
changeset
|
128 return makefilefoldmap(self._map, util.normcasespec, |
4a4018831d2e
dirstate: use parsers.make_file_foldmap when available
Siddharth Agarwal <sid0@fb.com>
parents:
24561
diff
changeset
|
129 util.normcasefallback) |
4a4018831d2e
dirstate: use parsers.make_file_foldmap when available
Siddharth Agarwal <sid0@fb.com>
parents:
24561
diff
changeset
|
130 |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
131 f = {} |
22782
a1eb21f5caea
dirstate: cache util.normcase while constructing the foldmap
Siddharth Agarwal <sid0@fb.com>
parents:
22459
diff
changeset
|
132 normcase = util.normcase |
19103
0176d0db4671
icasefs: ignore removed files at building "dirstate._foldmap" up on icasefs
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
18899
diff
changeset
|
133 for name, s in self._map.iteritems(): |
0176d0db4671
icasefs: ignore removed files at building "dirstate._foldmap" up on icasefs
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
18899
diff
changeset
|
134 if s[0] != 'r': |
22782
a1eb21f5caea
dirstate: cache util.normcase while constructing the foldmap
Siddharth Agarwal <sid0@fb.com>
parents:
22459
diff
changeset
|
135 f[normcase(name)] = name |
24540
25c1d3ca5ff6
dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents:
24539
diff
changeset
|
136 f['.'] = '.' # prevents useless util.fspath() invocation |
25c1d3ca5ff6
dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents:
24539
diff
changeset
|
137 return f |
25c1d3ca5ff6
dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents:
24539
diff
changeset
|
138 |
25c1d3ca5ff6
dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents:
24539
diff
changeset
|
139 @propertycache |
25c1d3ca5ff6
dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents:
24539
diff
changeset
|
140 def _dirfoldmap(self): |
25c1d3ca5ff6
dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents:
24539
diff
changeset
|
141 f = {} |
25c1d3ca5ff6
dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents:
24539
diff
changeset
|
142 normcase = util.normcase |
16302
49b54f1ae053
dirstate: normalize case of directory components
Matt Mackall <mpm@selenic.com>
parents:
16258
diff
changeset
|
143 for name in self._dirs: |
22782
a1eb21f5caea
dirstate: cache util.normcase while constructing the foldmap
Siddharth Agarwal <sid0@fb.com>
parents:
22459
diff
changeset
|
144 f[normcase(name)] = name |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
145 return f |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
146 |
16201
fb7c4c14223f
dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents:
16200
diff
changeset
|
147 @repocache('branch') |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
148 def _branch(self): |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
149 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
|
150 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
|
151 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
|
152 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
|
153 raise |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
154 return "default" |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
155 |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
156 @propertycache |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
157 def _pl(self): |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
158 try: |
26635
79d86ab65c9d
dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26634
diff
changeset
|
159 fp = self._opendirstatefile() |
13400
14f3795a5ed7
explicitly close files
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
13343
diff
changeset
|
160 st = fp.read(40) |
14f3795a5ed7
explicitly close files
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
13343
diff
changeset
|
161 fp.close() |
8716
f3322bb29a0e
dirstate: don't complain about 0-length files
Matt Mackall <mpm@selenic.com>
parents:
8708
diff
changeset
|
162 l = len(st) |
f3322bb29a0e
dirstate: don't complain about 0-length files
Matt Mackall <mpm@selenic.com>
parents:
8708
diff
changeset
|
163 if l == 40: |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
164 return st[:20], st[20:40] |
8716
f3322bb29a0e
dirstate: don't complain about 0-length files
Matt Mackall <mpm@selenic.com>
parents:
8708
diff
changeset
|
165 elif l > 0 and l < 40: |
26587
56b2bcea2529
error: get Abort from 'error' instead of 'util'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26521
diff
changeset
|
166 raise error.Abort(_('working directory state appears damaged!')) |
25660
328739ea70c3
global: mass rewrite to use modern exception syntax
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25658
diff
changeset
|
167 except IOError as err: |
10282
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
168 if err.errno != errno.ENOENT: |
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
169 raise |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
170 return [nullid, nullid] |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
171 |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
172 @propertycache |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
173 def _dirs(self): |
24635
21e1ece30f8c
util: move dirs() and finddirs() from scmutil to util
Drew Gottlieb <drgott@google.com>
parents:
24632
diff
changeset
|
174 return util.dirs(self._map, 'r') |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
175 |
16143
fceb2964fa6c
context: add 'dirs()' to changectx/workingctx for directory patterns
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
15801
diff
changeset
|
176 def dirs(self): |
fceb2964fa6c
context: add 'dirs()' to changectx/workingctx for directory patterns
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
15801
diff
changeset
|
177 return self._dirs |
fceb2964fa6c
context: add 'dirs()' to changectx/workingctx for directory patterns
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
15801
diff
changeset
|
178 |
16202
53e2cd303ecf
dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents:
16201
diff
changeset
|
179 @rootcache('.hgignore') |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
180 def _ignore(self): |
25163
3139900f31b1
ignore: remove .hgignore from ignore list if nonexistent
Durham Goode <durham@fb.com>
parents:
25151
diff
changeset
|
181 files = [] |
3139900f31b1
ignore: remove .hgignore from ignore list if nonexistent
Durham Goode <durham@fb.com>
parents:
25151
diff
changeset
|
182 if os.path.exists(self._join('.hgignore')): |
3139900f31b1
ignore: remove .hgignore from ignore list if nonexistent
Durham Goode <durham@fb.com>
parents:
25151
diff
changeset
|
183 files.append(self._join('.hgignore')) |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
184 for name, path in self._ui.configitems("ui"): |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
185 if name == 'ignore' or name.startswith('ignore.'): |
23629
a04c7b74b3d5
ignore: resolve ignore files relative to repo root (issue4473) (BC)
Siddharth Agarwal <sid0@fb.com>
parents:
23496
diff
changeset
|
186 # we need to use os.path.join here rather than self._join |
a04c7b74b3d5
ignore: resolve ignore files relative to repo root (issue4473) (BC)
Siddharth Agarwal <sid0@fb.com>
parents:
23496
diff
changeset
|
187 # because path is arbitrary and user-specified |
a04c7b74b3d5
ignore: resolve ignore files relative to repo root (issue4473) (BC)
Siddharth Agarwal <sid0@fb.com>
parents:
23496
diff
changeset
|
188 files.append(os.path.join(self._rootdir, util.expandpath(path))) |
25216
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25163
diff
changeset
|
189 |
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25163
diff
changeset
|
190 if not files: |
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25163
diff
changeset
|
191 return util.never |
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25163
diff
changeset
|
192 |
dc562165044a
ignore: use 'include:' rules instead of custom syntax
Durham Goode <durham@fb.com>
parents:
25163
diff
changeset
|
193 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
|
194 return matchmod.match(self._root, '', [], pats, warn=self._ui.warn) |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
195 |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
196 @propertycache |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
197 def _slash(self): |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
198 return self._ui.configbool('ui', 'slash') and os.sep != '/' |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
199 |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
200 @propertycache |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
201 def _checklink(self): |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
202 return util.checklink(self._root) |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
203 |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
204 @propertycache |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
205 def _checkexec(self): |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
206 return util.checkexec(self._root) |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
207 |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
208 @propertycache |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
209 def _checkcase(self): |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
210 return not util.checkcase(self._join('.hg')) |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
211 |
4905
fc61495ea9cf
dirstate: make wjoin function private
Matt Mackall <mpm@selenic.com>
parents:
4904
diff
changeset
|
212 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
|
213 # 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
|
214 # 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
|
215 return self._rootdir + f |
723 | 216 |
15337
cf5f9df6406b
windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents:
15057
diff
changeset
|
217 def flagfunc(self, buildfallback): |
cf5f9df6406b
windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents:
15057
diff
changeset
|
218 if self._checklink and self._checkexec: |
cf5f9df6406b
windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents:
15057
diff
changeset
|
219 def f(x): |
18869
e8b4b139a545
dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents:
18815
diff
changeset
|
220 try: |
e8b4b139a545
dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents:
18815
diff
changeset
|
221 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
|
222 if util.statislink(st): |
e8b4b139a545
dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents:
18815
diff
changeset
|
223 return 'l' |
e8b4b139a545
dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents:
18815
diff
changeset
|
224 if util.statisexec(st): |
e8b4b139a545
dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents:
18815
diff
changeset
|
225 return 'x' |
e8b4b139a545
dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents:
18815
diff
changeset
|
226 except OSError: |
e8b4b139a545
dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents:
18815
diff
changeset
|
227 pass |
15337
cf5f9df6406b
windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents:
15057
diff
changeset
|
228 return '' |
cf5f9df6406b
windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents:
15057
diff
changeset
|
229 return f |
cf5f9df6406b
windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents:
15057
diff
changeset
|
230 |
cf5f9df6406b
windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents:
15057
diff
changeset
|
231 fallback = buildfallback() |
6743 | 232 if self._checklink: |
233 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
|
234 if os.path.islink(self._join(x)): |
6743 | 235 return 'l' |
236 if 'x' in fallback(x): | |
237 return 'x' | |
238 return '' | |
239 return f | |
240 if self._checkexec: | |
241 def f(x): | |
242 if 'l' in fallback(x): | |
243 return 'l' | |
14273
38af0f514134
rename util.is_exec to isexec
Adrian Buehlmann <adrian@cadifra.com>
parents:
14168
diff
changeset
|
244 if util.isexec(self._join(x)): |
6743 | 245 return 'x' |
246 return '' | |
247 return f | |
15337
cf5f9df6406b
windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents:
15057
diff
changeset
|
248 else: |
cf5f9df6406b
windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents:
15057
diff
changeset
|
249 return fallback |
6743 | 250 |
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
|
251 @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
|
252 def _cwd(self): |
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
|
253 return os.getcwd() |
e40520642e64
rebase: do not crash in panic when cwd disapear in the process (issue4121)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
20033
diff
changeset
|
254 |
870
a82eae840447
Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents:
839
diff
changeset
|
255 def getcwd(self): |
26293
3d24f31c6b8f
dirstate: state that getcwd() shouldn't be used to get real file path
Yuya Nishihara <yuya@tcha.org>
parents:
25877
diff
changeset
|
256 '''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
|
257 |
3d24f31c6b8f
dirstate: state that getcwd() shouldn't be used to get real file path
Yuya Nishihara <yuya@tcha.org>
parents:
25877
diff
changeset
|
258 This path should be used to resolve file patterns or to convert |
3d24f31c6b8f
dirstate: state that getcwd() shouldn't be used to get real file path
Yuya Nishihara <yuya@tcha.org>
parents:
25877
diff
changeset
|
259 canonical paths back to file paths for display. It shouldn't be |
3d24f31c6b8f
dirstate: state that getcwd() shouldn't be used to get real file path
Yuya Nishihara <yuya@tcha.org>
parents:
25877
diff
changeset
|
260 used to get real file paths. Use vfs functions instead. |
3d24f31c6b8f
dirstate: state that getcwd() shouldn't be used to get real file path
Yuya Nishihara <yuya@tcha.org>
parents:
25877
diff
changeset
|
261 ''' |
20335
e40520642e64
rebase: do not crash in panic when cwd disapear in the process (issue4121)
Pierre-Yves David <pierre-yves.david@logilab.fr>
parents:
20033
diff
changeset
|
262 cwd = self._cwd |
10282
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
263 if cwd == self._root: |
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
264 return '' |
4614
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
265 # self._root ends with a path separator if self._root is '/' or 'C:\' |
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
266 rootsep = self._root |
5843
83c354c4d529
Add endswithsep() and use it instead of using os.sep and os.altsep directly.
Shun-ichi GOTO <shunichi.goto@gmail.com>
parents:
5842
diff
changeset
|
267 if not util.endswithsep(rootsep): |
4230
c93562fb12cc
Fix handling of paths when run outside the repo.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4229
diff
changeset
|
268 rootsep += os.sep |
c93562fb12cc
Fix handling of paths when run outside the repo.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4229
diff
changeset
|
269 if cwd.startswith(rootsep): |
c93562fb12cc
Fix handling of paths when run outside the repo.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4229
diff
changeset
|
270 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
|
271 else: |
c93562fb12cc
Fix handling of paths when run outside the repo.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4229
diff
changeset
|
272 # we're outside the repo. return an absolute path. |
c93562fb12cc
Fix handling of paths when run outside the repo.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4229
diff
changeset
|
273 return cwd |
870
a82eae840447
Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents:
839
diff
changeset
|
274 |
4525
78b6add1f966
Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4507
diff
changeset
|
275 def pathto(self, f, cwd=None): |
78b6add1f966
Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4507
diff
changeset
|
276 if cwd is None: |
78b6add1f966
Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4507
diff
changeset
|
277 cwd = self.getcwd() |
4614
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
278 path = util.pathto(self._root, cwd, f) |
4527
b422b558015b
Add ui.slash hgrc setting
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4525
diff
changeset
|
279 if self._slash: |
19210
865beb849720
dirstate: don't overnormalize for ui.slash
Matt Mackall <mpm@selenic.com>
parents:
19128
diff
changeset
|
280 return util.pconvert(path) |
4527
b422b558015b
Add ui.slash hgrc setting
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4525
diff
changeset
|
281 return path |
4525
78b6add1f966
Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4507
diff
changeset
|
282 |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
283 def __getitem__(self, key): |
9518
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
284 '''Return the current state of key (a filename) in the dirstate. |
10145
aec936051734
dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents:
9678
diff
changeset
|
285 |
9518
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
286 States are: |
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
287 n normal |
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
288 m needs merging |
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
289 r marked for removal |
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
290 a marked for addition |
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
291 ? not tracked |
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
292 ''' |
4906
30847b8af7ca
dirstate: add __contains__ and make __getitem__ more useful
Matt Mackall <mpm@selenic.com>
parents:
4905
diff
changeset
|
293 return self._map.get(key, ("?",))[0] |
220 | 294 |
295 def __contains__(self, key): | |
4614
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
296 return key in self._map |
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
297 |
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
298 def __iter__(self): |
8209
a1a5a57efe90
replace util.sort with sorted built-in
Matt Mackall <mpm@selenic.com>
parents:
8151
diff
changeset
|
299 for x in sorted(self._map): |
4614
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
300 yield x |
220 | 301 |
18792
10669e24eb6c
completion: add a debugpathcomplete command
Bryan O'Sullivan <bryano@fb.com>
parents:
18760
diff
changeset
|
302 def iteritems(self): |
10669e24eb6c
completion: add a debugpathcomplete command
Bryan O'Sullivan <bryano@fb.com>
parents:
18760
diff
changeset
|
303 return self._map.iteritems() |
10669e24eb6c
completion: add a debugpathcomplete command
Bryan O'Sullivan <bryano@fb.com>
parents:
18760
diff
changeset
|
304 |
227 | 305 def parents(self): |
13032
e41e2b79883d
dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents:
12907
diff
changeset
|
306 return [self._validate(p) for p in self._pl] |
227 | 307 |
13876
10c7d92ac482
dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents:
13763
diff
changeset
|
308 def p1(self): |
10c7d92ac482
dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents:
13763
diff
changeset
|
309 return self._validate(self._pl[0]) |
10c7d92ac482
dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents:
13763
diff
changeset
|
310 |
10c7d92ac482
dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents:
13763
diff
changeset
|
311 def p2(self): |
10c7d92ac482
dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents:
13763
diff
changeset
|
312 return self._validate(self._pl[1]) |
10c7d92ac482
dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents:
13763
diff
changeset
|
313 |
4179
7e1c8a565a4f
Move branch read/write to dirstate where it belongs
Matt Mackall <mpm@selenic.com>
parents:
4172
diff
changeset
|
314 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
|
315 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
|
316 |
1062 | 317 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
|
318 """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
|
319 |
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16542
diff
changeset
|
320 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
|
321 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
|
322 returned by the call. |
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16542
diff
changeset
|
323 |
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16542
diff
changeset
|
324 See localrepo.setparents() |
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16542
diff
changeset
|
325 """ |
22407
d259322a394b
dirstate: add exception when calling setparent without begin/end (API)
Durham Goode <durham@fb.com>
parents:
22404
diff
changeset
|
326 if self._parentwriters == 0: |
22459
0c7b018d3258
dirstate: copyedit exception for no beginparentchange call
Siddharth Agarwal <sid0@fb.com>
parents:
22407
diff
changeset
|
327 raise ValueError("cannot set dirstate parent without " |
0c7b018d3258
dirstate: copyedit exception for no beginparentchange call
Siddharth Agarwal <sid0@fb.com>
parents:
22407
diff
changeset
|
328 "calling dirstate.beginparentchange") |
22407
d259322a394b
dirstate: add exception when calling setparent without begin/end (API)
Durham Goode <durham@fb.com>
parents:
22404
diff
changeset
|
329 |
4965 | 330 self._dirty = self._dirtypl = True |
16509
eab9119c5dee
rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents:
16472
diff
changeset
|
331 oldp2 = self._pl[1] |
4614
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
332 self._pl = p1, p2 |
16551
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16542
diff
changeset
|
333 copies = {} |
16509
eab9119c5dee
rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents:
16472
diff
changeset
|
334 if oldp2 != nullid and p2 == nullid: |
eab9119c5dee
rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents:
16472
diff
changeset
|
335 for f, s in self._map.iteritems(): |
22895
dfa44e25bb53
dirstate: properly clean-up some more merge state on setparents
Matt Mackall <mpm@selenic.com>
parents:
22782
diff
changeset
|
336 # 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
|
337 if s[0] == 'm': |
16551
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16542
diff
changeset
|
338 if f in self._copymap: |
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16542
diff
changeset
|
339 copies[f] = self._copymap[f] |
16509
eab9119c5dee
rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents:
16472
diff
changeset
|
340 self.normallookup(f) |
22895
dfa44e25bb53
dirstate: properly clean-up some more merge state on setparents
Matt Mackall <mpm@selenic.com>
parents:
22782
diff
changeset
|
341 # 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
|
342 elif s[0] == 'n' and s[2] == -2: |
dfa44e25bb53
dirstate: properly clean-up some more merge state on setparents
Matt Mackall <mpm@selenic.com>
parents:
22782
diff
changeset
|
343 if f in self._copymap: |
dfa44e25bb53
dirstate: properly clean-up some more merge state on setparents
Matt Mackall <mpm@selenic.com>
parents:
22782
diff
changeset
|
344 copies[f] = self._copymap[f] |
dfa44e25bb53
dirstate: properly clean-up some more merge state on setparents
Matt Mackall <mpm@selenic.com>
parents:
22782
diff
changeset
|
345 self.add(f) |
16551
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16542
diff
changeset
|
346 return copies |
227 | 347 |
4179
7e1c8a565a4f
Move branch read/write to dirstate where it belongs
Matt Mackall <mpm@selenic.com>
parents:
4172
diff
changeset
|
348 def setbranch(self, branch): |
13047
6c375e07d673
branch: operate on branch names in local string space where possible
Matt Mackall <mpm@selenic.com>
parents:
13032
diff
changeset
|
349 self._branch = encoding.fromlocal(branch) |
16472
14a4e17f0817
dirstate: write branch file atomically
Idan Kamara <idankk86@gmail.com>
parents:
16323
diff
changeset
|
350 f = self._opener('branch', 'w', atomictemp=True) |
14a4e17f0817
dirstate: write branch file atomically
Idan Kamara <idankk86@gmail.com>
parents:
16323
diff
changeset
|
351 try: |
14a4e17f0817
dirstate: write branch file atomically
Idan Kamara <idankk86@gmail.com>
parents:
16323
diff
changeset
|
352 f.write(self._branch + '\n') |
14a4e17f0817
dirstate: write branch file atomically
Idan Kamara <idankk86@gmail.com>
parents:
16323
diff
changeset
|
353 f.close() |
18317
365fecd984c7
dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents:
18078
diff
changeset
|
354 |
365fecd984c7
dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents:
18078
diff
changeset
|
355 # 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
|
356 # replacing the underlying file |
365fecd984c7
dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents:
18078
diff
changeset
|
357 ce = self._filecache['_branch'] |
365fecd984c7
dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents:
18078
diff
changeset
|
358 if ce: |
365fecd984c7
dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents:
18078
diff
changeset
|
359 ce.refresh() |
18076
3bc21f6daac4
dirstate: don't rename branch file if writing it failed
Idan Kamara <idankk86@gmail.com>
parents:
17984
diff
changeset
|
360 except: # re-raises |
3bc21f6daac4
dirstate: don't rename branch file if writing it failed
Idan Kamara <idankk86@gmail.com>
parents:
17984
diff
changeset
|
361 f.discard() |
3bc21f6daac4
dirstate: don't rename branch file if writing it failed
Idan Kamara <idankk86@gmail.com>
parents:
17984
diff
changeset
|
362 raise |
4179
7e1c8a565a4f
Move branch read/write to dirstate where it belongs
Matt Mackall <mpm@selenic.com>
parents:
4172
diff
changeset
|
363 |
26635
79d86ab65c9d
dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26634
diff
changeset
|
364 def _opendirstatefile(self): |
79d86ab65c9d
dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26634
diff
changeset
|
365 fp, mode = _trypending(self._root, self._opener, self._filename) |
79d86ab65c9d
dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26634
diff
changeset
|
366 if self._pendingmode is not None and self._pendingmode != mode: |
79d86ab65c9d
dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26634
diff
changeset
|
367 fp.close() |
79d86ab65c9d
dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26634
diff
changeset
|
368 raise error.Abort(_('working directory state may be ' |
79d86ab65c9d
dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26634
diff
changeset
|
369 'changed parallelly')) |
79d86ab65c9d
dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26634
diff
changeset
|
370 self._pendingmode = mode |
79d86ab65c9d
dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26634
diff
changeset
|
371 return fp |
79d86ab65c9d
dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26634
diff
changeset
|
372 |
4615
9b00b73a5286
dirstate: hide some more internals
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
373 def _read(self): |
4614
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
374 self._map = {} |
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
375 self._copymap = {} |
4607
49dcac6ede26
dirstate: fold parse into read
Matt Mackall <mpm@selenic.com>
parents:
4606
diff
changeset
|
376 try: |
26635
79d86ab65c9d
dirstate: read from pending file under HG_PENDING mode if it exists
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26634
diff
changeset
|
377 fp = self._opendirstatefile() |
25227
fd0f919170d2
dirstate: use open/read of vfs(opener) explicitly instead of read
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
25226
diff
changeset
|
378 try: |
fd0f919170d2
dirstate: use open/read of vfs(opener) explicitly instead of read
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
25226
diff
changeset
|
379 st = fp.read() |
fd0f919170d2
dirstate: use open/read of vfs(opener) explicitly instead of read
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
25226
diff
changeset
|
380 finally: |
fd0f919170d2
dirstate: use open/read of vfs(opener) explicitly instead of read
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
25226
diff
changeset
|
381 fp.close() |
25660
328739ea70c3
global: mass rewrite to use modern exception syntax
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25658
diff
changeset
|
382 except IOError as err: |
10282
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
383 if err.errno != errno.ENOENT: |
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
384 raise |
4607
49dcac6ede26
dirstate: fold parse into read
Matt Mackall <mpm@selenic.com>
parents:
4606
diff
changeset
|
385 return |
49dcac6ede26
dirstate: fold parse into read
Matt Mackall <mpm@selenic.com>
parents:
4606
diff
changeset
|
386 if not st: |
49dcac6ede26
dirstate: fold parse into read
Matt Mackall <mpm@selenic.com>
parents:
4606
diff
changeset
|
387 return |
49dcac6ede26
dirstate: fold parse into read
Matt Mackall <mpm@selenic.com>
parents:
4606
diff
changeset
|
388 |
25585
868b7ee8b570
dirstate: use a presized dict for the dirstate
Siddharth Agarwal <sid0@fb.com>
parents:
25448
diff
changeset
|
389 if util.safehasattr(parsers, 'dict_new_presized'): |
868b7ee8b570
dirstate: use a presized dict for the dirstate
Siddharth Agarwal <sid0@fb.com>
parents:
25448
diff
changeset
|
390 # Make an estimate of the number of files in the dirstate based on |
868b7ee8b570
dirstate: use a presized dict for the dirstate
Siddharth Agarwal <sid0@fb.com>
parents:
25448
diff
changeset
|
391 # its size. From a linear regression on a set of real-world repos, |
868b7ee8b570
dirstate: use a presized dict for the dirstate
Siddharth Agarwal <sid0@fb.com>
parents:
25448
diff
changeset
|
392 # all over 10,000 files, the size of a dirstate entry is 85 |
868b7ee8b570
dirstate: use a presized dict for the dirstate
Siddharth Agarwal <sid0@fb.com>
parents:
25448
diff
changeset
|
393 # bytes. The cost of resizing is significantly higher than the cost |
868b7ee8b570
dirstate: use a presized dict for the dirstate
Siddharth Agarwal <sid0@fb.com>
parents:
25448
diff
changeset
|
394 # of filling in a larger presized dict, so subtract 20% from the |
868b7ee8b570
dirstate: use a presized dict for the dirstate
Siddharth Agarwal <sid0@fb.com>
parents:
25448
diff
changeset
|
395 # size. |
868b7ee8b570
dirstate: use a presized dict for the dirstate
Siddharth Agarwal <sid0@fb.com>
parents:
25448
diff
changeset
|
396 # |
868b7ee8b570
dirstate: use a presized dict for the dirstate
Siddharth Agarwal <sid0@fb.com>
parents:
25448
diff
changeset
|
397 # This heuristic is imperfect in many ways, so in a future dirstate |
868b7ee8b570
dirstate: use a presized dict for the dirstate
Siddharth Agarwal <sid0@fb.com>
parents:
25448
diff
changeset
|
398 # format update it makes sense to just record the number of entries |
868b7ee8b570
dirstate: use a presized dict for the dirstate
Siddharth Agarwal <sid0@fb.com>
parents:
25448
diff
changeset
|
399 # on write. |
868b7ee8b570
dirstate: use a presized dict for the dirstate
Siddharth Agarwal <sid0@fb.com>
parents:
25448
diff
changeset
|
400 self._map = parsers.dict_new_presized(len(st) / 71) |
868b7ee8b570
dirstate: use a presized dict for the dirstate
Siddharth Agarwal <sid0@fb.com>
parents:
25448
diff
changeset
|
401 |
18649
0969980308c7
dirstate: disable gc while parsing the dirstate
Siddharth Agarwal <sid0@fb.com>
parents:
18567
diff
changeset
|
402 # Python's garbage collector triggers a GC each time a certain number |
0969980308c7
dirstate: disable gc while parsing the dirstate
Siddharth Agarwal <sid0@fb.com>
parents:
18567
diff
changeset
|
403 # of container objects (the number being defined by |
0969980308c7
dirstate: disable gc while parsing the dirstate
Siddharth Agarwal <sid0@fb.com>
parents:
18567
diff
changeset
|
404 # gc.get_threshold()) are allocated. parse_dirstate creates a tuple |
0969980308c7
dirstate: disable gc while parsing the dirstate
Siddharth Agarwal <sid0@fb.com>
parents:
18567
diff
changeset
|
405 # for each file in the dirstate. The C version then immediately marks |
0969980308c7
dirstate: disable gc while parsing the dirstate
Siddharth Agarwal <sid0@fb.com>
parents:
18567
diff
changeset
|
406 # them as not to be tracked by the collector. However, this has no |
0969980308c7
dirstate: disable gc while parsing the dirstate
Siddharth Agarwal <sid0@fb.com>
parents:
18567
diff
changeset
|
407 # effect on when GCs are triggered, only on what objects the GC looks |
0969980308c7
dirstate: disable gc while parsing the dirstate
Siddharth Agarwal <sid0@fb.com>
parents:
18567
diff
changeset
|
408 # into. This means that O(number of files) GCs are unavoidable. |
0969980308c7
dirstate: disable gc while parsing the dirstate
Siddharth Agarwal <sid0@fb.com>
parents:
18567
diff
changeset
|
409 # Depending on when in the process's lifetime the dirstate is parsed, |
0969980308c7
dirstate: disable gc while parsing the dirstate
Siddharth Agarwal <sid0@fb.com>
parents:
18567
diff
changeset
|
410 # this can get very expensive. As a workaround, disable GC while |
0969980308c7
dirstate: disable gc while parsing the dirstate
Siddharth Agarwal <sid0@fb.com>
parents:
18567
diff
changeset
|
411 # parsing the dirstate. |
23496
ee5a4ed4c8b1
dirstate: use the 'nogc' decorator
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23375
diff
changeset
|
412 # |
ee5a4ed4c8b1
dirstate: use the 'nogc' decorator
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23375
diff
changeset
|
413 # (we cannot decorate the function directly since it is in a C module) |
ee5a4ed4c8b1
dirstate: use the 'nogc' decorator
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23375
diff
changeset
|
414 parse_dirstate = util.nogc(parsers.parse_dirstate) |
ee5a4ed4c8b1
dirstate: use the 'nogc' decorator
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23375
diff
changeset
|
415 p = parse_dirstate(self._map, self._copymap, st) |
4952
a11921d24ec4
add dirstate._dirtypl variable
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4677
diff
changeset
|
416 if not self._dirtypl: |
7093
16bafcebd3d1
dirstate: C parsing extension
Matt Mackall <mpm@selenic.com>
parents:
7069
diff
changeset
|
417 self._pl = p |
363 | 418 |
4613
3a645af7fb76
localrepo and dirstate: rename reload to invalidate
Matt Mackall <mpm@selenic.com>
parents:
4612
diff
changeset
|
419 def invalidate(self): |
24540
25c1d3ca5ff6
dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents:
24539
diff
changeset
|
420 for a in ("_map", "_copymap", "_filefoldmap", "_dirfoldmap", "_branch", |
25c1d3ca5ff6
dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents:
24539
diff
changeset
|
421 "_pl", "_dirs", "_ignore"): |
4953
6b3ed43f77ba
dirstate.invalidate: avoid rebuilding _map
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4952
diff
changeset
|
422 if a in self.__dict__: |
6b3ed43f77ba
dirstate.invalidate: avoid rebuilding _map
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4952
diff
changeset
|
423 delattr(self, a) |
15791
a814f8fcc65a
Use explicit integer division
Martin Geisler <mg@aragost.com>
parents:
15670
diff
changeset
|
424 self._lastnormaltime = 0 |
4903
81078e177266
dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents:
4677
diff
changeset
|
425 self._dirty = False |
22404
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
426 self._parentwriters = 0 |
4375
109077e7048d
When reloading the dirstate, recompute ignore information if needed.
Bryan O'Sullivan <bos@serpentine.com>
parents:
4374
diff
changeset
|
427 |
363 | 428 def copy(self, source, dest): |
10145
aec936051734
dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents:
9678
diff
changeset
|
429 """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
|
430 if source == dest: |
deda205a00e1
Ignore dummy copies in dirstate and localrepo.filecommit()
Patrick Mezard <pmezard@gmail.com>
parents:
6479
diff
changeset
|
431 return |
4903
81078e177266
dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents:
4677
diff
changeset
|
432 self._dirty = True |
7566
5f7e3f17aece
mq: drop copy records when refreshing regular patches (issue1441)
Patrick Mezard <pmezard@gmail.com>
parents:
7280
diff
changeset
|
433 if source is not None: |
5f7e3f17aece
mq: drop copy records when refreshing regular patches (issue1441)
Patrick Mezard <pmezard@gmail.com>
parents:
7280
diff
changeset
|
434 self._copymap[dest] = source |
5f7e3f17aece
mq: drop copy records when refreshing regular patches (issue1441)
Patrick Mezard <pmezard@gmail.com>
parents:
7280
diff
changeset
|
435 elif dest in self._copymap: |
5f7e3f17aece
mq: drop copy records when refreshing regular patches (issue1441)
Patrick Mezard <pmezard@gmail.com>
parents:
7280
diff
changeset
|
436 del self._copymap[dest] |
363 | 437 |
438 def copied(self, file): | |
4614
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
439 return self._copymap.get(file, None) |
3154
b1f10d3223c1
dirstate: add copies function
Matt Mackall <mpm@selenic.com>
parents:
2962
diff
changeset
|
440 |
b1f10d3223c1
dirstate: add copies function
Matt Mackall <mpm@selenic.com>
parents:
2962
diff
changeset
|
441 def copies(self): |
4614
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
442 return self._copymap |
515 | 443 |
6767
80605a8127e0
dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents:
6762
diff
changeset
|
444 def _droppath(self, f): |
80605a8127e0
dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents:
6762
diff
changeset
|
445 if self[f] not in "?r" and "_dirs" in self.__dict__: |
18899
d8ff607ef721
scmutil: use new dirs class in dirstate and context
Bryan O'Sullivan <bryano@fb.com>
parents:
18897
diff
changeset
|
446 self._dirs.delpath(f) |
2953 | 447 |
17196
2abe975ffb94
dirstate: eliminate redundant check parameter on _addpath()
Adrian Buehlmann <adrian@cadifra.com>
parents:
17094
diff
changeset
|
448 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
|
449 oldstate = self[f] |
17196
2abe975ffb94
dirstate: eliminate redundant check parameter on _addpath()
Adrian Buehlmann <adrian@cadifra.com>
parents:
17094
diff
changeset
|
450 if state == 'a' or oldstate == 'r': |
13974
23f2736abce3
move checkfilename from util to scmutil
Adrian Buehlmann <adrian@cadifra.com>
parents:
13944
diff
changeset
|
451 scmutil.checkfilename(f) |
6767
80605a8127e0
dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents:
6762
diff
changeset
|
452 if f in self._dirs: |
26587
56b2bcea2529
error: get Abort from 'error' instead of 'util'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26521
diff
changeset
|
453 raise error.Abort(_('directory %r already in dirstate') % f) |
6767
80605a8127e0
dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents:
6762
diff
changeset
|
454 # shadows |
24635
21e1ece30f8c
util: move dirs() and finddirs() from scmutil to util
Drew Gottlieb <drgott@google.com>
parents:
24632
diff
changeset
|
455 for d in util.finddirs(f): |
6767
80605a8127e0
dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents:
6762
diff
changeset
|
456 if d in self._dirs: |
80605a8127e0
dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents:
6762
diff
changeset
|
457 break |
80605a8127e0
dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents:
6762
diff
changeset
|
458 if d in self._map and self[d] != 'r': |
26587
56b2bcea2529
error: get Abort from 'error' instead of 'util'
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
26521
diff
changeset
|
459 raise error.Abort( |
6767
80605a8127e0
dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents:
6762
diff
changeset
|
460 _('file %r in dirstate clashes with %r') % (d, f)) |
80605a8127e0
dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents:
6762
diff
changeset
|
461 if oldstate in "?r" and "_dirs" in self.__dict__: |
18899
d8ff607ef721
scmutil: use new dirs class in dirstate and context
Bryan O'Sullivan <bryano@fb.com>
parents:
18897
diff
changeset
|
462 self._dirs.addpath(f) |
17094
c2016bae3b97
dirstate: factor common update code into _addpath
Joshua Redstone <joshua.redstone@fb.com>
parents:
16955
diff
changeset
|
463 self._dirty = True |
21808
7537e57f5dbd
dirstate: add dirstatetuple to create dirstate values
Siddharth Agarwal <sid0@fb.com>
parents:
21116
diff
changeset
|
464 self._map[f] = dirstatetuple(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
|
465 |
4904
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4903
diff
changeset
|
466 def normal(self, f): |
10145
aec936051734
dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents:
9678
diff
changeset
|
467 '''Mark a file normal and clean.''' |
4905
fc61495ea9cf
dirstate: make wjoin function private
Matt Mackall <mpm@selenic.com>
parents:
4904
diff
changeset
|
468 s = os.lstat(self._join(f)) |
26492
3a0bb61371c5
util: extract stub function to get mtime with second accuracy
Yuya Nishihara <yuya@tcha.org>
parents:
26294
diff
changeset
|
469 mtime = util.statmtimesec(s) |
17733
3c775c5a6c03
dirstate: handle large dates and times with masking (issue2608)
Matt Mackall <mpm@selenic.com>
parents:
17197
diff
changeset
|
470 self._addpath(f, 'n', s.st_mode, |
3c775c5a6c03
dirstate: handle large dates and times with masking (issue2608)
Matt Mackall <mpm@selenic.com>
parents:
17197
diff
changeset
|
471 s.st_size & _rangemask, mtime & _rangemask) |
5915
d0576d065993
Prefer i in d over d.has_key(i)
Christian Ebert <blacktrash@gmx.net>
parents:
5843
diff
changeset
|
472 if f in self._copymap: |
4904
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4903
diff
changeset
|
473 del self._copymap[f] |
13763
7a73c406c0fd
dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents:
13754
diff
changeset
|
474 if mtime > self._lastnormaltime: |
7a73c406c0fd
dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents:
13754
diff
changeset
|
475 # 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
|
476 # 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
|
477 # modifications that happen within the same timeslot. |
13763
7a73c406c0fd
dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents:
13754
diff
changeset
|
478 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
|
479 |
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
|
480 def normallookup(self, f): |
10145
aec936051734
dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents:
9678
diff
changeset
|
481 '''Mark a file normal, but possibly dirty.''' |
6298
53cbb33e1269
normallookup: during merges, restore the state saved by remove
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
6297
diff
changeset
|
482 if self._pl[1] != nullid and f in self._map: |
53cbb33e1269
normallookup: during merges, restore the state saved by remove
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
6297
diff
changeset
|
483 # 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
|
484 # 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
|
485 # being removed, restore that state. |
6298
53cbb33e1269
normallookup: during merges, restore the state saved by remove
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
6297
diff
changeset
|
486 entry = self._map[f] |
53cbb33e1269
normallookup: during merges, restore the state saved by remove
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
6297
diff
changeset
|
487 if entry[0] == 'r' and entry[2] in (-1, -2): |
53cbb33e1269
normallookup: during merges, restore the state saved by remove
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
6297
diff
changeset
|
488 source = self._copymap.get(f) |
53cbb33e1269
normallookup: during merges, restore the state saved by remove
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
6297
diff
changeset
|
489 if entry[2] == -1: |
53cbb33e1269
normallookup: during merges, restore the state saved by remove
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
6297
diff
changeset
|
490 self.merge(f) |
53cbb33e1269
normallookup: during merges, restore the state saved by remove
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
6297
diff
changeset
|
491 elif entry[2] == -2: |
10968
7a0d096e221e
dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10935
diff
changeset
|
492 self.otherparent(f) |
6298
53cbb33e1269
normallookup: during merges, restore the state saved by remove
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
6297
diff
changeset
|
493 if source: |
53cbb33e1269
normallookup: during merges, restore the state saved by remove
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
6297
diff
changeset
|
494 self.copy(source, f) |
53cbb33e1269
normallookup: during merges, restore the state saved by remove
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
6297
diff
changeset
|
495 return |
53cbb33e1269
normallookup: during merges, restore the state saved by remove
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
6297
diff
changeset
|
496 if entry[0] == 'm' or entry[0] == 'n' and entry[2] == -2: |
53cbb33e1269
normallookup: during merges, restore the state saved by remove
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
6297
diff
changeset
|
497 return |
17094
c2016bae3b97
dirstate: factor common update code into _addpath
Joshua Redstone <joshua.redstone@fb.com>
parents:
16955
diff
changeset
|
498 self._addpath(f, 'n', 0, -1, -1) |
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
|
499 if f in self._copymap: |
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
|
500 del self._copymap[f] |
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
|
501 |
10968
7a0d096e221e
dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10935
diff
changeset
|
502 def otherparent(self, f): |
7a0d096e221e
dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10935
diff
changeset
|
503 '''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
|
504 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
|
505 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
|
506 "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
|
507 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
|
508 # merge-like |
7e9cbb9c6053
dirstate: use 'm' state in otherparent to reduce ambiguity
Matt Mackall <mpm@selenic.com>
parents:
22895
diff
changeset
|
509 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
|
510 else: |
7e9cbb9c6053
dirstate: use 'm' state in otherparent to reduce ambiguity
Matt Mackall <mpm@selenic.com>
parents:
22895
diff
changeset
|
511 # add-like |
7e9cbb9c6053
dirstate: use 'm' state in otherparent to reduce ambiguity
Matt Mackall <mpm@selenic.com>
parents:
22895
diff
changeset
|
512 self._addpath(f, 'n', 0, -2, -1) |
7e9cbb9c6053
dirstate: use 'm' state in otherparent to reduce ambiguity
Matt Mackall <mpm@selenic.com>
parents:
22895
diff
changeset
|
513 |
4904
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4903
diff
changeset
|
514 if f in self._copymap: |
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4903
diff
changeset
|
515 del self._copymap[f] |
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4903
diff
changeset
|
516 |
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4903
diff
changeset
|
517 def add(self, f): |
10145
aec936051734
dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents:
9678
diff
changeset
|
518 '''Mark a file added.''' |
17196
2abe975ffb94
dirstate: eliminate redundant check parameter on _addpath()
Adrian Buehlmann <adrian@cadifra.com>
parents:
17094
diff
changeset
|
519 self._addpath(f, 'a', 0, -1, -1) |
4904
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4903
diff
changeset
|
520 if f in self._copymap: |
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4903
diff
changeset
|
521 del self._copymap[f] |
4616
70352337934e
dirstate: refactor checkinterfering
Matt Mackall <mpm@selenic.com>
parents:
4615
diff
changeset
|
522 |
4904
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4903
diff
changeset
|
523 def remove(self, f): |
10145
aec936051734
dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents:
9678
diff
changeset
|
524 '''Mark a file removed.''' |
4904
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4903
diff
changeset
|
525 self._dirty = True |
6767
80605a8127e0
dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents:
6762
diff
changeset
|
526 self._droppath(f) |
6297
fed1a9c22076
dirstate.remove: during merges, remember the previous file state
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
6257
diff
changeset
|
527 size = 0 |
fed1a9c22076
dirstate.remove: during merges, remember the previous file state
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
6257
diff
changeset
|
528 if self._pl[1] != nullid and f in self._map: |
10968
7a0d096e221e
dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10935
diff
changeset
|
529 # backup the previous state |
6297
fed1a9c22076
dirstate.remove: during merges, remember the previous file state
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
6257
diff
changeset
|
530 entry = self._map[f] |
10968
7a0d096e221e
dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10935
diff
changeset
|
531 if entry[0] == 'm': # merge |
6297
fed1a9c22076
dirstate.remove: during merges, remember the previous file state
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
6257
diff
changeset
|
532 size = -1 |
10968
7a0d096e221e
dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10935
diff
changeset
|
533 elif entry[0] == 'n' and entry[2] == -2: # other parent |
6297
fed1a9c22076
dirstate.remove: during merges, remember the previous file state
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
6257
diff
changeset
|
534 size = -2 |
21808
7537e57f5dbd
dirstate: add dirstatetuple to create dirstate values
Siddharth Agarwal <sid0@fb.com>
parents:
21116
diff
changeset
|
535 self._map[f] = dirstatetuple('r', 0, size, 0) |
6297
fed1a9c22076
dirstate.remove: during merges, remember the previous file state
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
6257
diff
changeset
|
536 if size == 0 and f in self._copymap: |
4904
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4903
diff
changeset
|
537 del self._copymap[f] |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
538 |
4904
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4903
diff
changeset
|
539 def merge(self, f): |
10145
aec936051734
dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents:
9678
diff
changeset
|
540 '''Mark a file merged.''' |
16509
eab9119c5dee
rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents:
16472
diff
changeset
|
541 if self._pl[1] == nullid: |
eab9119c5dee
rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents:
16472
diff
changeset
|
542 return self.normallookup(f) |
22897
8fe74328f700
dirstate: merge falls through to otherparent
Matt Mackall <mpm@selenic.com>
parents:
22896
diff
changeset
|
543 return self.otherparent(f) |
4904
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4903
diff
changeset
|
544 |
14434
cc8c09855d19
dirstate: rename forget to drop
Matt Mackall <mpm@selenic.com>
parents:
14273
diff
changeset
|
545 def drop(self, f): |
cc8c09855d19
dirstate: rename forget to drop
Matt Mackall <mpm@selenic.com>
parents:
14273
diff
changeset
|
546 '''Drop a file from the dirstate''' |
15399
41453d55b481
dirstate: don't fail when dropping a not-tracked file (issue3080)
Matt Mackall <mpm@selenic.com>
parents:
15337
diff
changeset
|
547 if f in self._map: |
41453d55b481
dirstate: don't fail when dropping a not-tracked file (issue3080)
Matt Mackall <mpm@selenic.com>
parents:
15337
diff
changeset
|
548 self._dirty = True |
41453d55b481
dirstate: don't fail when dropping a not-tracked file (issue3080)
Matt Mackall <mpm@selenic.com>
parents:
15337
diff
changeset
|
549 self._droppath(f) |
41453d55b481
dirstate: don't fail when dropping a not-tracked file (issue3080)
Matt Mackall <mpm@selenic.com>
parents:
15337
diff
changeset
|
550 del self._map[f] |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
551 |
24538
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
552 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
|
553 if exists is None: |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
554 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
|
555 if not exists: |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
556 # Maybe a path component exists |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
557 if not ignoremissing and '/' in path: |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
558 d, f = path.rsplit('/', 1) |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
559 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
|
560 folded = d + "/" + f |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
561 else: |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
562 # No path components, preserve original case |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
563 folded = path |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
564 else: |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
565 # recursively normalize leading directory components |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
566 # against dirstate |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
567 if '/' in normed: |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
568 d, f = normed.rsplit('/', 1) |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
569 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
|
570 r = self._root + "/" + d |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
571 folded = d + "/" + util.fspath(f, r) |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
572 else: |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
573 folded = util.fspath(normed, self._root) |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
574 storemap[normed] = folded |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
575 |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
576 return folded |
24df92075200
dirstate: factor out code to discover normalized path
Siddharth Agarwal <sid0@fb.com>
parents:
24523
diff
changeset
|
577 |
24539
3a8eba78803e
dirstate: introduce function to normalize just filenames
Siddharth Agarwal <sid0@fb.com>
parents:
24538
diff
changeset
|
578 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
|
579 normed = util.normcase(path) |
24540
25c1d3ca5ff6
dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents:
24539
diff
changeset
|
580 folded = self._filefoldmap.get(normed, None) |
13717
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
581 if folded is None: |
16542
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
582 if isknown: |
13717
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
583 folded = path |
7068
57377fa7eda2
issue 1286: dirstat regression on case folding systems
Petr Kodl <petrkodl@gmail.com>
parents:
7034
diff
changeset
|
584 else: |
24539
3a8eba78803e
dirstate: introduce function to normalize just filenames
Siddharth Agarwal <sid0@fb.com>
parents:
24538
diff
changeset
|
585 folded = self._discoverpath(path, normed, ignoremissing, exists, |
24540
25c1d3ca5ff6
dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents:
24539
diff
changeset
|
586 self._filefoldmap) |
24539
3a8eba78803e
dirstate: introduce function to normalize just filenames
Siddharth Agarwal <sid0@fb.com>
parents:
24538
diff
changeset
|
587 return folded |
16302
49b54f1ae053
dirstate: normalize case of directory components
Matt Mackall <mpm@selenic.com>
parents:
16258
diff
changeset
|
588 |
16542
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
589 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
|
590 normed = util.normcase(path) |
24561
6514030dc686
dirstate._normalize: don't construct dirfoldmap if not necessary
Siddharth Agarwal <sid0@fb.com>
parents:
24560
diff
changeset
|
591 folded = self._filefoldmap.get(normed, None) |
6514030dc686
dirstate._normalize: don't construct dirfoldmap if not necessary
Siddharth Agarwal <sid0@fb.com>
parents:
24560
diff
changeset
|
592 if folded is None: |
6514030dc686
dirstate._normalize: don't construct dirfoldmap if not necessary
Siddharth Agarwal <sid0@fb.com>
parents:
24560
diff
changeset
|
593 folded = self._dirfoldmap.get(normed, None) |
13717
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
594 if folded is None: |
16542
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
595 if isknown: |
13717
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
596 folded = path |
7068
57377fa7eda2
issue 1286: dirstat regression on case folding systems
Petr Kodl <petrkodl@gmail.com>
parents:
7034
diff
changeset
|
597 else: |
24540
25c1d3ca5ff6
dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents:
24539
diff
changeset
|
598 # 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
|
599 # 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
|
600 folded = self._discoverpath(path, normed, ignoremissing, exists, |
24540
25c1d3ca5ff6
dirstate: split the foldmap into separate ones for files and directories
Siddharth Agarwal <sid0@fb.com>
parents:
24539
diff
changeset
|
601 self._dirfoldmap) |
13717
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
602 return folded |
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
603 |
16542
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
604 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
|
605 ''' |
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
606 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
|
607 |
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
608 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
|
609 disk, to avoid extra filesystem access. |
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
610 |
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
611 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
|
612 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
|
613 existing path components. |
13717
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
614 |
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
615 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
|
616 |
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
617 - 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
|
618 - version of name stored on disk |
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
619 - version provided via command arguments |
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
620 ''' |
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
621 |
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
622 if self._checkcase: |
16542
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
623 return self._normalize(path, isknown, ignoremissing) |
13717
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
624 return path |
6677
9865e15febd0
Add a normalize() method to dirstate
Paul Moore <p.f.moore@gmail.com>
parents:
6675
diff
changeset
|
625 |
5065
b304c2496f52
dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4953
diff
changeset
|
626 def clear(self): |
b304c2496f52
dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4953
diff
changeset
|
627 self._map = {} |
5487
7a64931e2d76
Fix file-changed-to-dir and dir-to-file commits (issue660).
Maxim Dounin <mdounin@mdounin.ru>
parents:
5396
diff
changeset
|
628 if "_dirs" in self.__dict__: |
10394
4612cded5176
fix coding style (reported by pylint)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10282
diff
changeset
|
629 delattr(self, "_dirs") |
5065
b304c2496f52
dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4953
diff
changeset
|
630 self._copymap = {} |
b304c2496f52
dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4953
diff
changeset
|
631 self._pl = [nullid, nullid] |
15791
a814f8fcc65a
Use explicit integer division
Martin Geisler <mg@aragost.com>
parents:
15670
diff
changeset
|
632 self._lastnormaltime = 0 |
5123 | 633 self._dirty = True |
5065
b304c2496f52
dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4953
diff
changeset
|
634 |
18760
e74704c33e24
strip: make --keep option not set all dirstate times to 0
Durham Goode <durham@fb.com>
parents:
18663
diff
changeset
|
635 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
|
636 if changedfiles is None: |
2bbfc2042d93
dirstate: avoid invalidating every entries when list is empty
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
25275
diff
changeset
|
637 changedfiles = allfiles |
18760
e74704c33e24
strip: make --keep option not set all dirstate times to 0
Durham Goode <durham@fb.com>
parents:
18663
diff
changeset
|
638 oldmap = self._map |
5065
b304c2496f52
dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4953
diff
changeset
|
639 self.clear() |
18760
e74704c33e24
strip: make --keep option not set all dirstate times to 0
Durham Goode <durham@fb.com>
parents:
18663
diff
changeset
|
640 for f in allfiles: |
e74704c33e24
strip: make --keep option not set all dirstate times to 0
Durham Goode <durham@fb.com>
parents:
18663
diff
changeset
|
641 if f not in changedfiles: |
e74704c33e24
strip: make --keep option not set all dirstate times to 0
Durham Goode <durham@fb.com>
parents:
18663
diff
changeset
|
642 self._map[f] = oldmap[f] |
1755
a8f7791e3680
add 'debugrebuildstate' to rebuild the dirstate from a given revision
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1749
diff
changeset
|
643 else: |
18760
e74704c33e24
strip: make --keep option not set all dirstate times to 0
Durham Goode <durham@fb.com>
parents:
18663
diff
changeset
|
644 if 'x' in allfiles.flags(f): |
25658
e93036747902
global: mass rewrite to use modern octal syntax
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25585
diff
changeset
|
645 self._map[f] = dirstatetuple('n', 0o777, -1, 0) |
18760
e74704c33e24
strip: make --keep option not set all dirstate times to 0
Durham Goode <durham@fb.com>
parents:
18663
diff
changeset
|
646 else: |
25658
e93036747902
global: mass rewrite to use modern octal syntax
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25585
diff
changeset
|
647 self._map[f] = dirstatetuple('n', 0o666, -1, 0) |
4614
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
648 self._pl = (parent, nullid) |
4903
81078e177266
dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents:
4677
diff
changeset
|
649 self._dirty = True |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
650 |
26747
beff0b2481b3
dirstate: remove layering violation around writing dirstate out
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26746
diff
changeset
|
651 def write(self, tr=False): |
4612
17ee7407097f
dirstate: simplify dirty handling
Matt Mackall <mpm@selenic.com>
parents:
4611
diff
changeset
|
652 if not self._dirty: |
1794
98b6c1cad58b
only write the dirstate when something changed
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1755
diff
changeset
|
653 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
|
654 |
89b809fa6cef
dirstate: delay writing out to ensure timestamp of each entries explicitly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
21810
diff
changeset
|
655 # enough 'delaywrite' prevents 'pack_dirstate' from dropping |
89b809fa6cef
dirstate: delay writing out to ensure timestamp of each entries explicitly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
21810
diff
changeset
|
656 # timestamp of each entries in dirstate, because of 'now > mtime' |
89b809fa6cef
dirstate: delay writing out to ensure timestamp of each entries explicitly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
21810
diff
changeset
|
657 delaywrite = self._ui.configint('debug', 'dirstate.delaywrite', 0) |
23866
9dd442148301
dirstate: ignore negative debug.dirstate.delaywrite values - they crashed it
Mads Kiilerich <madski@unity3d.com>
parents:
23629
diff
changeset
|
658 if delaywrite > 0: |
21931
89b809fa6cef
dirstate: delay writing out to ensure timestamp of each entries explicitly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
21810
diff
changeset
|
659 import time # to avoid useless import |
89b809fa6cef
dirstate: delay writing out to ensure timestamp of each entries explicitly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
21810
diff
changeset
|
660 time.sleep(delaywrite) |
89b809fa6cef
dirstate: delay writing out to ensure timestamp of each entries explicitly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
21810
diff
changeset
|
661 |
26634
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
662 filename = self._filename |
26747
beff0b2481b3
dirstate: remove layering violation around writing dirstate out
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26746
diff
changeset
|
663 if tr is False: # not explicitly specified |
26749
4a82cb5c1dc8
dirstate: show develwarn for write() invocation without transaction
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26747
diff
changeset
|
664 if (self._ui.configbool('devel', 'all-warnings') |
26782
cbd04ce641b9
dirstate: fix invalid reference to self.ui
James Mills <prologic@fb.com>
parents:
26781
diff
changeset
|
665 or self._ui.configbool('devel', 'check-dirstate-write')): |
26749
4a82cb5c1dc8
dirstate: show develwarn for write() invocation without transaction
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26747
diff
changeset
|
666 self._ui.develwarn('use dirstate.write with ' |
4a82cb5c1dc8
dirstate: show develwarn for write() invocation without transaction
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26747
diff
changeset
|
667 'repo.currenttransaction()') |
4a82cb5c1dc8
dirstate: show develwarn for write() invocation without transaction
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26747
diff
changeset
|
668 |
26634
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
669 if self._opener.lexists(self._pendingfilename): |
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
670 # if pending file already exists, in-memory changes |
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
671 # should be written into it, because it has priority |
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
672 # to '.hg/dirstate' at reading under HG_PENDING mode |
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
673 filename = self._pendingfilename |
26747
beff0b2481b3
dirstate: remove layering violation around writing dirstate out
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26746
diff
changeset
|
674 elif tr: |
26634
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
675 # '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
|
676 # 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
|
677 # 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
|
678 # 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
|
679 # 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
|
680 |
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
681 # 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
|
682 now = _getfsnow(self._opener) |
26634
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
683 dmap = self._map |
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
684 for f, e in dmap.iteritems(): |
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
685 if e[0] == 'n' and e[3] == now: |
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
686 dmap[f] = dirstatetuple(e[0], e[1], e[2], -1) |
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
687 |
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
688 # 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
|
689 self._lastnormaltime = 0 |
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
690 |
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
691 # 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
|
692 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
|
693 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
|
694 return |
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
695 |
09bb1ee7e73e
dirstate: make writing in-memory changes aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26633
diff
changeset
|
696 st = self._opener(filename, "w", atomictemp=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
|
697 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
|
698 |
3f41e28a16d8
dirstate: split write to write changes into files other than .hg/dirstate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26492
diff
changeset
|
699 def _writedirstate(self, st): |
9509
e4ca8c258d9b
dirstate: kill dirstate.granularity config option
Adrian Buehlmann <adrian@cadifra.com>
parents:
9379
diff
changeset
|
700 # 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
|
701 # filesystem's notion of 'now' |
26630
3111b45a2bbf
parsers: make pack_dirstate take now in integer for consistency
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26592
diff
changeset
|
702 now = util.statmtimesec(util.fstat(st)) & _rangemask |
21026
7ee03e190c1d
dirstate: inline local finish function
Mads Kiilerich <madski@unity3d.com>
parents:
20632
diff
changeset
|
703 st.write(parsers.pack_dirstate(self._map, self._copymap, self._pl, now)) |
7ee03e190c1d
dirstate: inline local finish function
Mads Kiilerich <madski@unity3d.com>
parents:
20632
diff
changeset
|
704 st.close() |
7ee03e190c1d
dirstate: inline local finish function
Mads Kiilerich <madski@unity3d.com>
parents:
20632
diff
changeset
|
705 self._lastnormaltime = 0 |
7ee03e190c1d
dirstate: inline local finish function
Mads Kiilerich <madski@unity3d.com>
parents:
20632
diff
changeset
|
706 self._dirty = self._dirtypl = False |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
707 |
6032
b41f0d6a74fc
dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5516
diff
changeset
|
708 def _dirignore(self, f): |
6479
31abcae33b4f
dirstate: do not ignore current directory '.' (issue 1078)
Patrick Mezard <pmezard@gmail.com>
parents:
6327
diff
changeset
|
709 if f == '.': |
31abcae33b4f
dirstate: do not ignore current directory '.' (issue 1078)
Patrick Mezard <pmezard@gmail.com>
parents:
6327
diff
changeset
|
710 return False |
6032
b41f0d6a74fc
dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5516
diff
changeset
|
711 if self._ignore(f): |
b41f0d6a74fc
dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5516
diff
changeset
|
712 return True |
24635
21e1ece30f8c
util: move dirs() and finddirs() from scmutil to util
Drew Gottlieb <drgott@google.com>
parents:
24632
diff
changeset
|
713 for p in util.finddirs(f): |
6767
80605a8127e0
dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents:
6762
diff
changeset
|
714 if self._ignore(p): |
6032
b41f0d6a74fc
dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5516
diff
changeset
|
715 return True |
b41f0d6a74fc
dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5516
diff
changeset
|
716 return False |
b41f0d6a74fc
dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5516
diff
changeset
|
717 |
19173
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
718 def _walkexplicit(self, match, subrepos): |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
719 '''Get stat data about the files explicitly specified by match. |
3529 | 720 |
19174
022256ef47b8
dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents:
19173
diff
changeset
|
721 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
|
722 - 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
|
723 listings mapping subrepos and .hg to None. |
19174
022256ef47b8
dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents:
19173
diff
changeset
|
724 - 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
|
725 - 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
|
726 directories and that were not found.''' |
6578
f242d3684f83
walk: begin refactoring badmatch handling
Matt Mackall <mpm@selenic.com>
parents:
6577
diff
changeset
|
727 |
8681
26f133267cd7
walk: use match.bad callback for filetype messages
Matt Mackall <mpm@selenic.com>
parents:
8680
diff
changeset
|
728 def badtype(mode): |
8310
8417d82d3969
dirstate: translate forgotten string
Simon Heimberg <simohe@besonet.ch>
parents:
8261
diff
changeset
|
729 kind = _('unknown') |
10282
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
730 if stat.S_ISCHR(mode): |
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
731 kind = _('character device') |
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
732 elif stat.S_ISBLK(mode): |
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
733 kind = _('block device') |
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
734 elif stat.S_ISFIFO(mode): |
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
735 kind = _('fifo') |
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
736 elif stat.S_ISSOCK(mode): |
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
737 kind = _('socket') |
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
738 elif stat.S_ISDIR(mode): |
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
739 kind = _('directory') |
8681
26f133267cd7
walk: use match.bad callback for filetype messages
Matt Mackall <mpm@selenic.com>
parents:
8680
diff
changeset
|
740 return _('unsupported file type (type is %s)') % kind |
6830
2cf4cda64727
dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents:
6829
diff
changeset
|
741 |
19142
c3d3e4d75ec3
dirstate.walk: cache match.explicitdir and traversedir locally
Siddharth Agarwal <sid0@fb.com>
parents:
19137
diff
changeset
|
742 matchedir = match.explicitdir |
8676
acd69fc201a5
walk: we always have a badfn
Matt Mackall <mpm@selenic.com>
parents:
8675
diff
changeset
|
743 badfn = match.bad |
6831
2b663f542bd3
dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents:
6830
diff
changeset
|
744 dmap = self._map |
5000
46facb73ba8b
dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents:
4965
diff
changeset
|
745 lstat = os.lstat |
6830
2cf4cda64727
dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents:
6829
diff
changeset
|
746 getkind = stat.S_IFMT |
6828
55d65a33da52
dirstate.walk: minor cleanups
Matt Mackall <mpm@selenic.com>
parents:
6827
diff
changeset
|
747 dirkind = stat.S_IFDIR |
6830
2cf4cda64727
dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents:
6829
diff
changeset
|
748 regkind = stat.S_IFREG |
2cf4cda64727
dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents:
6829
diff
changeset
|
749 lnkkind = stat.S_IFLNK |
6831
2b663f542bd3
dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents:
6830
diff
changeset
|
750 join = self._join |
19174
022256ef47b8
dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents:
19173
diff
changeset
|
751 dirsfound = [] |
022256ef47b8
dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents:
19173
diff
changeset
|
752 foundadd = dirsfound.append |
19173
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
753 dirsnotfound = [] |
19175
63f7bd2e1a46
dirstate._walkexplicit: inline dirsnotfound.append
Siddharth Agarwal <sid0@fb.com>
parents:
19174
diff
changeset
|
754 notfoundadd = dirsnotfound.append |
6820
639d9cb95509
dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents:
6819
diff
changeset
|
755 |
24448
55c449345b10
match: add isexact() method to hide internals
Martin von Zweigbergk <martinvonz@google.com>
parents:
24212
diff
changeset
|
756 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
|
757 normalize = self._normalize |
e255a5dc29e6
dirstate: skip optimization on case-folding FS (issue2440)
Matt Mackall <mpm@selenic.com>
parents:
12401
diff
changeset
|
758 else: |
18032
a9e623bb440e
dirstate: test normalize is truthy instead of using a no-op lambda
Siddharth Agarwal <sid0@fb.com>
parents:
18018
diff
changeset
|
759 normalize = None |
12907
e255a5dc29e6
dirstate: skip optimization on case-folding FS (issue2440)
Matt Mackall <mpm@selenic.com>
parents:
12401
diff
changeset
|
760 |
12211
798d72f3621c
dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12164
diff
changeset
|
761 files = sorted(match.files()) |
798d72f3621c
dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12164
diff
changeset
|
762 subrepos.sort() |
798d72f3621c
dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12164
diff
changeset
|
763 i, j = 0, 0 |
798d72f3621c
dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12164
diff
changeset
|
764 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
|
765 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
|
766 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
|
767 i += 1 |
798d72f3621c
dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12164
diff
changeset
|
768 continue |
13339
22167be007ed
subrepo: fix pruning of subrepo filenames in dirstate (issue2619)
trbs <trbs@trbs.net>
parents:
13233
diff
changeset
|
769 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
|
770 del files[i] |
798d72f3621c
dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12164
diff
changeset
|
771 j += 1 |
798d72f3621c
dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12164
diff
changeset
|
772 |
6831
2b663f542bd3
dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents:
6830
diff
changeset
|
773 if not files or '.' in files: |
24521
489026bffbf6
dirstate._walkexplicit: indicate root as '.', not ''
Siddharth Agarwal <sid0@fb.com>
parents:
24448
diff
changeset
|
774 files = ['.'] |
10176
24ce8f0c0a39
dirstate: don't check state of subrepo directories
Augie Fackler <durin42@gmail.com>
parents:
10145
diff
changeset
|
775 results = dict.fromkeys(subrepos) |
24ce8f0c0a39
dirstate: don't check state of subrepo directories
Augie Fackler <durin42@gmail.com>
parents:
10145
diff
changeset
|
776 results['.hg'] = None |
5000
46facb73ba8b
dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents:
4965
diff
changeset
|
777 |
23375
a179db3db9b9
dirstate: speed up repeated missing directory checks
Martin von Zweigbergk <martinvonz@google.com>
parents:
22915
diff
changeset
|
778 alldirs = None |
12211
798d72f3621c
dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12164
diff
changeset
|
779 for ff in files: |
24523
a4b81dbe73c1
dirstate._walkexplicit: don't bother normalizing '.'
Siddharth Agarwal <sid0@fb.com>
parents:
24522
diff
changeset
|
780 # constructing the foldmap is expensive, so don't do it for the |
a4b81dbe73c1
dirstate._walkexplicit: don't bother normalizing '.'
Siddharth Agarwal <sid0@fb.com>
parents:
24522
diff
changeset
|
781 # common case where files is ['.'] |
a4b81dbe73c1
dirstate._walkexplicit: don't bother normalizing '.'
Siddharth Agarwal <sid0@fb.com>
parents:
24522
diff
changeset
|
782 if normalize and ff != '.': |
24522
18085e46caa9
dirstate._walkexplicit: drop normpath calls
Siddharth Agarwal <sid0@fb.com>
parents:
24521
diff
changeset
|
783 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
|
784 else: |
24522
18085e46caa9
dirstate._walkexplicit: drop normpath calls
Siddharth Agarwal <sid0@fb.com>
parents:
24521
diff
changeset
|
785 nf = ff |
6829
fec1da46006e
dirstate.walk: build a dict rather than yield
Matt Mackall <mpm@selenic.com>
parents:
6828
diff
changeset
|
786 if nf in results: |
6820
639d9cb95509
dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents:
6819
diff
changeset
|
787 continue |
639d9cb95509
dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents:
6819
diff
changeset
|
788 |
639d9cb95509
dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents:
6819
diff
changeset
|
789 try: |
6831
2b663f542bd3
dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents:
6830
diff
changeset
|
790 st = lstat(join(nf)) |
6830
2cf4cda64727
dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents:
6829
diff
changeset
|
791 kind = getkind(st.st_mode) |
2cf4cda64727
dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents:
6829
diff
changeset
|
792 if kind == dirkind: |
8588
2624f485b9bc
dirstate: set more states in step 1 of walk
Simon Heimberg <simohe@besonet.ch>
parents:
8521
diff
changeset
|
793 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
|
794 # 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
|
795 results[nf] = None |
19143
3cb9468535bd
match: make explicitdir and traversedir None by default
Siddharth Agarwal <sid0@fb.com>
parents:
19142
diff
changeset
|
796 if matchedir: |
3cb9468535bd
match: make explicitdir and traversedir None by default
Siddharth Agarwal <sid0@fb.com>
parents:
19142
diff
changeset
|
797 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
|
798 foundadd((nf, ff)) |
12401
4cdaf1adafc8
backout most of 4f8067c94729
Matt Mackall <mpm@selenic.com>
parents:
12387
diff
changeset
|
799 elif kind == regkind or kind == lnkkind: |
6830
2cf4cda64727
dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents:
6829
diff
changeset
|
800 results[nf] = st |
6828
55d65a33da52
dirstate.walk: minor cleanups
Matt Mackall <mpm@selenic.com>
parents:
6827
diff
changeset
|
801 else: |
8681
26f133267cd7
walk: use match.bad callback for filetype messages
Matt Mackall <mpm@selenic.com>
parents:
8680
diff
changeset
|
802 badfn(ff, badtype(kind)) |
6830
2cf4cda64727
dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents:
6829
diff
changeset
|
803 if nf in dmap: |
6829
fec1da46006e
dirstate.walk: build a dict rather than yield
Matt Mackall <mpm@selenic.com>
parents:
6828
diff
changeset
|
804 results[nf] = None |
25660
328739ea70c3
global: mass rewrite to use modern exception syntax
Gregory Szorc <gregory.szorc@gmail.com>
parents:
25658
diff
changeset
|
805 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
|
806 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
|
807 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
|
808 else: # does it match a missing directory? |
23375
a179db3db9b9
dirstate: speed up repeated missing directory checks
Martin von Zweigbergk <martinvonz@google.com>
parents:
22915
diff
changeset
|
809 if alldirs is None: |
24635
21e1ece30f8c
util: move dirs() and finddirs() from scmutil to util
Drew Gottlieb <drgott@google.com>
parents:
24632
diff
changeset
|
810 alldirs = util.dirs(dmap) |
23375
a179db3db9b9
dirstate: speed up repeated missing directory checks
Martin von Zweigbergk <martinvonz@google.com>
parents:
22915
diff
changeset
|
811 if nf in alldirs: |
a179db3db9b9
dirstate: speed up repeated missing directory checks
Martin von Zweigbergk <martinvonz@google.com>
parents:
22915
diff
changeset
|
812 if matchedir: |
a179db3db9b9
dirstate: speed up repeated missing directory checks
Martin von Zweigbergk <martinvonz@google.com>
parents:
22915
diff
changeset
|
813 matchedir(nf) |
a179db3db9b9
dirstate: speed up repeated missing directory checks
Martin von Zweigbergk <martinvonz@google.com>
parents:
22915
diff
changeset
|
814 notfoundadd(nf) |
8677
34df078b8b1b
walk: simplify logic for badfn clause
Matt Mackall <mpm@selenic.com>
parents:
8676
diff
changeset
|
815 else: |
8680
b6511055d37b
match: ignore return of match.bad
Matt Mackall <mpm@selenic.com>
parents:
8677
diff
changeset
|
816 badfn(ff, inst.strerror) |
6820
639d9cb95509
dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents:
6819
diff
changeset
|
817 |
25877
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
818 # 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
|
819 # 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
|
820 # 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
|
821 # 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
|
822 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
|
823 normed = {} |
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
824 |
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
825 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
|
826 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
|
827 continue |
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
828 |
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
829 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
|
830 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
|
831 |
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
832 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
|
833 paths = set() |
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
834 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
|
835 |
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
836 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
|
837 |
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
838 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
|
839 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
|
840 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
|
841 folded = self._discoverpath(path, norm, True, None, |
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
842 self._dirfoldmap) |
85785cd3b69f
dirstate: ensure mv source is marked deleted when walking icasefs (issue4760)
Matt Harbison <matt_harbison@yahoo.com>
parents:
25660
diff
changeset
|
843 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
|
844 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
|
845 |
19174
022256ef47b8
dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents:
19173
diff
changeset
|
846 return results, dirsfound, dirsnotfound |
19173
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
847 |
19190
b03952ee634d
dirstate.walk: add a flag to let extensions avoid full walks
Siddharth Agarwal <sid0@fb.com>
parents:
19175
diff
changeset
|
848 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
|
849 ''' |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
850 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
|
851 matched by match. |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
852 |
19190
b03952ee634d
dirstate.walk: add a flag to let extensions avoid full walks
Siddharth Agarwal <sid0@fb.com>
parents:
19175
diff
changeset
|
853 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
|
854 |
19173
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
855 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
|
856 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
|
857 |
19173
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
858 ''' |
19190
b03952ee634d
dirstate.walk: add a flag to let extensions avoid full walks
Siddharth Agarwal <sid0@fb.com>
parents:
19175
diff
changeset
|
859 # 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
|
860 # 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
|
861 # 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
|
862 |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
863 if ignored: |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
864 ignore = util.never |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
865 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
|
866 elif unknown: |
1b6e37f44250
dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents:
21026
diff
changeset
|
867 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
|
868 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
|
869 else: |
1b6e37f44250
dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents:
21026
diff
changeset
|
870 # 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
|
871 ignore = util.always |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
872 dirignore = util.always |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
873 |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
874 matchfn = match.matchfn |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
875 matchalways = match.always() |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
876 matchtdir = match.traversedir |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
877 dmap = self._map |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
878 listdir = osutil.listdir |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
879 lstat = os.lstat |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
880 dirkind = stat.S_IFDIR |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
881 regkind = stat.S_IFREG |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
882 lnkkind = stat.S_IFLNK |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
883 join = self._join |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
884 |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
885 exact = skipstep3 = False |
24448
55c449345b10
match: add isexact() method to hide internals
Martin von Zweigbergk <martinvonz@google.com>
parents:
24212
diff
changeset
|
886 if match.isexact(): # match.exact |
19173
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
887 exact = True |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
888 dirignore = util.always # skip step 2 |
25234
3c346969c321
dirstate: avoid match.files() in walk()
Martin von Zweigbergk <martinvonz@google.com>
parents:
25227
diff
changeset
|
889 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
|
890 skipstep3 = True |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
891 |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
892 if not exact and self._checkcase: |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
893 normalize = self._normalize |
24541
e235b5dc5cf9
dirstate.walk: use the file foldmap to normalize
Siddharth Agarwal <sid0@fb.com>
parents:
24540
diff
changeset
|
894 normalizefile = self._normalizefile |
19173
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
895 skipstep3 = False |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
896 else: |
24560
b38bcf18993c
dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents:
24559
diff
changeset
|
897 normalize = self._normalize |
24541
e235b5dc5cf9
dirstate.walk: use the file foldmap to normalize
Siddharth Agarwal <sid0@fb.com>
parents:
24540
diff
changeset
|
898 normalizefile = None |
19173
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 # step 1: find all explicit files |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
901 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
|
902 |
19172
c6cea2e2031b
dirstate.walk: pull skipstep3 out of the explicit walk code
Siddharth Agarwal <sid0@fb.com>
parents:
19171
diff
changeset
|
903 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
|
904 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
|
905 |
6826
eca20fee0728
dirstate.walk: pull directory scanning into top-level loop
Matt Mackall <mpm@selenic.com>
parents:
6825
diff
changeset
|
906 # 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
|
907 def traverse(work, alreadynormed): |
24559
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
908 wadd = work.append |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
909 while work: |
24560
b38bcf18993c
dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents:
24559
diff
changeset
|
910 nd = work.pop() |
24559
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
911 skip = None |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
912 if nd == '.': |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
913 nd = '' |
18032
a9e623bb440e
dirstate: test normalize is truthy instead of using a no-op lambda
Siddharth Agarwal <sid0@fb.com>
parents:
18018
diff
changeset
|
914 else: |
24559
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
915 skip = '.hg' |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
916 try: |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
917 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
|
918 except OSError as inst: |
24559
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
919 if inst.errno in (errno.EACCES, errno.ENOENT): |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
920 match.bad(self.pathto(nd), inst.strerror) |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
921 continue |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
922 raise |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
923 for f, kind, st in entries: |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
924 if normalizefile: |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
925 # 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
|
926 # 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
|
927 # dmap -- therefore normalizefile is enough |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
928 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
|
929 True) |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
930 else: |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
931 nf = nd and (nd + "/" + f) or f |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
932 if nf not in results: |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
933 if kind == dirkind: |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
934 if not ignore(nf): |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
935 if matchtdir: |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
936 matchtdir(nf) |
24560
b38bcf18993c
dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents:
24559
diff
changeset
|
937 wadd(nf) |
24559
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
938 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
|
939 results[nf] = None |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
940 elif kind == regkind or kind == lnkkind: |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
941 if nf in dmap: |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
942 if matchalways or matchfn(nf): |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
943 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
|
944 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
|
945 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
|
946 # 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
|
947 if not alreadynormed: |
b38bcf18993c
dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents:
24559
diff
changeset
|
948 nf = normalize(nf, False, True) |
24559
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
949 results[nf] = st |
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
950 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
|
951 results[nf] = None |
24559
4728d6f7c69f
dirstate.walk: factor out directory traversal
Siddharth Agarwal <sid0@fb.com>
parents:
24553
diff
changeset
|
952 |
24560
b38bcf18993c
dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents:
24559
diff
changeset
|
953 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
|
954 # 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
|
955 # expensive directory normalization |
b38bcf18993c
dirstate.walk: don't keep track of normalized files in parallel
Siddharth Agarwal <sid0@fb.com>
parents:
24559
diff
changeset
|
956 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
|
957 traverse([d], alreadynormed) |
536 | 958 |
18812
1c40526da52a
dirstate.walk: remove subrepo and .hg from results before step 3
Siddharth Agarwal <sid0@fb.com>
parents:
18792
diff
changeset
|
959 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
|
960 del results[s] |
1c40526da52a
dirstate.walk: remove subrepo and .hg from results before step 3
Siddharth Agarwal <sid0@fb.com>
parents:
18792
diff
changeset
|
961 del results['.hg'] |
1c40526da52a
dirstate.walk: remove subrepo and .hg from results before step 3
Siddharth Agarwal <sid0@fb.com>
parents:
18792
diff
changeset
|
962 |
21115
1b6e37f44250
dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents:
21026
diff
changeset
|
963 # 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
|
964 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
|
965 # 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
|
966 # 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
|
967 # 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
|
968 if not results and matchalways: |
a18919de61e5
dirstate.walk: fast path none-seen + match-always case for step 3
Siddharth Agarwal <sid0@fb.com>
parents:
18814
diff
changeset
|
969 visit = dmap.keys() |
a18919de61e5
dirstate.walk: fast path none-seen + match-always case for step 3
Siddharth Agarwal <sid0@fb.com>
parents:
18814
diff
changeset
|
970 else: |
a18919de61e5
dirstate.walk: fast path none-seen + match-always case for step 3
Siddharth Agarwal <sid0@fb.com>
parents:
18814
diff
changeset
|
971 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
|
972 visit.sort() |
a18919de61e5
dirstate.walk: fast path none-seen + match-always case for step 3
Siddharth Agarwal <sid0@fb.com>
parents:
18814
diff
changeset
|
973 |
18625
2cbd27f4f3c4
dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents:
18567
diff
changeset
|
974 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
|
975 # 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
|
976 # 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
|
977 # 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
|
978 # The rest must thus be ignored or under a symlink. |
20033
f962870712da
pathutil: tease out a new library to break an import cycle from canonpath use
Augie Fackler <raf@durin42.com>
parents:
19910
diff
changeset
|
979 audit_path = pathutil.pathauditor(self._root) |
18625
2cbd27f4f3c4
dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents:
18567
diff
changeset
|
980 |
2cbd27f4f3c4
dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents:
18567
diff
changeset
|
981 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
|
982 # 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
|
983 # 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
|
984 # 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
|
985 # on disk. |
24632 | 986 if (normalizefile and |
987 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
|
988 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
|
989 # 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
|
990 # 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
|
991 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
|
992 try: |
05cf40f9b0ec
dirstate: fix generator/list error when using python 2.7
Durham Goode <durham@fb.com>
parents:
18653
diff
changeset
|
993 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
|
994 # 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
|
995 except OSError: |
05cf40f9b0ec
dirstate: fix generator/list error when using python 2.7
Durham Goode <durham@fb.com>
parents:
18653
diff
changeset
|
996 # file doesn't exist |
05cf40f9b0ec
dirstate: fix generator/list error when using python 2.7
Durham Goode <durham@fb.com>
parents:
18653
diff
changeset
|
997 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
|
998 else: |
2cbd27f4f3c4
dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents:
18567
diff
changeset
|
999 # 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
|
1000 # 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
|
1001 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
|
1002 else: |
2cbd27f4f3c4
dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents:
18567
diff
changeset
|
1003 # 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
|
1004 # so stat and check everything we missed. |
18625
2cbd27f4f3c4
dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents:
18567
diff
changeset
|
1005 nf = iter(visit).next |
26592
502b56a9e897
dirstate: batch calls to statfiles (issue4878)
Matt Mackall <mpm@selenic.com>
parents:
26587
diff
changeset
|
1006 pos = 0 |
502b56a9e897
dirstate: batch calls to statfiles (issue4878)
Matt Mackall <mpm@selenic.com>
parents:
26587
diff
changeset
|
1007 while pos < len(visit): |
502b56a9e897
dirstate: batch calls to statfiles (issue4878)
Matt Mackall <mpm@selenic.com>
parents:
26587
diff
changeset
|
1008 # visit in mid-sized batches so that we don't |
502b56a9e897
dirstate: batch calls to statfiles (issue4878)
Matt Mackall <mpm@selenic.com>
parents:
26587
diff
changeset
|
1009 # block signals indefinitely |
502b56a9e897
dirstate: batch calls to statfiles (issue4878)
Matt Mackall <mpm@selenic.com>
parents:
26587
diff
changeset
|
1010 xr = xrange(pos, min(len(visit), pos + 1000)) |
502b56a9e897
dirstate: batch calls to statfiles (issue4878)
Matt Mackall <mpm@selenic.com>
parents:
26587
diff
changeset
|
1011 for st in util.statfiles([join(visit[n]) for n in xr]): |
502b56a9e897
dirstate: batch calls to statfiles (issue4878)
Matt Mackall <mpm@selenic.com>
parents:
26587
diff
changeset
|
1012 results[nf()] = st |
502b56a9e897
dirstate: batch calls to statfiles (issue4878)
Matt Mackall <mpm@selenic.com>
parents:
26587
diff
changeset
|
1013 pos += 1000 |
6829
fec1da46006e
dirstate.walk: build a dict rather than yield
Matt Mackall <mpm@selenic.com>
parents:
6828
diff
changeset
|
1014 return results |
669
8aa2a282eda4
.hgignore speedups patch incorporating Matt's feedback.
mwilli2@localhost.localdomain
parents:
667
diff
changeset
|
1015 |
10176
24ce8f0c0a39
dirstate: don't check state of subrepo directories
Augie Fackler <durin42@gmail.com>
parents:
10145
diff
changeset
|
1016 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
|
1017 '''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
|
1018 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
|
1019 scmutil.status and: |
9518
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
1020 |
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
1021 unsure: |
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
1022 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
|
1023 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
|
1024 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
|
1025 status.modified: |
9518
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
1026 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
|
1027 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
|
1028 status.clean: |
9518
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
1029 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
|
1030 dirstate was written |
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
1031 ''' |
6753
ed5ffb2c12f3
repo.status: eliminate list_
Matt Mackall <mpm@selenic.com>
parents:
6750
diff
changeset
|
1032 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
|
1033 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
|
1034 removed, deleted, clean = [], [], [] |
723 | 1035 |
5003
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
1036 dmap = self._map |
9518
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
1037 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
|
1038 madd = modified.append |
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
1039 aadd = added.append |
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
1040 uadd = unknown.append |
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
1041 iadd = ignored.append |
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
1042 radd = removed.append |
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
1043 dadd = deleted.append |
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
1044 cadd = clean.append |
18034
1a570f04de07
dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents:
18032
diff
changeset
|
1045 mexact = match.exact |
1a570f04de07
dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents:
18032
diff
changeset
|
1046 dirignore = self._dirignore |
1a570f04de07
dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents:
18032
diff
changeset
|
1047 checkexec = self._checkexec |
1a570f04de07
dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents:
18032
diff
changeset
|
1048 copymap = self._copymap |
1a570f04de07
dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents:
18032
diff
changeset
|
1049 lastnormaltime = self._lastnormaltime |
5003
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
1050 |
19191
ab9de1e8fc36
dirstate.status: avoid full walks when possible
Siddharth Agarwal <sid0@fb.com>
parents:
19190
diff
changeset
|
1051 # 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
|
1052 # - we're listing all clean files, or |
ab9de1e8fc36
dirstate.status: avoid full walks when possible
Siddharth Agarwal <sid0@fb.com>
parents:
19190
diff
changeset
|
1053 # - 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
|
1054 # 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
|
1055 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
|
1056 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
|
1057 full=full).iteritems(): |
6591
eda3fd322a7f
dirstate: minor status cleanups
Matt Mackall <mpm@selenic.com>
parents:
6590
diff
changeset
|
1058 if fn not in dmap: |
18034
1a570f04de07
dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents:
18032
diff
changeset
|
1059 if (listignored or mexact(fn)) and dirignore(fn): |
6753
ed5ffb2c12f3
repo.status: eliminate list_
Matt Mackall <mpm@selenic.com>
parents:
6750
diff
changeset
|
1060 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
|
1061 iadd(fn) |
19910
601944f41257
dirstate.status: return explicit unknown files even when not asked
Siddharth Agarwal <sid0@fb.com>
parents:
19651
diff
changeset
|
1062 else: |
5003
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
1063 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
|
1064 continue |
6591
eda3fd322a7f
dirstate: minor status cleanups
Matt Mackall <mpm@selenic.com>
parents:
6590
diff
changeset
|
1065 |
21810
4b2ebd3187a1
dirstate.status: assign members one by one instead of unpacking the tuple
Siddharth Agarwal <sid0@fb.com>
parents:
21809
diff
changeset
|
1066 # 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
|
1067 # 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
|
1068 # 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
|
1069 # 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
|
1070 # 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
|
1071 # 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
|
1072 # tuple members one by one. |
4b2ebd3187a1
dirstate.status: assign members one by one instead of unpacking the tuple
Siddharth Agarwal <sid0@fb.com>
parents:
21809
diff
changeset
|
1073 t = dmap[fn] |
4b2ebd3187a1
dirstate.status: assign members one by one instead of unpacking the tuple
Siddharth Agarwal <sid0@fb.com>
parents:
21809
diff
changeset
|
1074 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
|
1075 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
|
1076 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
|
1077 time = t[3] |
6591
eda3fd322a7f
dirstate: minor status cleanups
Matt Mackall <mpm@selenic.com>
parents:
6590
diff
changeset
|
1078 |
6818
6e93fbd847ef
dirstate.walk: eliminate src from yield
Matt Mackall <mpm@selenic.com>
parents:
6811
diff
changeset
|
1079 if not st and state in "nma": |
6e93fbd847ef
dirstate.walk: eliminate src from yield
Matt Mackall <mpm@selenic.com>
parents:
6811
diff
changeset
|
1080 dadd(fn) |
6e93fbd847ef
dirstate.walk: eliminate src from yield
Matt Mackall <mpm@selenic.com>
parents:
6811
diff
changeset
|
1081 elif state == 'n': |
26492
3a0bb61371c5
util: extract stub function to get mtime with second accuracy
Yuya Nishihara <yuya@tcha.org>
parents:
26294
diff
changeset
|
1082 mtime = util.statmtimesec(st) |
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
|
1083 if (size >= 0 and |
17733
3c775c5a6c03
dirstate: handle large dates and times with masking (issue2608)
Matt Mackall <mpm@selenic.com>
parents:
17197
diff
changeset
|
1084 ((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
|
1085 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
|
1086 or size == -2 # other parent |
18034
1a570f04de07
dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents:
18032
diff
changeset
|
1087 or fn in copymap): |
5003
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
1088 madd(fn) |
19651
902c646019ad
dirstate.status: don't ignore symlink placeholders in the normal set
Siddharth Agarwal <sid0@fb.com>
parents:
19216
diff
changeset
|
1089 elif time != mtime and time != mtime & _rangemask: |
5003
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
1090 ladd(fn) |
18034
1a570f04de07
dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents:
18032
diff
changeset
|
1091 elif mtime == lastnormaltime: |
24181
5245caa0dcde
dirstate: clarify comment about leaving normal files undef if changed 'now'
Mads Kiilerich <madski@unity3d.com>
parents:
23866
diff
changeset
|
1092 # 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
|
1093 # 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
|
1094 # This can happen if we quickly do multiple commits. |
13763
7a73c406c0fd
dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents:
13754
diff
changeset
|
1095 # 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
|
1096 ladd(fn) |
6753
ed5ffb2c12f3
repo.status: eliminate list_
Matt Mackall <mpm@selenic.com>
parents:
6750
diff
changeset
|
1097 elif listclean: |
5003
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
1098 cadd(fn) |
6590
9f80e062d71c
status: rename type_ to state
Matt Mackall <mpm@selenic.com>
parents:
6589
diff
changeset
|
1099 elif state == 'm': |
5003
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
1100 madd(fn) |
6590
9f80e062d71c
status: rename type_ to state
Matt Mackall <mpm@selenic.com>
parents:
6589
diff
changeset
|
1101 elif state == 'a': |
5003
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
1102 aadd(fn) |
6590
9f80e062d71c
status: rename type_ to state
Matt Mackall <mpm@selenic.com>
parents:
6589
diff
changeset
|
1103 elif state == 'r': |
5003
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
1104 radd(fn) |
1183 | 1105 |
22913
cb4449921a1d
status: create class for status lists
Martin von Zweigbergk <martinvonz@gmail.com>
parents:
22911
diff
changeset
|
1106 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
|
1107 unknown, ignored, clean)) |
21984
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
1108 |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
1109 def matches(self, match): |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
1110 ''' |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
1111 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
|
1112 ''' |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
1113 dmap = self._map |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
1114 if match.always(): |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
1115 return dmap.keys() |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
1116 files = match.files() |
24448
55c449345b10
match: add isexact() method to hide internals
Martin von Zweigbergk <martinvonz@google.com>
parents:
24212
diff
changeset
|
1117 if match.isexact(): |
21984
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
1118 # 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
|
1119 # much smaller than dmap |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
1120 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
|
1121 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
|
1122 # 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
|
1123 # that |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
1124 return list(files) |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
1125 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
|
1126 |
26746
3c1d297fe929
dirstateguard: remove layering violation around saving/restoring backup
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26635
diff
changeset
|
1127 def _actualfilename(self, tr): |
3c1d297fe929
dirstateguard: remove layering violation around saving/restoring backup
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26635
diff
changeset
|
1128 if tr: |
26633
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1129 return self._pendingfilename |
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1130 else: |
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1131 return self._filename |
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1132 |
26746
3c1d297fe929
dirstateguard: remove layering violation around saving/restoring backup
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26635
diff
changeset
|
1133 def _savebackup(self, tr, suffix): |
26632
59b5e8844eb0
dirstate: move code paths for backup from dirstateguard to dirstate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26630
diff
changeset
|
1134 '''Save current dirstate into backup file with suffix''' |
26746
3c1d297fe929
dirstateguard: remove layering violation around saving/restoring backup
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26635
diff
changeset
|
1135 filename = self._actualfilename(tr) |
26633
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1136 |
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1137 # 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
|
1138 # 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
|
1139 # output file will be used to create backup of dirstate at this point. |
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1140 self._writedirstate(self._opener(filename, "w", atomictemp=True)) |
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1141 |
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1142 if tr: |
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1143 # 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
|
1144 # 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
|
1145 # changed after this |
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1146 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
|
1147 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
|
1148 |
020b12d591f3
dirstate: make functions for backup aware of transaction activity
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26632
diff
changeset
|
1149 # 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
|
1150 # 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
|
1151 # 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
|
1152 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
|
1153 |
26632
59b5e8844eb0
dirstate: move code paths for backup from dirstateguard to dirstate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26630
diff
changeset
|
1154 self._opener.write(filename + suffix, self._opener.tryread(filename)) |
59b5e8844eb0
dirstate: move code paths for backup from dirstateguard to dirstate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26630
diff
changeset
|
1155 |
26746
3c1d297fe929
dirstateguard: remove layering violation around saving/restoring backup
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26635
diff
changeset
|
1156 def _restorebackup(self, tr, suffix): |
26632
59b5e8844eb0
dirstate: move code paths for backup from dirstateguard to dirstate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26630
diff
changeset
|
1157 '''Restore dirstate by backup file with suffix''' |
59b5e8844eb0
dirstate: move code paths for backup from dirstateguard to dirstate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26630
diff
changeset
|
1158 # 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
|
1159 # 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
|
1160 self.invalidate() |
26746
3c1d297fe929
dirstateguard: remove layering violation around saving/restoring backup
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26635
diff
changeset
|
1161 filename = self._actualfilename(tr) |
26632
59b5e8844eb0
dirstate: move code paths for backup from dirstateguard to dirstate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26630
diff
changeset
|
1162 self._opener.rename(filename + suffix, filename) |
59b5e8844eb0
dirstate: move code paths for backup from dirstateguard to dirstate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26630
diff
changeset
|
1163 |
26746
3c1d297fe929
dirstateguard: remove layering violation around saving/restoring backup
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26635
diff
changeset
|
1164 def _clearbackup(self, tr, suffix): |
26632
59b5e8844eb0
dirstate: move code paths for backup from dirstateguard to dirstate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26630
diff
changeset
|
1165 '''Clear backup file with suffix''' |
26746
3c1d297fe929
dirstateguard: remove layering violation around saving/restoring backup
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26635
diff
changeset
|
1166 filename = self._actualfilename(tr) |
26632
59b5e8844eb0
dirstate: move code paths for backup from dirstateguard to dirstate
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26630
diff
changeset
|
1167 self._opener.unlink(filename + suffix) |