Mercurial > hg
annotate mercurial/dirstate.py @ 24066:afdf5f6ab37a
pager: set an attribute on ui indicating that a pager is active
A subsequent patch will teach the color extension to do different things
depending on whether a pager is active. This patch leaves a breadcrumb
on the ui instance to allow it do that that.
author | Gregory Szorc <gregory.szorc@gmail.com> |
---|---|
date | Fri, 06 Feb 2015 12:07:56 -0800 |
parents | 9dd442148301 |
children | 5245caa0dcde 3cc630be5f09 |
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 _ |
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
|
10 import scmutil, util, ignore, osutil, parsers, encoding, pathutil |
23496
ee5a4ed4c8b1
dirstate: use the 'nogc' decorator
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23375
diff
changeset
|
11 import os, stat, errno |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
12 |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
13 propertycache = util.propertycache |
16201
fb7c4c14223f
dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents:
16200
diff
changeset
|
14 filecache = scmutil.filecache |
17733
3c775c5a6c03
dirstate: handle large dates and times with masking (issue2608)
Matt Mackall <mpm@selenic.com>
parents:
17197
diff
changeset
|
15 _rangemask = 0x7fffffff |
16201
fb7c4c14223f
dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents:
16200
diff
changeset
|
16 |
21809
e250b8300e6e
parsers: inline fields of dirstate values in C version
Siddharth Agarwal <sid0@fb.com>
parents:
21808
diff
changeset
|
17 dirstatetuple = parsers.dirstatetuple |
21808
7537e57f5dbd
dirstate: add dirstatetuple to create dirstate values
Siddharth Agarwal <sid0@fb.com>
parents:
21116
diff
changeset
|
18 |
16201
fb7c4c14223f
dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents:
16200
diff
changeset
|
19 class repocache(filecache): |
fb7c4c14223f
dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents:
16200
diff
changeset
|
20 """filecache for files in .hg/""" |
fb7c4c14223f
dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents:
16200
diff
changeset
|
21 def join(self, obj, fname): |
fb7c4c14223f
dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents:
16200
diff
changeset
|
22 return obj._opener.join(fname) |
4610 | 23 |
16202
53e2cd303ecf
dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents:
16201
diff
changeset
|
24 class rootcache(filecache): |
53e2cd303ecf
dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents:
16201
diff
changeset
|
25 """filecache for files in the repository root""" |
53e2cd303ecf
dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents:
16201
diff
changeset
|
26 def join(self, obj, fname): |
53e2cd303ecf
dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents:
16201
diff
changeset
|
27 return obj._join(fname) |
53e2cd303ecf
dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents:
16201
diff
changeset
|
28 |
1559
59b3639df0a9
Convert all classes to new-style classes by deriving them from object.
Eric Hopper <hopper@omnifarious.org>
parents:
1541
diff
changeset
|
29 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
|
30 |
13032
e41e2b79883d
dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents:
12907
diff
changeset
|
31 def __init__(self, opener, ui, root, validate): |
10145
aec936051734
dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents:
9678
diff
changeset
|
32 '''Create a new dirstate object. |
aec936051734
dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents:
9678
diff
changeset
|
33 |
aec936051734
dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents:
9678
diff
changeset
|
34 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
|
35 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
|
36 the dirstate. |
aec936051734
dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents:
9678
diff
changeset
|
37 ''' |
4614
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
38 self._opener = opener |
13032
e41e2b79883d
dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents:
12907
diff
changeset
|
39 self._validate = validate |
4614
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
40 self._root = root |
6972
63d1d3e489f8
performance: normalize self._root, avoid calling os.path.join() in dirstate
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
6971
diff
changeset
|
41 self._rootdir = os.path.join(root, '') |
4903
81078e177266
dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents:
4677
diff
changeset
|
42 self._dirty = False |
4965 | 43 self._dirtypl = False |
15791
a814f8fcc65a
Use explicit integer division
Martin Geisler <mg@aragost.com>
parents:
15670
diff
changeset
|
44 self._lastnormaltime = 0 |
4614
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
45 self._ui = ui |
16200
9d4a2942a732
dirstate: add filecache support
Idan Kamara <idankk86@gmail.com>
parents:
16143
diff
changeset
|
46 self._filecache = {} |
22404
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
47 self._parentwriters = 0 |
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
48 |
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
49 def beginparentchange(self): |
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
50 '''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
|
51 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
|
52 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
|
53 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
|
54 match the contents. |
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
55 ''' |
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
56 self._parentwriters += 1 |
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
57 |
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
58 def endparentchange(self): |
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
59 '''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
|
60 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
|
61 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
|
62 ''' |
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
63 if self._parentwriters > 0: |
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
64 self._parentwriters -= 1 |
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
65 |
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
66 def pendingparentchange(self): |
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
67 '''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
|
68 that modify the dirstate parent. |
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
69 ''' |
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
70 return self._parentwriters > 0 |
723 | 71 |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
72 @propertycache |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
73 def _map(self): |
9518
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
74 '''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
|
75 (state, mode, size, time).''' |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
76 self._read() |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
77 return self._map |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
78 |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
79 @propertycache |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
80 def _copymap(self): |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
81 self._read() |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
82 return self._copymap |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
83 |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
84 @propertycache |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
85 def _foldmap(self): |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
86 f = {} |
22782
a1eb21f5caea
dirstate: cache util.normcase while constructing the foldmap
Siddharth Agarwal <sid0@fb.com>
parents:
22459
diff
changeset
|
87 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
|
88 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
|
89 if s[0] != 'r': |
22782
a1eb21f5caea
dirstate: cache util.normcase while constructing the foldmap
Siddharth Agarwal <sid0@fb.com>
parents:
22459
diff
changeset
|
90 f[normcase(name)] = name |
16302
49b54f1ae053
dirstate: normalize case of directory components
Matt Mackall <mpm@selenic.com>
parents:
16258
diff
changeset
|
91 for name in self._dirs: |
22782
a1eb21f5caea
dirstate: cache util.normcase while constructing the foldmap
Siddharth Agarwal <sid0@fb.com>
parents:
22459
diff
changeset
|
92 f[normcase(name)] = name |
15668
8e020155e76c
dirstate: prevent useless util.fspath() invocation for '.'
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
15550
diff
changeset
|
93 f['.'] = '.' # prevents useless util.fspath() invocation |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
94 return f |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
95 |
16201
fb7c4c14223f
dirstate: filecacheify _branch
Idan Kamara <idankk86@gmail.com>
parents:
16200
diff
changeset
|
96 @repocache('branch') |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
97 def _branch(self): |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
98 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
|
99 return self._opener.read("branch").strip() or "default" |
15799
e43c140eb08f
dirstate: propagate IOError other than ENOENT when reading branch
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15670
diff
changeset
|
100 except IOError, inst: |
e43c140eb08f
dirstate: propagate IOError other than ENOENT when reading branch
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
15670
diff
changeset
|
101 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
|
102 raise |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
103 return "default" |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
104 |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
105 @propertycache |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
106 def _pl(self): |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
107 try: |
13400
14f3795a5ed7
explicitly close files
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
13343
diff
changeset
|
108 fp = self._opener("dirstate") |
14f3795a5ed7
explicitly close files
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
13343
diff
changeset
|
109 st = fp.read(40) |
14f3795a5ed7
explicitly close files
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
13343
diff
changeset
|
110 fp.close() |
8716
f3322bb29a0e
dirstate: don't complain about 0-length files
Matt Mackall <mpm@selenic.com>
parents:
8708
diff
changeset
|
111 l = len(st) |
f3322bb29a0e
dirstate: don't complain about 0-length files
Matt Mackall <mpm@selenic.com>
parents:
8708
diff
changeset
|
112 if l == 40: |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
113 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
|
114 elif l > 0 and l < 40: |
8640
8536119f2f94
dirstate: notice truncated parents read
Matt Mackall <mpm@selenic.com>
parents:
8589
diff
changeset
|
115 raise util.Abort(_('working directory state appears damaged!')) |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
116 except IOError, err: |
10282
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
117 if err.errno != errno.ENOENT: |
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
118 raise |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
119 return [nullid, nullid] |
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 |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
122 def _dirs(self): |
18899
d8ff607ef721
scmutil: use new dirs class in dirstate and context
Bryan O'Sullivan <bryano@fb.com>
parents:
18897
diff
changeset
|
123 return scmutil.dirs(self._map, 'r') |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
124 |
16143
fceb2964fa6c
context: add 'dirs()' to changectx/workingctx for directory patterns
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
15801
diff
changeset
|
125 def dirs(self): |
fceb2964fa6c
context: add 'dirs()' to changectx/workingctx for directory patterns
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
15801
diff
changeset
|
126 return self._dirs |
fceb2964fa6c
context: add 'dirs()' to changectx/workingctx for directory patterns
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
15801
diff
changeset
|
127 |
16202
53e2cd303ecf
dirstate: filecacheify _ignore (issue3278)
Idan Kamara <idankk86@gmail.com>
parents:
16201
diff
changeset
|
128 @rootcache('.hgignore') |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
129 def _ignore(self): |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
130 files = [self._join('.hgignore')] |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
131 for name, path in self._ui.configitems("ui"): |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
132 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
|
133 # 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
|
134 # 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
|
135 files.append(os.path.join(self._rootdir, util.expandpath(path))) |
8261
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
136 return ignore.ignore(self._root, files, self._ui.warn) |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
137 |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
138 @propertycache |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
139 def _slash(self): |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
140 return self._ui.configbool('ui', 'slash') and os.sep != '/' |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
141 |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
142 @propertycache |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
143 def _checklink(self): |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
144 return util.checklink(self._root) |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
145 |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
146 @propertycache |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
147 def _checkexec(self): |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
148 return util.checkexec(self._root) |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
149 |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
150 @propertycache |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
151 def _checkcase(self): |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
152 return not util.checkcase(self._join('.hg')) |
0fe1f57ac2bd
dirstate: use propertycache
Matt Mackall <mpm@selenic.com>
parents:
8226
diff
changeset
|
153 |
4905
fc61495ea9cf
dirstate: make wjoin function private
Matt Mackall <mpm@selenic.com>
parents:
4904
diff
changeset
|
154 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
|
155 # 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
|
156 # 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
|
157 return self._rootdir + f |
723 | 158 |
15337
cf5f9df6406b
windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents:
15057
diff
changeset
|
159 def flagfunc(self, buildfallback): |
cf5f9df6406b
windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents:
15057
diff
changeset
|
160 if self._checklink and self._checkexec: |
cf5f9df6406b
windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents:
15057
diff
changeset
|
161 def f(x): |
18869
e8b4b139a545
dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents:
18815
diff
changeset
|
162 try: |
e8b4b139a545
dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents:
18815
diff
changeset
|
163 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
|
164 if util.statislink(st): |
e8b4b139a545
dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents:
18815
diff
changeset
|
165 return 'l' |
e8b4b139a545
dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents:
18815
diff
changeset
|
166 if util.statisexec(st): |
e8b4b139a545
dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents:
18815
diff
changeset
|
167 return 'x' |
e8b4b139a545
dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents:
18815
diff
changeset
|
168 except OSError: |
e8b4b139a545
dirstate: only call lstat once per flags invocation
Bryan O'Sullivan <bryano@fb.com>
parents:
18815
diff
changeset
|
169 pass |
15337
cf5f9df6406b
windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents:
15057
diff
changeset
|
170 return '' |
cf5f9df6406b
windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents:
15057
diff
changeset
|
171 return f |
cf5f9df6406b
windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents:
15057
diff
changeset
|
172 |
cf5f9df6406b
windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents:
15057
diff
changeset
|
173 fallback = buildfallback() |
6743 | 174 if self._checklink: |
175 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
|
176 if os.path.islink(self._join(x)): |
6743 | 177 return 'l' |
178 if 'x' in fallback(x): | |
179 return 'x' | |
180 return '' | |
181 return f | |
182 if self._checkexec: | |
183 def f(x): | |
184 if 'l' in fallback(x): | |
185 return 'l' | |
14273
38af0f514134
rename util.is_exec to isexec
Adrian Buehlmann <adrian@cadifra.com>
parents:
14168
diff
changeset
|
186 if util.isexec(self._join(x)): |
6743 | 187 return 'x' |
188 return '' | |
189 return f | |
15337
cf5f9df6406b
windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents:
15057
diff
changeset
|
190 else: |
cf5f9df6406b
windows: recompute flags when committing a merge (issue1802)
Matt Mackall <mpm@selenic.com>
parents:
15057
diff
changeset
|
191 return fallback |
6743 | 192 |
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
|
193 @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
|
194 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
|
195 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
|
196 |
870
a82eae840447
Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents:
839
diff
changeset
|
197 def getcwd(self): |
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
|
198 cwd = self._cwd |
10282
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
199 if cwd == self._root: |
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
200 return '' |
4614
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
201 # 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
|
202 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
|
203 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
|
204 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
|
205 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
|
206 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
|
207 else: |
c93562fb12cc
Fix handling of paths when run outside the repo.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4229
diff
changeset
|
208 # 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
|
209 return cwd |
870
a82eae840447
Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents:
839
diff
changeset
|
210 |
4525
78b6add1f966
Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4507
diff
changeset
|
211 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
|
212 if cwd is None: |
78b6add1f966
Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4507
diff
changeset
|
213 cwd = self.getcwd() |
4614
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
214 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
|
215 if self._slash: |
19210
865beb849720
dirstate: don't overnormalize for ui.slash
Matt Mackall <mpm@selenic.com>
parents:
19128
diff
changeset
|
216 return util.pconvert(path) |
4527
b422b558015b
Add ui.slash hgrc setting
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4525
diff
changeset
|
217 return path |
4525
78b6add1f966
Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4507
diff
changeset
|
218 |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
219 def __getitem__(self, key): |
9518
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
220 '''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
|
221 |
9518
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
222 States are: |
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
223 n normal |
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
224 m needs merging |
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
225 r marked for removal |
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
226 a marked for addition |
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
227 ? not tracked |
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
228 ''' |
4906
30847b8af7ca
dirstate: add __contains__ and make __getitem__ more useful
Matt Mackall <mpm@selenic.com>
parents:
4905
diff
changeset
|
229 return self._map.get(key, ("?",))[0] |
220 | 230 |
231 def __contains__(self, key): | |
4614
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
232 return key in self._map |
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
233 |
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
234 def __iter__(self): |
8209
a1a5a57efe90
replace util.sort with sorted built-in
Matt Mackall <mpm@selenic.com>
parents:
8151
diff
changeset
|
235 for x in sorted(self._map): |
4614
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
236 yield x |
220 | 237 |
18792
10669e24eb6c
completion: add a debugpathcomplete command
Bryan O'Sullivan <bryano@fb.com>
parents:
18760
diff
changeset
|
238 def iteritems(self): |
10669e24eb6c
completion: add a debugpathcomplete command
Bryan O'Sullivan <bryano@fb.com>
parents:
18760
diff
changeset
|
239 return self._map.iteritems() |
10669e24eb6c
completion: add a debugpathcomplete command
Bryan O'Sullivan <bryano@fb.com>
parents:
18760
diff
changeset
|
240 |
227 | 241 def parents(self): |
13032
e41e2b79883d
dirstate: warn on invalid parents rather than aborting
Matt Mackall <mpm@selenic.com>
parents:
12907
diff
changeset
|
242 return [self._validate(p) for p in self._pl] |
227 | 243 |
13876
10c7d92ac482
dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents:
13763
diff
changeset
|
244 def p1(self): |
10c7d92ac482
dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents:
13763
diff
changeset
|
245 return self._validate(self._pl[0]) |
10c7d92ac482
dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents:
13763
diff
changeset
|
246 |
10c7d92ac482
dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents:
13763
diff
changeset
|
247 def p2(self): |
10c7d92ac482
dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents:
13763
diff
changeset
|
248 return self._validate(self._pl[1]) |
10c7d92ac482
dirstate: add p1/p2 convenience methods
Matt Mackall <mpm@selenic.com>
parents:
13763
diff
changeset
|
249 |
4179
7e1c8a565a4f
Move branch read/write to dirstate where it belongs
Matt Mackall <mpm@selenic.com>
parents:
4172
diff
changeset
|
250 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
|
251 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
|
252 |
1062 | 253 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
|
254 """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
|
255 |
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16542
diff
changeset
|
256 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
|
257 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
|
258 returned by the call. |
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16542
diff
changeset
|
259 |
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16542
diff
changeset
|
260 See localrepo.setparents() |
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16542
diff
changeset
|
261 """ |
22407
d259322a394b
dirstate: add exception when calling setparent without begin/end (API)
Durham Goode <durham@fb.com>
parents:
22404
diff
changeset
|
262 if self._parentwriters == 0: |
22459
0c7b018d3258
dirstate: copyedit exception for no beginparentchange call
Siddharth Agarwal <sid0@fb.com>
parents:
22407
diff
changeset
|
263 raise ValueError("cannot set dirstate parent without " |
0c7b018d3258
dirstate: copyedit exception for no beginparentchange call
Siddharth Agarwal <sid0@fb.com>
parents:
22407
diff
changeset
|
264 "calling dirstate.beginparentchange") |
22407
d259322a394b
dirstate: add exception when calling setparent without begin/end (API)
Durham Goode <durham@fb.com>
parents:
22404
diff
changeset
|
265 |
4965 | 266 self._dirty = self._dirtypl = True |
16509
eab9119c5dee
rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents:
16472
diff
changeset
|
267 oldp2 = self._pl[1] |
4614
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
268 self._pl = p1, p2 |
16551
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16542
diff
changeset
|
269 copies = {} |
16509
eab9119c5dee
rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents:
16472
diff
changeset
|
270 if oldp2 != nullid and p2 == nullid: |
eab9119c5dee
rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents:
16472
diff
changeset
|
271 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
|
272 # 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
|
273 if s[0] == 'm': |
16551
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16542
diff
changeset
|
274 if f in self._copymap: |
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16542
diff
changeset
|
275 copies[f] = self._copymap[f] |
16509
eab9119c5dee
rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents:
16472
diff
changeset
|
276 self.normallookup(f) |
22895
dfa44e25bb53
dirstate: properly clean-up some more merge state on setparents
Matt Mackall <mpm@selenic.com>
parents:
22782
diff
changeset
|
277 # 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
|
278 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
|
279 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
|
280 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
|
281 self.add(f) |
16551
ebf6d38c9063
localrepo: add setparents() to adjust dirstate copies (issue3407)
Patrick Mezard <patrick@mezard.eu>
parents:
16542
diff
changeset
|
282 return copies |
227 | 283 |
4179
7e1c8a565a4f
Move branch read/write to dirstate where it belongs
Matt Mackall <mpm@selenic.com>
parents:
4172
diff
changeset
|
284 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
|
285 self._branch = encoding.fromlocal(branch) |
16472
14a4e17f0817
dirstate: write branch file atomically
Idan Kamara <idankk86@gmail.com>
parents:
16323
diff
changeset
|
286 f = self._opener('branch', 'w', atomictemp=True) |
14a4e17f0817
dirstate: write branch file atomically
Idan Kamara <idankk86@gmail.com>
parents:
16323
diff
changeset
|
287 try: |
14a4e17f0817
dirstate: write branch file atomically
Idan Kamara <idankk86@gmail.com>
parents:
16323
diff
changeset
|
288 f.write(self._branch + '\n') |
14a4e17f0817
dirstate: write branch file atomically
Idan Kamara <idankk86@gmail.com>
parents:
16323
diff
changeset
|
289 f.close() |
18317
365fecd984c7
dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents:
18078
diff
changeset
|
290 |
365fecd984c7
dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents:
18078
diff
changeset
|
291 # 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
|
292 # replacing the underlying file |
365fecd984c7
dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents:
18078
diff
changeset
|
293 ce = self._filecache['_branch'] |
365fecd984c7
dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents:
18078
diff
changeset
|
294 if ce: |
365fecd984c7
dirstate: refresh _branch cache entry after writing it
Idan Kamara <idankk86@gmail.com>
parents:
18078
diff
changeset
|
295 ce.refresh() |
18076
3bc21f6daac4
dirstate: don't rename branch file if writing it failed
Idan Kamara <idankk86@gmail.com>
parents:
17984
diff
changeset
|
296 except: # re-raises |
3bc21f6daac4
dirstate: don't rename branch file if writing it failed
Idan Kamara <idankk86@gmail.com>
parents:
17984
diff
changeset
|
297 f.discard() |
3bc21f6daac4
dirstate: don't rename branch file if writing it failed
Idan Kamara <idankk86@gmail.com>
parents:
17984
diff
changeset
|
298 raise |
4179
7e1c8a565a4f
Move branch read/write to dirstate where it belongs
Matt Mackall <mpm@selenic.com>
parents:
4172
diff
changeset
|
299 |
4615
9b00b73a5286
dirstate: hide some more internals
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
300 def _read(self): |
4614
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
301 self._map = {} |
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
302 self._copymap = {} |
4607
49dcac6ede26
dirstate: fold parse into read
Matt Mackall <mpm@selenic.com>
parents:
4606
diff
changeset
|
303 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
|
304 st = self._opener.read("dirstate") |
4607
49dcac6ede26
dirstate: fold parse into read
Matt Mackall <mpm@selenic.com>
parents:
4606
diff
changeset
|
305 except IOError, err: |
10282
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
306 if err.errno != errno.ENOENT: |
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
307 raise |
4607
49dcac6ede26
dirstate: fold parse into read
Matt Mackall <mpm@selenic.com>
parents:
4606
diff
changeset
|
308 return |
49dcac6ede26
dirstate: fold parse into read
Matt Mackall <mpm@selenic.com>
parents:
4606
diff
changeset
|
309 if not st: |
49dcac6ede26
dirstate: fold parse into read
Matt Mackall <mpm@selenic.com>
parents:
4606
diff
changeset
|
310 return |
49dcac6ede26
dirstate: fold parse into read
Matt Mackall <mpm@selenic.com>
parents:
4606
diff
changeset
|
311 |
18649
0969980308c7
dirstate: disable gc while parsing the dirstate
Siddharth Agarwal <sid0@fb.com>
parents:
18567
diff
changeset
|
312 # 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
|
313 # 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
|
314 # 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
|
315 # 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
|
316 # 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
|
317 # 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
|
318 # 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
|
319 # 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
|
320 # 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
|
321 # parsing the dirstate. |
23496
ee5a4ed4c8b1
dirstate: use the 'nogc' decorator
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23375
diff
changeset
|
322 # |
ee5a4ed4c8b1
dirstate: use the 'nogc' decorator
Pierre-Yves David <pierre-yves.david@fb.com>
parents:
23375
diff
changeset
|
323 # (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
|
324 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
|
325 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
|
326 if not self._dirtypl: |
7093
16bafcebd3d1
dirstate: C parsing extension
Matt Mackall <mpm@selenic.com>
parents:
7069
diff
changeset
|
327 self._pl = p |
363 | 328 |
4613
3a645af7fb76
localrepo and dirstate: rename reload to invalidate
Matt Mackall <mpm@selenic.com>
parents:
4612
diff
changeset
|
329 def invalidate(self): |
13200
6f011cf52f9a
avoid .split() in for loops and use tuples instead
David Soria Parra <dsp@php.net>
parents:
13047
diff
changeset
|
330 for a in ("_map", "_copymap", "_foldmap", "_branch", "_pl", "_dirs", |
6f011cf52f9a
avoid .split() in for loops and use tuples instead
David Soria Parra <dsp@php.net>
parents:
13047
diff
changeset
|
331 "_ignore"): |
4953
6b3ed43f77ba
dirstate.invalidate: avoid rebuilding _map
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4952
diff
changeset
|
332 if a in self.__dict__: |
6b3ed43f77ba
dirstate.invalidate: avoid rebuilding _map
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4952
diff
changeset
|
333 delattr(self, a) |
15791
a814f8fcc65a
Use explicit integer division
Martin Geisler <mg@aragost.com>
parents:
15670
diff
changeset
|
334 self._lastnormaltime = 0 |
4903
81078e177266
dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents:
4677
diff
changeset
|
335 self._dirty = False |
22404
12bc7f06fc41
dirstate: add begin/endparentchange to dirstate
Durham Goode <durham@fb.com>
parents:
21984
diff
changeset
|
336 self._parentwriters = 0 |
4375
109077e7048d
When reloading the dirstate, recompute ignore information if needed.
Bryan O'Sullivan <bos@serpentine.com>
parents:
4374
diff
changeset
|
337 |
363 | 338 def copy(self, source, dest): |
10145
aec936051734
dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents:
9678
diff
changeset
|
339 """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
|
340 if source == dest: |
deda205a00e1
Ignore dummy copies in dirstate and localrepo.filecommit()
Patrick Mezard <pmezard@gmail.com>
parents:
6479
diff
changeset
|
341 return |
4903
81078e177266
dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents:
4677
diff
changeset
|
342 self._dirty = True |
7566
5f7e3f17aece
mq: drop copy records when refreshing regular patches (issue1441)
Patrick Mezard <pmezard@gmail.com>
parents:
7280
diff
changeset
|
343 if source is not None: |
5f7e3f17aece
mq: drop copy records when refreshing regular patches (issue1441)
Patrick Mezard <pmezard@gmail.com>
parents:
7280
diff
changeset
|
344 self._copymap[dest] = source |
5f7e3f17aece
mq: drop copy records when refreshing regular patches (issue1441)
Patrick Mezard <pmezard@gmail.com>
parents:
7280
diff
changeset
|
345 elif dest in self._copymap: |
5f7e3f17aece
mq: drop copy records when refreshing regular patches (issue1441)
Patrick Mezard <pmezard@gmail.com>
parents:
7280
diff
changeset
|
346 del self._copymap[dest] |
363 | 347 |
348 def copied(self, file): | |
4614
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
349 return self._copymap.get(file, None) |
3154
b1f10d3223c1
dirstate: add copies function
Matt Mackall <mpm@selenic.com>
parents:
2962
diff
changeset
|
350 |
b1f10d3223c1
dirstate: add copies function
Matt Mackall <mpm@selenic.com>
parents:
2962
diff
changeset
|
351 def copies(self): |
4614
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
352 return self._copymap |
515 | 353 |
6767
80605a8127e0
dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents:
6762
diff
changeset
|
354 def _droppath(self, f): |
80605a8127e0
dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents:
6762
diff
changeset
|
355 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
|
356 self._dirs.delpath(f) |
2953 | 357 |
17196
2abe975ffb94
dirstate: eliminate redundant check parameter on _addpath()
Adrian Buehlmann <adrian@cadifra.com>
parents:
17094
diff
changeset
|
358 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
|
359 oldstate = self[f] |
17196
2abe975ffb94
dirstate: eliminate redundant check parameter on _addpath()
Adrian Buehlmann <adrian@cadifra.com>
parents:
17094
diff
changeset
|
360 if state == 'a' or oldstate == 'r': |
13974
23f2736abce3
move checkfilename from util to scmutil
Adrian Buehlmann <adrian@cadifra.com>
parents:
13944
diff
changeset
|
361 scmutil.checkfilename(f) |
6767
80605a8127e0
dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents:
6762
diff
changeset
|
362 if f in self._dirs: |
80605a8127e0
dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents:
6762
diff
changeset
|
363 raise util.Abort(_('directory %r already in dirstate') % f) |
80605a8127e0
dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents:
6762
diff
changeset
|
364 # shadows |
18897
38982de2b4eb
scmutil: migrate finddirs from dirstate
Bryan O'Sullivan <bryano@fb.com>
parents:
18869
diff
changeset
|
365 for d in scmutil.finddirs(f): |
6767
80605a8127e0
dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents:
6762
diff
changeset
|
366 if d in self._dirs: |
80605a8127e0
dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents:
6762
diff
changeset
|
367 break |
80605a8127e0
dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents:
6762
diff
changeset
|
368 if d in self._map and self[d] != 'r': |
80605a8127e0
dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents:
6762
diff
changeset
|
369 raise util.Abort( |
80605a8127e0
dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents:
6762
diff
changeset
|
370 _('file %r in dirstate clashes with %r') % (d, f)) |
80605a8127e0
dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents:
6762
diff
changeset
|
371 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
|
372 self._dirs.addpath(f) |
17094
c2016bae3b97
dirstate: factor common update code into _addpath
Joshua Redstone <joshua.redstone@fb.com>
parents:
16955
diff
changeset
|
373 self._dirty = True |
21808
7537e57f5dbd
dirstate: add dirstatetuple to create dirstate values
Siddharth Agarwal <sid0@fb.com>
parents:
21116
diff
changeset
|
374 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
|
375 |
4904
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4903
diff
changeset
|
376 def normal(self, f): |
10145
aec936051734
dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents:
9678
diff
changeset
|
377 '''Mark a file normal and clean.''' |
4905
fc61495ea9cf
dirstate: make wjoin function private
Matt Mackall <mpm@selenic.com>
parents:
4904
diff
changeset
|
378 s = os.lstat(self._join(f)) |
13754
ae157ca56cd5
dirstate: check mtime when adding to _lastnormal
Adrian Buehlmann <adrian@cadifra.com>
parents:
13743
diff
changeset
|
379 mtime = int(s.st_mtime) |
17733
3c775c5a6c03
dirstate: handle large dates and times with masking (issue2608)
Matt Mackall <mpm@selenic.com>
parents:
17197
diff
changeset
|
380 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
|
381 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
|
382 if f in self._copymap: |
4904
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4903
diff
changeset
|
383 del self._copymap[f] |
13763
7a73c406c0fd
dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents:
13754
diff
changeset
|
384 if mtime > self._lastnormaltime: |
7a73c406c0fd
dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents:
13754
diff
changeset
|
385 # 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
|
386 # 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
|
387 # modifications that happen within the same timeslot. |
13763
7a73c406c0fd
dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents:
13754
diff
changeset
|
388 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
|
389 |
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
|
390 def normallookup(self, f): |
10145
aec936051734
dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents:
9678
diff
changeset
|
391 '''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
|
392 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
|
393 # 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
|
394 # 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
|
395 # 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
|
396 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
|
397 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
|
398 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
|
399 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
|
400 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
|
401 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
|
402 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
|
403 if source: |
53cbb33e1269
normallookup: during merges, restore the state saved by remove
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
6297
diff
changeset
|
404 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
|
405 return |
53cbb33e1269
normallookup: during merges, restore the state saved by remove
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
6297
diff
changeset
|
406 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
|
407 return |
17094
c2016bae3b97
dirstate: factor common update code into _addpath
Joshua Redstone <joshua.redstone@fb.com>
parents:
16955
diff
changeset
|
408 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
|
409 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
|
410 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
|
411 |
10968
7a0d096e221e
dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10935
diff
changeset
|
412 def otherparent(self, f): |
7a0d096e221e
dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10935
diff
changeset
|
413 '''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
|
414 if self._pl[1] == nullid: |
7a0d096e221e
dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10935
diff
changeset
|
415 raise util.Abort(_("setting %r to other parent " |
7a0d096e221e
dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10935
diff
changeset
|
416 "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
|
417 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
|
418 # merge-like |
7e9cbb9c6053
dirstate: use 'm' state in otherparent to reduce ambiguity
Matt Mackall <mpm@selenic.com>
parents:
22895
diff
changeset
|
419 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
|
420 else: |
7e9cbb9c6053
dirstate: use 'm' state in otherparent to reduce ambiguity
Matt Mackall <mpm@selenic.com>
parents:
22895
diff
changeset
|
421 # add-like |
7e9cbb9c6053
dirstate: use 'm' state in otherparent to reduce ambiguity
Matt Mackall <mpm@selenic.com>
parents:
22895
diff
changeset
|
422 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
|
423 |
4904
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4903
diff
changeset
|
424 if f in self._copymap: |
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4903
diff
changeset
|
425 del self._copymap[f] |
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4903
diff
changeset
|
426 |
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4903
diff
changeset
|
427 def add(self, f): |
10145
aec936051734
dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents:
9678
diff
changeset
|
428 '''Mark a file added.''' |
17196
2abe975ffb94
dirstate: eliminate redundant check parameter on _addpath()
Adrian Buehlmann <adrian@cadifra.com>
parents:
17094
diff
changeset
|
429 self._addpath(f, 'a', 0, -1, -1) |
4904
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4903
diff
changeset
|
430 if f in self._copymap: |
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4903
diff
changeset
|
431 del self._copymap[f] |
4616
70352337934e
dirstate: refactor checkinterfering
Matt Mackall <mpm@selenic.com>
parents:
4615
diff
changeset
|
432 |
4904
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4903
diff
changeset
|
433 def remove(self, f): |
10145
aec936051734
dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents:
9678
diff
changeset
|
434 '''Mark a file removed.''' |
4904
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4903
diff
changeset
|
435 self._dirty = True |
6767
80605a8127e0
dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents:
6762
diff
changeset
|
436 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
|
437 size = 0 |
fed1a9c22076
dirstate.remove: during merges, remember the previous file state
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
6257
diff
changeset
|
438 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
|
439 # 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
|
440 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
|
441 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
|
442 size = -1 |
10968
7a0d096e221e
dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10935
diff
changeset
|
443 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
|
444 size = -2 |
21808
7537e57f5dbd
dirstate: add dirstatetuple to create dirstate values
Siddharth Agarwal <sid0@fb.com>
parents:
21116
diff
changeset
|
445 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
|
446 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
|
447 del self._copymap[f] |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
448 |
4904
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4903
diff
changeset
|
449 def merge(self, f): |
10145
aec936051734
dirstate: improve docstring formatting
Martin Geisler <mg@lazybytes.net>
parents:
9678
diff
changeset
|
450 '''Mark a file merged.''' |
16509
eab9119c5dee
rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents:
16472
diff
changeset
|
451 if self._pl[1] == nullid: |
eab9119c5dee
rebase: skip resolved but emptied revisions
Patrick Mezard <patrick@mezard.eu>
parents:
16472
diff
changeset
|
452 return self.normallookup(f) |
22897
8fe74328f700
dirstate: merge falls through to otherparent
Matt Mackall <mpm@selenic.com>
parents:
22896
diff
changeset
|
453 return self.otherparent(f) |
4904
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4903
diff
changeset
|
454 |
14434
cc8c09855d19
dirstate: rename forget to drop
Matt Mackall <mpm@selenic.com>
parents:
14273
diff
changeset
|
455 def drop(self, f): |
cc8c09855d19
dirstate: rename forget to drop
Matt Mackall <mpm@selenic.com>
parents:
14273
diff
changeset
|
456 '''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
|
457 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
|
458 self._dirty = True |
41453d55b481
dirstate: don't fail when dropping a not-tracked file (issue3080)
Matt Mackall <mpm@selenic.com>
parents:
15337
diff
changeset
|
459 self._droppath(f) |
41453d55b481
dirstate: don't fail when dropping a not-tracked file (issue3080)
Matt Mackall <mpm@selenic.com>
parents:
15337
diff
changeset
|
460 del self._map[f] |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
461 |
16542
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
462 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
|
463 normed = util.normcase(path) |
13717
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
464 folded = self._foldmap.get(normed, None) |
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
465 if folded is None: |
16542
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
466 if isknown: |
13717
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
467 folded = path |
7068
57377fa7eda2
issue 1286: dirstat regression on case folding systems
Petr Kodl <petrkodl@gmail.com>
parents:
7034
diff
changeset
|
468 else: |
16542
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
469 if exists is None: |
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
470 exists = os.path.lexists(os.path.join(self._root, path)) |
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
471 if not exists: |
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
472 # Maybe a path component exists |
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
473 if not ignoremissing and '/' in path: |
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
474 d, f = path.rsplit('/', 1) |
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
475 d = self._normalize(d, isknown, ignoremissing, None) |
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
476 folded = d + "/" + f |
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
477 else: |
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
478 # No path components, preserve original case |
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
479 folded = path |
16302
49b54f1ae053
dirstate: normalize case of directory components
Matt Mackall <mpm@selenic.com>
parents:
16258
diff
changeset
|
480 else: |
16542
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
481 # recursively normalize leading directory components |
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
482 # against dirstate |
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
483 if '/' in normed: |
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
484 d, f = normed.rsplit('/', 1) |
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
485 d = self._normalize(d, isknown, ignoremissing, True) |
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
486 r = self._root + "/" + d |
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
487 folded = d + "/" + util.fspath(f, r) |
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
488 else: |
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
489 folded = util.fspath(normed, self._root) |
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
490 self._foldmap[normed] = folded |
16302
49b54f1ae053
dirstate: normalize case of directory components
Matt Mackall <mpm@selenic.com>
parents:
16258
diff
changeset
|
491 |
13717
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
492 return folded |
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
493 |
16542
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
494 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
|
495 ''' |
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
496 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
|
497 |
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
498 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
|
499 disk, to avoid extra filesystem access. |
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
500 |
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
501 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
|
502 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
|
503 existing path components. |
13717
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
504 |
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
505 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
|
506 |
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
507 - 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
|
508 - version of name stored on disk |
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
509 - version provided via command arguments |
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
510 ''' |
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
511 |
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
512 if self._checkcase: |
16542
e596a631210e
dirstate: preserve path components case on renames (issue3402)
Patrick Mezard <patrick@mezard.eu>
parents:
16509
diff
changeset
|
513 return self._normalize(path, isknown, ignoremissing) |
13717
bc41d08a5ccc
dirstate: introduce a public case normalizing method
Matt Mackall <mpm@selenic.com>
parents:
13400
diff
changeset
|
514 return path |
6677
9865e15febd0
Add a normalize() method to dirstate
Paul Moore <p.f.moore@gmail.com>
parents:
6675
diff
changeset
|
515 |
5065
b304c2496f52
dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4953
diff
changeset
|
516 def clear(self): |
b304c2496f52
dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4953
diff
changeset
|
517 self._map = {} |
5487
7a64931e2d76
Fix file-changed-to-dir and dir-to-file commits (issue660).
Maxim Dounin <mdounin@mdounin.ru>
parents:
5396
diff
changeset
|
518 if "_dirs" in self.__dict__: |
10394
4612cded5176
fix coding style (reported by pylint)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10282
diff
changeset
|
519 delattr(self, "_dirs") |
5065
b304c2496f52
dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4953
diff
changeset
|
520 self._copymap = {} |
b304c2496f52
dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4953
diff
changeset
|
521 self._pl = [nullid, nullid] |
15791
a814f8fcc65a
Use explicit integer division
Martin Geisler <mg@aragost.com>
parents:
15670
diff
changeset
|
522 self._lastnormaltime = 0 |
5123 | 523 self._dirty = True |
5065
b304c2496f52
dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4953
diff
changeset
|
524 |
18760
e74704c33e24
strip: make --keep option not set all dirstate times to 0
Durham Goode <durham@fb.com>
parents:
18663
diff
changeset
|
525 def rebuild(self, parent, allfiles, changedfiles=None): |
e74704c33e24
strip: make --keep option not set all dirstate times to 0
Durham Goode <durham@fb.com>
parents:
18663
diff
changeset
|
526 changedfiles = changedfiles or allfiles |
e74704c33e24
strip: make --keep option not set all dirstate times to 0
Durham Goode <durham@fb.com>
parents:
18663
diff
changeset
|
527 oldmap = self._map |
5065
b304c2496f52
dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4953
diff
changeset
|
528 self.clear() |
18760
e74704c33e24
strip: make --keep option not set all dirstate times to 0
Durham Goode <durham@fb.com>
parents:
18663
diff
changeset
|
529 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
|
530 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
|
531 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
|
532 else: |
18760
e74704c33e24
strip: make --keep option not set all dirstate times to 0
Durham Goode <durham@fb.com>
parents:
18663
diff
changeset
|
533 if 'x' in allfiles.flags(f): |
21808
7537e57f5dbd
dirstate: add dirstatetuple to create dirstate values
Siddharth Agarwal <sid0@fb.com>
parents:
21116
diff
changeset
|
534 self._map[f] = dirstatetuple('n', 0777, -1, 0) |
18760
e74704c33e24
strip: make --keep option not set all dirstate times to 0
Durham Goode <durham@fb.com>
parents:
18663
diff
changeset
|
535 else: |
21808
7537e57f5dbd
dirstate: add dirstatetuple to create dirstate values
Siddharth Agarwal <sid0@fb.com>
parents:
21116
diff
changeset
|
536 self._map[f] = dirstatetuple('n', 0666, -1, 0) |
4614
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
537 self._pl = (parent, nullid) |
4903
81078e177266
dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents:
4677
diff
changeset
|
538 self._dirty = True |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
539 |
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
540 def write(self): |
4612
17ee7407097f
dirstate: simplify dirty handling
Matt Mackall <mpm@selenic.com>
parents:
4611
diff
changeset
|
541 if not self._dirty: |
1794
98b6c1cad58b
only write the dirstate when something changed
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1755
diff
changeset
|
542 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
|
543 |
89b809fa6cef
dirstate: delay writing out to ensure timestamp of each entries explicitly
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
21810
diff
changeset
|
544 # 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
|
545 # 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
|
546 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
|
547 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
|
548 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
|
549 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
|
550 |
6326
af3f26b6bba4
dirstate: ignore stat data for files that were updated too recently
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
6298
diff
changeset
|
551 st = self._opener("dirstate", "w", atomictemp=True) |
9509
e4ca8c258d9b
dirstate: kill dirstate.granularity config option
Adrian Buehlmann <adrian@cadifra.com>
parents:
9379
diff
changeset
|
552 # 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
|
553 # filesystem's notion of 'now' |
16955
92e1c64ba0d4
parsers: add a C function to pack the dirstate
Bryan O'Sullivan <bryano@fb.com>
parents:
16686
diff
changeset
|
554 now = util.fstat(st).st_mtime |
21026
7ee03e190c1d
dirstate: inline local finish function
Mads Kiilerich <madski@unity3d.com>
parents:
20632
diff
changeset
|
555 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
|
556 st.close() |
7ee03e190c1d
dirstate: inline local finish function
Mads Kiilerich <madski@unity3d.com>
parents:
20632
diff
changeset
|
557 self._lastnormaltime = 0 |
7ee03e190c1d
dirstate: inline local finish function
Mads Kiilerich <madski@unity3d.com>
parents:
20632
diff
changeset
|
558 self._dirty = self._dirtypl = False |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
559 |
6032
b41f0d6a74fc
dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5516
diff
changeset
|
560 def _dirignore(self, f): |
6479
31abcae33b4f
dirstate: do not ignore current directory '.' (issue 1078)
Patrick Mezard <pmezard@gmail.com>
parents:
6327
diff
changeset
|
561 if f == '.': |
31abcae33b4f
dirstate: do not ignore current directory '.' (issue 1078)
Patrick Mezard <pmezard@gmail.com>
parents:
6327
diff
changeset
|
562 return False |
6032
b41f0d6a74fc
dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5516
diff
changeset
|
563 if self._ignore(f): |
b41f0d6a74fc
dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5516
diff
changeset
|
564 return True |
18897
38982de2b4eb
scmutil: migrate finddirs from dirstate
Bryan O'Sullivan <bryano@fb.com>
parents:
18869
diff
changeset
|
565 for p in scmutil.finddirs(f): |
6767
80605a8127e0
dirstate: simplify/optimize path checking
Matt Mackall <mpm@selenic.com>
parents:
6762
diff
changeset
|
566 if self._ignore(p): |
6032
b41f0d6a74fc
dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5516
diff
changeset
|
567 return True |
b41f0d6a74fc
dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5516
diff
changeset
|
568 return False |
b41f0d6a74fc
dirstate: don't walk ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5516
diff
changeset
|
569 |
19173
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
570 def _walkexplicit(self, match, subrepos): |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
571 '''Get stat data about the files explicitly specified by match. |
3529 | 572 |
19174
022256ef47b8
dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents:
19173
diff
changeset
|
573 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
|
574 - 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
|
575 listings mapping subrepos and .hg to None. |
19174
022256ef47b8
dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents:
19173
diff
changeset
|
576 - 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
|
577 - 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
|
578 directories and that were not found.''' |
6578
f242d3684f83
walk: begin refactoring badmatch handling
Matt Mackall <mpm@selenic.com>
parents:
6577
diff
changeset
|
579 |
8681
26f133267cd7
walk: use match.bad callback for filetype messages
Matt Mackall <mpm@selenic.com>
parents:
8680
diff
changeset
|
580 def badtype(mode): |
8310
8417d82d3969
dirstate: translate forgotten string
Simon Heimberg <simohe@besonet.ch>
parents:
8261
diff
changeset
|
581 kind = _('unknown') |
10282
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
582 if stat.S_ISCHR(mode): |
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
583 kind = _('character device') |
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
584 elif stat.S_ISBLK(mode): |
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
585 kind = _('block device') |
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
586 elif stat.S_ISFIFO(mode): |
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
587 kind = _('fifo') |
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
588 elif stat.S_ISSOCK(mode): |
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
589 kind = _('socket') |
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
590 elif stat.S_ISDIR(mode): |
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
591 kind = _('directory') |
8681
26f133267cd7
walk: use match.bad callback for filetype messages
Matt Mackall <mpm@selenic.com>
parents:
8680
diff
changeset
|
592 return _('unsupported file type (type is %s)') % kind |
6830
2cf4cda64727
dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents:
6829
diff
changeset
|
593 |
19142
c3d3e4d75ec3
dirstate.walk: cache match.explicitdir and traversedir locally
Siddharth Agarwal <sid0@fb.com>
parents:
19137
diff
changeset
|
594 matchedir = match.explicitdir |
8676
acd69fc201a5
walk: we always have a badfn
Matt Mackall <mpm@selenic.com>
parents:
8675
diff
changeset
|
595 badfn = match.bad |
6831
2b663f542bd3
dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents:
6830
diff
changeset
|
596 dmap = self._map |
5000
46facb73ba8b
dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents:
4965
diff
changeset
|
597 normpath = util.normpath |
46facb73ba8b
dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents:
4965
diff
changeset
|
598 lstat = os.lstat |
6830
2cf4cda64727
dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents:
6829
diff
changeset
|
599 getkind = stat.S_IFMT |
6828
55d65a33da52
dirstate.walk: minor cleanups
Matt Mackall <mpm@selenic.com>
parents:
6827
diff
changeset
|
600 dirkind = stat.S_IFDIR |
6830
2cf4cda64727
dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents:
6829
diff
changeset
|
601 regkind = stat.S_IFREG |
2cf4cda64727
dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents:
6829
diff
changeset
|
602 lnkkind = stat.S_IFLNK |
6831
2b663f542bd3
dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents:
6830
diff
changeset
|
603 join = self._join |
19174
022256ef47b8
dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents:
19173
diff
changeset
|
604 dirsfound = [] |
022256ef47b8
dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents:
19173
diff
changeset
|
605 foundadd = dirsfound.append |
19173
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
606 dirsnotfound = [] |
19175
63f7bd2e1a46
dirstate._walkexplicit: inline dirsnotfound.append
Siddharth Agarwal <sid0@fb.com>
parents:
19174
diff
changeset
|
607 notfoundadd = dirsnotfound.append |
6820
639d9cb95509
dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents:
6819
diff
changeset
|
608 |
19173
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
609 if match.matchfn != match.exact and self._checkcase: |
12907
e255a5dc29e6
dirstate: skip optimization on case-folding FS (issue2440)
Matt Mackall <mpm@selenic.com>
parents:
12401
diff
changeset
|
610 normalize = self._normalize |
e255a5dc29e6
dirstate: skip optimization on case-folding FS (issue2440)
Matt Mackall <mpm@selenic.com>
parents:
12401
diff
changeset
|
611 else: |
18032
a9e623bb440e
dirstate: test normalize is truthy instead of using a no-op lambda
Siddharth Agarwal <sid0@fb.com>
parents:
18018
diff
changeset
|
612 normalize = None |
12907
e255a5dc29e6
dirstate: skip optimization on case-folding FS (issue2440)
Matt Mackall <mpm@selenic.com>
parents:
12401
diff
changeset
|
613 |
12211
798d72f3621c
dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12164
diff
changeset
|
614 files = sorted(match.files()) |
798d72f3621c
dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12164
diff
changeset
|
615 subrepos.sort() |
798d72f3621c
dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12164
diff
changeset
|
616 i, j = 0, 0 |
798d72f3621c
dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12164
diff
changeset
|
617 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
|
618 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
|
619 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
|
620 i += 1 |
798d72f3621c
dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12164
diff
changeset
|
621 continue |
13339
22167be007ed
subrepo: fix pruning of subrepo filenames in dirstate (issue2619)
trbs <trbs@trbs.net>
parents:
13233
diff
changeset
|
622 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
|
623 del files[i] |
798d72f3621c
dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12164
diff
changeset
|
624 j += 1 |
798d72f3621c
dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12164
diff
changeset
|
625 |
6831
2b663f542bd3
dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents:
6830
diff
changeset
|
626 if not files or '.' in files: |
2b663f542bd3
dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents:
6830
diff
changeset
|
627 files = [''] |
10176
24ce8f0c0a39
dirstate: don't check state of subrepo directories
Augie Fackler <durin42@gmail.com>
parents:
10145
diff
changeset
|
628 results = dict.fromkeys(subrepos) |
24ce8f0c0a39
dirstate: don't check state of subrepo directories
Augie Fackler <durin42@gmail.com>
parents:
10145
diff
changeset
|
629 results['.hg'] = None |
5000
46facb73ba8b
dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents:
4965
diff
changeset
|
630 |
23375
a179db3db9b9
dirstate: speed up repeated missing directory checks
Martin von Zweigbergk <martinvonz@google.com>
parents:
22915
diff
changeset
|
631 alldirs = None |
12211
798d72f3621c
dirstate: use one pass to filter out files in subrepos
Martin Geisler <mg@lazybytes.net>
parents:
12164
diff
changeset
|
632 for ff in files: |
18032
a9e623bb440e
dirstate: test normalize is truthy instead of using a no-op lambda
Siddharth Agarwal <sid0@fb.com>
parents:
18018
diff
changeset
|
633 if normalize: |
a9e623bb440e
dirstate: test normalize is truthy instead of using a no-op lambda
Siddharth Agarwal <sid0@fb.com>
parents:
18018
diff
changeset
|
634 nf = normalize(normpath(ff), False, True) |
a9e623bb440e
dirstate: test normalize is truthy instead of using a no-op lambda
Siddharth Agarwal <sid0@fb.com>
parents:
18018
diff
changeset
|
635 else: |
a9e623bb440e
dirstate: test normalize is truthy instead of using a no-op lambda
Siddharth Agarwal <sid0@fb.com>
parents:
18018
diff
changeset
|
636 nf = normpath(ff) |
6829
fec1da46006e
dirstate.walk: build a dict rather than yield
Matt Mackall <mpm@selenic.com>
parents:
6828
diff
changeset
|
637 if nf in results: |
6820
639d9cb95509
dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents:
6819
diff
changeset
|
638 continue |
639d9cb95509
dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents:
6819
diff
changeset
|
639 |
639d9cb95509
dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents:
6819
diff
changeset
|
640 try: |
6831
2b663f542bd3
dirstate.walk: more cleanups
Matt Mackall <mpm@selenic.com>
parents:
6830
diff
changeset
|
641 st = lstat(join(nf)) |
6830
2cf4cda64727
dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents:
6829
diff
changeset
|
642 kind = getkind(st.st_mode) |
2cf4cda64727
dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents:
6829
diff
changeset
|
643 if kind == dirkind: |
8588
2624f485b9bc
dirstate: set more states in step 1 of walk
Simon Heimberg <simohe@besonet.ch>
parents:
8521
diff
changeset
|
644 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
|
645 # 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
|
646 results[nf] = None |
19143
3cb9468535bd
match: make explicitdir and traversedir None by default
Siddharth Agarwal <sid0@fb.com>
parents:
19142
diff
changeset
|
647 if matchedir: |
3cb9468535bd
match: make explicitdir and traversedir None by default
Siddharth Agarwal <sid0@fb.com>
parents:
19142
diff
changeset
|
648 matchedir(nf) |
19174
022256ef47b8
dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents:
19173
diff
changeset
|
649 foundadd(nf) |
12401
4cdaf1adafc8
backout most of 4f8067c94729
Matt Mackall <mpm@selenic.com>
parents:
12387
diff
changeset
|
650 elif kind == regkind or kind == lnkkind: |
6830
2cf4cda64727
dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents:
6829
diff
changeset
|
651 results[nf] = st |
6828
55d65a33da52
dirstate.walk: minor cleanups
Matt Mackall <mpm@selenic.com>
parents:
6827
diff
changeset
|
652 else: |
8681
26f133267cd7
walk: use match.bad callback for filetype messages
Matt Mackall <mpm@selenic.com>
parents:
8680
diff
changeset
|
653 badfn(ff, badtype(kind)) |
6830
2cf4cda64727
dirstate.walk: fold in _supported
Matt Mackall <mpm@selenic.com>
parents:
6829
diff
changeset
|
654 if nf in dmap: |
6829
fec1da46006e
dirstate.walk: build a dict rather than yield
Matt Mackall <mpm@selenic.com>
parents:
6828
diff
changeset
|
655 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
|
656 except OSError, inst: # nf not found on disk - it is dirstate only |
1b6e37f44250
dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents:
21026
diff
changeset
|
657 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
|
658 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
|
659 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
|
660 if alldirs is None: |
a179db3db9b9
dirstate: speed up repeated missing directory checks
Martin von Zweigbergk <martinvonz@google.com>
parents:
22915
diff
changeset
|
661 alldirs = scmutil.dirs(dmap) |
a179db3db9b9
dirstate: speed up repeated missing directory checks
Martin von Zweigbergk <martinvonz@google.com>
parents:
22915
diff
changeset
|
662 if nf in alldirs: |
a179db3db9b9
dirstate: speed up repeated missing directory checks
Martin von Zweigbergk <martinvonz@google.com>
parents:
22915
diff
changeset
|
663 if matchedir: |
a179db3db9b9
dirstate: speed up repeated missing directory checks
Martin von Zweigbergk <martinvonz@google.com>
parents:
22915
diff
changeset
|
664 matchedir(nf) |
a179db3db9b9
dirstate: speed up repeated missing directory checks
Martin von Zweigbergk <martinvonz@google.com>
parents:
22915
diff
changeset
|
665 notfoundadd(nf) |
8677
34df078b8b1b
walk: simplify logic for badfn clause
Matt Mackall <mpm@selenic.com>
parents:
8676
diff
changeset
|
666 else: |
8680
b6511055d37b
match: ignore return of match.bad
Matt Mackall <mpm@selenic.com>
parents:
8677
diff
changeset
|
667 badfn(ff, inst.strerror) |
6820
639d9cb95509
dirstate.walk: fold findfiles into main walk loop
Matt Mackall <mpm@selenic.com>
parents:
6819
diff
changeset
|
668 |
19174
022256ef47b8
dirstate._walkexplicit: rename work to dirsfound
Siddharth Agarwal <sid0@fb.com>
parents:
19173
diff
changeset
|
669 return results, dirsfound, dirsnotfound |
19173
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
670 |
19190
b03952ee634d
dirstate.walk: add a flag to let extensions avoid full walks
Siddharth Agarwal <sid0@fb.com>
parents:
19175
diff
changeset
|
671 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
|
672 ''' |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
673 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
|
674 matched by match. |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
675 |
19190
b03952ee634d
dirstate.walk: add a flag to let extensions avoid full walks
Siddharth Agarwal <sid0@fb.com>
parents:
19175
diff
changeset
|
676 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
|
677 |
19173
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
678 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
|
679 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
|
680 |
19173
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
681 ''' |
19190
b03952ee634d
dirstate.walk: add a flag to let extensions avoid full walks
Siddharth Agarwal <sid0@fb.com>
parents:
19175
diff
changeset
|
682 # 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
|
683 # 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
|
684 # 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
|
685 |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
686 if ignored: |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
687 ignore = util.never |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
688 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
|
689 elif unknown: |
1b6e37f44250
dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents:
21026
diff
changeset
|
690 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
|
691 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
|
692 else: |
1b6e37f44250
dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents:
21026
diff
changeset
|
693 # 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
|
694 ignore = util.always |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
695 dirignore = util.always |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
696 |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
697 matchfn = match.matchfn |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
698 matchalways = match.always() |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
699 matchtdir = match.traversedir |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
700 dmap = self._map |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
701 listdir = osutil.listdir |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
702 lstat = os.lstat |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
703 dirkind = stat.S_IFDIR |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
704 regkind = stat.S_IFREG |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
705 lnkkind = stat.S_IFLNK |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
706 join = self._join |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
707 |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
708 exact = skipstep3 = False |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
709 if matchfn == match.exact: # match.exact |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
710 exact = True |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
711 dirignore = util.always # skip step 2 |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
712 elif match.files() and not match.anypats(): # match.match, no patterns |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
713 skipstep3 = True |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
714 |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
715 if not exact and self._checkcase: |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
716 normalize = self._normalize |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
717 skipstep3 = False |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
718 else: |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
719 normalize = None |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
720 |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
721 # step 1: find all explicit files |
ec70a78a70e0
dirstate.walk: refactor explicit walk into separate function
Siddharth Agarwal <sid0@fb.com>
parents:
19172
diff
changeset
|
722 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
|
723 |
19172
c6cea2e2031b
dirstate.walk: pull skipstep3 out of the explicit walk code
Siddharth Agarwal <sid0@fb.com>
parents:
19171
diff
changeset
|
724 skipstep3 = skipstep3 and not (work or dirsnotfound) |
19171
252de7b77cfd
dirstate.walk: move dirignore filter out of explicit walk code
Siddharth Agarwal <sid0@fb.com>
parents:
19170
diff
changeset
|
725 work = [d for d in work if not dirignore(d)] |
252de7b77cfd
dirstate.walk: move dirignore filter out of explicit walk code
Siddharth Agarwal <sid0@fb.com>
parents:
19170
diff
changeset
|
726 wadd = work.append |
252de7b77cfd
dirstate.walk: move dirignore filter out of explicit walk code
Siddharth Agarwal <sid0@fb.com>
parents:
19170
diff
changeset
|
727 |
6826
eca20fee0728
dirstate.walk: pull directory scanning into top-level loop
Matt Mackall <mpm@selenic.com>
parents:
6825
diff
changeset
|
728 # step 2: visit subdirectories |
eca20fee0728
dirstate.walk: pull directory scanning into top-level loop
Matt Mackall <mpm@selenic.com>
parents:
6825
diff
changeset
|
729 while work: |
eca20fee0728
dirstate.walk: pull directory scanning into top-level loop
Matt Mackall <mpm@selenic.com>
parents:
6825
diff
changeset
|
730 nd = work.pop() |
7099
6f750e76fb46
dirstate.walk: skip unreadable directories (issue1213)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7096
diff
changeset
|
731 skip = None |
6826
eca20fee0728
dirstate.walk: pull directory scanning into top-level loop
Matt Mackall <mpm@selenic.com>
parents:
6825
diff
changeset
|
732 if nd == '.': |
eca20fee0728
dirstate.walk: pull directory scanning into top-level loop
Matt Mackall <mpm@selenic.com>
parents:
6825
diff
changeset
|
733 nd = '' |
eca20fee0728
dirstate.walk: pull directory scanning into top-level loop
Matt Mackall <mpm@selenic.com>
parents:
6825
diff
changeset
|
734 else: |
7099
6f750e76fb46
dirstate.walk: skip unreadable directories (issue1213)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7096
diff
changeset
|
735 skip = '.hg' |
6f750e76fb46
dirstate.walk: skip unreadable directories (issue1213)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7096
diff
changeset
|
736 try: |
6f750e76fb46
dirstate.walk: skip unreadable directories (issue1213)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7096
diff
changeset
|
737 entries = listdir(join(nd), stat=True, skip=skip) |
6f750e76fb46
dirstate.walk: skip unreadable directories (issue1213)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7096
diff
changeset
|
738 except OSError, inst: |
17879
7b0b1da49f15
dirstate: handle dangling junctions on windows (issue2579)
Bryan O'Sullivan <bryano@fb.com>
parents:
17821
diff
changeset
|
739 if inst.errno in (errno.EACCES, errno.ENOENT): |
21116
30c60e28aa9b
dirstate: report bad subdirectories as match.bad, not just a warning (BC)
Mads Kiilerich <madski@unity3d.com>
parents:
21115
diff
changeset
|
740 match.bad(self.pathto(nd), inst.strerror) |
7099
6f750e76fb46
dirstate.walk: skip unreadable directories (issue1213)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7096
diff
changeset
|
741 continue |
6f750e76fb46
dirstate.walk: skip unreadable directories (issue1213)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
7096
diff
changeset
|
742 raise |
6826
eca20fee0728
dirstate.walk: pull directory scanning into top-level loop
Matt Mackall <mpm@selenic.com>
parents:
6825
diff
changeset
|
743 for f, kind, st in entries: |
18032
a9e623bb440e
dirstate: test normalize is truthy instead of using a no-op lambda
Siddharth Agarwal <sid0@fb.com>
parents:
18018
diff
changeset
|
744 if normalize: |
a9e623bb440e
dirstate: test normalize is truthy instead of using a no-op lambda
Siddharth Agarwal <sid0@fb.com>
parents:
18018
diff
changeset
|
745 nf = normalize(nd and (nd + "/" + f) or f, True, True) |
a9e623bb440e
dirstate: test normalize is truthy instead of using a no-op lambda
Siddharth Agarwal <sid0@fb.com>
parents:
18018
diff
changeset
|
746 else: |
a9e623bb440e
dirstate: test normalize is truthy instead of using a no-op lambda
Siddharth Agarwal <sid0@fb.com>
parents:
18018
diff
changeset
|
747 nf = nd and (nd + "/" + f) or f |
6829
fec1da46006e
dirstate.walk: build a dict rather than yield
Matt Mackall <mpm@selenic.com>
parents:
6828
diff
changeset
|
748 if nf not in results: |
6828
55d65a33da52
dirstate.walk: minor cleanups
Matt Mackall <mpm@selenic.com>
parents:
6827
diff
changeset
|
749 if kind == dirkind: |
55d65a33da52
dirstate.walk: minor cleanups
Matt Mackall <mpm@selenic.com>
parents:
6827
diff
changeset
|
750 if not ignore(nf): |
19143
3cb9468535bd
match: make explicitdir and traversedir None by default
Siddharth Agarwal <sid0@fb.com>
parents:
19142
diff
changeset
|
751 if matchtdir: |
3cb9468535bd
match: make explicitdir and traversedir None by default
Siddharth Agarwal <sid0@fb.com>
parents:
19142
diff
changeset
|
752 matchtdir(nf) |
6828
55d65a33da52
dirstate.walk: minor cleanups
Matt Mackall <mpm@selenic.com>
parents:
6827
diff
changeset
|
753 wadd(nf) |
18814
1413ba410244
dirstate.walk: fast path match-always case during traversal
Siddharth Agarwal <sid0@fb.com>
parents:
18812
diff
changeset
|
754 if 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
|
755 results[nf] = None |
6832
643ff33812f8
dirstate.walk: inline imatch
Matt Mackall <mpm@selenic.com>
parents:
6831
diff
changeset
|
756 elif kind == regkind or kind == lnkkind: |
643ff33812f8
dirstate.walk: inline imatch
Matt Mackall <mpm@selenic.com>
parents:
6831
diff
changeset
|
757 if nf in dmap: |
18814
1413ba410244
dirstate.walk: fast path match-always case during traversal
Siddharth Agarwal <sid0@fb.com>
parents:
18812
diff
changeset
|
758 if matchalways or matchfn(nf): |
6832
643ff33812f8
dirstate.walk: inline imatch
Matt Mackall <mpm@selenic.com>
parents:
6831
diff
changeset
|
759 results[nf] = st |
18814
1413ba410244
dirstate.walk: fast path match-always case during traversal
Siddharth Agarwal <sid0@fb.com>
parents:
18812
diff
changeset
|
760 elif (matchalways or matchfn(nf)) and not ignore(nf): |
6829
fec1da46006e
dirstate.walk: build a dict rather than yield
Matt Mackall <mpm@selenic.com>
parents:
6828
diff
changeset
|
761 results[nf] = st |
18814
1413ba410244
dirstate.walk: fast path match-always case during traversal
Siddharth Agarwal <sid0@fb.com>
parents:
18812
diff
changeset
|
762 elif nf in dmap and (matchalways or matchfn(nf)): |
6832
643ff33812f8
dirstate.walk: inline imatch
Matt Mackall <mpm@selenic.com>
parents:
6831
diff
changeset
|
763 results[nf] = None |
536 | 764 |
18812
1c40526da52a
dirstate.walk: remove subrepo and .hg from results before step 3
Siddharth Agarwal <sid0@fb.com>
parents:
18792
diff
changeset
|
765 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
|
766 del results[s] |
1c40526da52a
dirstate.walk: remove subrepo and .hg from results before step 3
Siddharth Agarwal <sid0@fb.com>
parents:
18792
diff
changeset
|
767 del results['.hg'] |
1c40526da52a
dirstate.walk: remove subrepo and .hg from results before step 3
Siddharth Agarwal <sid0@fb.com>
parents:
18792
diff
changeset
|
768 |
21115
1b6e37f44250
dirstate: improve documentation and readability of match and ignore in the walker
Mads Kiilerich <madski@unity3d.com>
parents:
21026
diff
changeset
|
769 # 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
|
770 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
|
771 # 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
|
772 # 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
|
773 # 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
|
774 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
|
775 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
|
776 else: |
a18919de61e5
dirstate.walk: fast path none-seen + match-always case for step 3
Siddharth Agarwal <sid0@fb.com>
parents:
18814
diff
changeset
|
777 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
|
778 visit.sort() |
a18919de61e5
dirstate.walk: fast path none-seen + match-always case for step 3
Siddharth Agarwal <sid0@fb.com>
parents:
18814
diff
changeset
|
779 |
18625
2cbd27f4f3c4
dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents:
18567
diff
changeset
|
780 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
|
781 # 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
|
782 # 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
|
783 # 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
|
784 # 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
|
785 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
|
786 |
2cbd27f4f3c4
dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents:
18567
diff
changeset
|
787 for nf in iter(visit): |
2cbd27f4f3c4
dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents:
18567
diff
changeset
|
788 # 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
|
789 # under a symlink directory. |
19128
f4930b533d55
hgignore: fix regression with hgignore directory matches (issue3921)
Durham Goode <durham@fb.com>
parents:
19103
diff
changeset
|
790 if 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
|
791 try: |
05cf40f9b0ec
dirstate: fix generator/list error when using python 2.7
Durham Goode <durham@fb.com>
parents:
18653
diff
changeset
|
792 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
|
793 # 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
|
794 except OSError: |
05cf40f9b0ec
dirstate: fix generator/list error when using python 2.7
Durham Goode <durham@fb.com>
parents:
18653
diff
changeset
|
795 # file doesn't exist |
05cf40f9b0ec
dirstate: fix generator/list error when using python 2.7
Durham Goode <durham@fb.com>
parents:
18653
diff
changeset
|
796 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
|
797 else: |
2cbd27f4f3c4
dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents:
18567
diff
changeset
|
798 # 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
|
799 # 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
|
800 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
|
801 else: |
2cbd27f4f3c4
dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents:
18567
diff
changeset
|
802 # 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
|
803 # 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
|
804 nf = iter(visit).next |
2cbd27f4f3c4
dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents:
18567
diff
changeset
|
805 for st in util.statfiles([join(i) for i in visit]): |
2cbd27f4f3c4
dirstate: walk returns None for files that have a symlink in their path
Durham Goode <durham@fb.com>
parents:
18567
diff
changeset
|
806 results[nf()] = st |
6829
fec1da46006e
dirstate.walk: build a dict rather than yield
Matt Mackall <mpm@selenic.com>
parents:
6828
diff
changeset
|
807 return results |
669
8aa2a282eda4
.hgignore speedups patch incorporating Matt's feedback.
mwilli2@localhost.localdomain
parents:
667
diff
changeset
|
808 |
10176
24ce8f0c0a39
dirstate: don't check state of subrepo directories
Augie Fackler <durin42@gmail.com>
parents:
10145
diff
changeset
|
809 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
|
810 '''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
|
811 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
|
812 scmutil.status and: |
9518
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
813 |
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
814 unsure: |
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
815 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
|
816 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
|
817 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
|
818 status.modified: |
9518
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
819 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
|
820 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
|
821 status.clean: |
9518
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
822 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
|
823 dirstate was written |
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
824 ''' |
6753
ed5ffb2c12f3
repo.status: eliminate list_
Matt Mackall <mpm@selenic.com>
parents:
6750
diff
changeset
|
825 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
|
826 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
|
827 removed, deleted, clean = [], [], [] |
723 | 828 |
5003
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
829 dmap = self._map |
9518
bc19a0b04e83
dirstate: add/improve method docstrings.
Greg Ward <greg-hg@gerg.ca>
parents:
9509
diff
changeset
|
830 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
|
831 madd = modified.append |
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
832 aadd = added.append |
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
833 uadd = unknown.append |
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
834 iadd = ignored.append |
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
835 radd = removed.append |
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
836 dadd = deleted.append |
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
837 cadd = clean.append |
18034
1a570f04de07
dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents:
18032
diff
changeset
|
838 mexact = match.exact |
1a570f04de07
dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents:
18032
diff
changeset
|
839 dirignore = self._dirignore |
1a570f04de07
dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents:
18032
diff
changeset
|
840 checkexec = self._checkexec |
1a570f04de07
dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents:
18032
diff
changeset
|
841 copymap = self._copymap |
1a570f04de07
dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents:
18032
diff
changeset
|
842 lastnormaltime = self._lastnormaltime |
5003
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
843 |
19191
ab9de1e8fc36
dirstate.status: avoid full walks when possible
Siddharth Agarwal <sid0@fb.com>
parents:
19190
diff
changeset
|
844 # 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
|
845 # - we're listing all clean files, or |
ab9de1e8fc36
dirstate.status: avoid full walks when possible
Siddharth Agarwal <sid0@fb.com>
parents:
19190
diff
changeset
|
846 # - 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
|
847 # 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
|
848 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
|
849 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
|
850 full=full).iteritems(): |
6591
eda3fd322a7f
dirstate: minor status cleanups
Matt Mackall <mpm@selenic.com>
parents:
6590
diff
changeset
|
851 if fn not in dmap: |
18034
1a570f04de07
dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents:
18032
diff
changeset
|
852 if (listignored or mexact(fn)) and dirignore(fn): |
6753
ed5ffb2c12f3
repo.status: eliminate list_
Matt Mackall <mpm@selenic.com>
parents:
6750
diff
changeset
|
853 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
|
854 iadd(fn) |
19910
601944f41257
dirstate.status: return explicit unknown files even when not asked
Siddharth Agarwal <sid0@fb.com>
parents:
19651
diff
changeset
|
855 else: |
5003
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
856 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
|
857 continue |
6591
eda3fd322a7f
dirstate: minor status cleanups
Matt Mackall <mpm@selenic.com>
parents:
6590
diff
changeset
|
858 |
21810
4b2ebd3187a1
dirstate.status: assign members one by one instead of unpacking the tuple
Siddharth Agarwal <sid0@fb.com>
parents:
21809
diff
changeset
|
859 # 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
|
860 # 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
|
861 # 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
|
862 # 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
|
863 # 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
|
864 # 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
|
865 # 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
|
866 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
|
867 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
|
868 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
|
869 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
|
870 time = t[3] |
6591
eda3fd322a7f
dirstate: minor status cleanups
Matt Mackall <mpm@selenic.com>
parents:
6590
diff
changeset
|
871 |
6818
6e93fbd847ef
dirstate.walk: eliminate src from yield
Matt Mackall <mpm@selenic.com>
parents:
6811
diff
changeset
|
872 if not st and state in "nma": |
6e93fbd847ef
dirstate.walk: eliminate src from yield
Matt Mackall <mpm@selenic.com>
parents:
6811
diff
changeset
|
873 dadd(fn) |
6e93fbd847ef
dirstate.walk: eliminate src from yield
Matt Mackall <mpm@selenic.com>
parents:
6811
diff
changeset
|
874 elif state == 'n': |
13763
7a73c406c0fd
dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents:
13754
diff
changeset
|
875 mtime = int(st.st_mtime) |
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
|
876 if (size >= 0 and |
17733
3c775c5a6c03
dirstate: handle large dates and times with masking (issue2608)
Matt Mackall <mpm@selenic.com>
parents:
17197
diff
changeset
|
877 ((size != st.st_size and size != st.st_size & _rangemask) |
18034
1a570f04de07
dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents:
18032
diff
changeset
|
878 or ((mode ^ st.st_mode) & 0100 and checkexec)) |
10968
7a0d096e221e
dirstate: more explicit name, rename normaldirty() to otherparent()
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10935
diff
changeset
|
879 or size == -2 # other parent |
18034
1a570f04de07
dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents:
18032
diff
changeset
|
880 or fn in copymap): |
5003
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
881 madd(fn) |
19651
902c646019ad
dirstate.status: don't ignore symlink placeholders in the normal set
Siddharth Agarwal <sid0@fb.com>
parents:
19216
diff
changeset
|
882 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
|
883 ladd(fn) |
18034
1a570f04de07
dirstate: inline more properties and methods in status
Siddharth Agarwal <sid0@fb.com>
parents:
18032
diff
changeset
|
884 elif mtime == lastnormaltime: |
13763
7a73c406c0fd
dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents:
13754
diff
changeset
|
885 # fn may have been changed in the same timeslot without |
7a73c406c0fd
dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents:
13754
diff
changeset
|
886 # changing its size. This can happen if we quickly do |
7a73c406c0fd
dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents:
13754
diff
changeset
|
887 # multiple commits in a single transaction. |
7a73c406c0fd
dirstate: eliminate _lastnormal set
Adrian Buehlmann <adrian@cadifra.com>
parents:
13754
diff
changeset
|
888 # 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
|
889 ladd(fn) |
6753
ed5ffb2c12f3
repo.status: eliminate list_
Matt Mackall <mpm@selenic.com>
parents:
6750
diff
changeset
|
890 elif listclean: |
5003
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
891 cadd(fn) |
6590
9f80e062d71c
status: rename type_ to state
Matt Mackall <mpm@selenic.com>
parents:
6589
diff
changeset
|
892 elif state == 'm': |
5003
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
893 madd(fn) |
6590
9f80e062d71c
status: rename type_ to state
Matt Mackall <mpm@selenic.com>
parents:
6589
diff
changeset
|
894 elif state == 'a': |
5003
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
895 aadd(fn) |
6590
9f80e062d71c
status: rename type_ to state
Matt Mackall <mpm@selenic.com>
parents:
6589
diff
changeset
|
896 elif state == 'r': |
5003
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
897 radd(fn) |
1183 | 898 |
22913
cb4449921a1d
status: create class for status lists
Martin von Zweigbergk <martinvonz@gmail.com>
parents:
22911
diff
changeset
|
899 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
|
900 unknown, ignored, clean)) |
21984
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
901 |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
902 def matches(self, match): |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
903 ''' |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
904 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
|
905 ''' |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
906 dmap = self._map |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
907 if match.always(): |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
908 return dmap.keys() |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
909 files = match.files() |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
910 if match.matchfn == match.exact: |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
911 # 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
|
912 # much smaller than dmap |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
913 return [f for f in files if f in dmap] |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
914 if not match.anypats() and util.all(fn in dmap for fn in files): |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
915 # 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
|
916 # that |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
917 return list(files) |
977a0b9af5ac
dirstate: add a method to efficiently filter by match
Siddharth Agarwal <sid0@fb.com>
parents:
21931
diff
changeset
|
918 return [f for f in dmap if match(f)] |