annotate mercurial/dirstate.py @ 21984:977a0b9af5ac

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