Mercurial > hg > mercurial-crew-with-dirclash
annotate mercurial/dirstate.py @ 5369:7530334bf301
revlog: generate trivial deltas against null revision
To avoid extra memory usage and performance issues with large files,
generate a trivial delta header for deltas against the null revision
rather than calling the usual delta generator.
We append the delta header to meta rather than prepending it to data
to avoid a large allocate and copy.
author | Matt Mackall <mpm@selenic.com> |
---|---|
date | Wed, 03 Oct 2007 17:17:27 -0500 |
parents | f46ab9cacd3c |
children | 5105b119edd2 |
rev | line source |
---|---|
1089 | 1 """ |
2 dirstate.py - working directory tracking for mercurial | |
3 | |
4635
63b9d2deed48
Updated copyright notices and add "and others" to "hg version"
Thomas Arendsen Hein <thomas@intevation.de>
parents:
4633
diff
changeset
|
4 Copyright 2005-2007 Matt Mackall <mpm@selenic.com> |
1089 | 5 |
6 This software may be used and distributed according to the terms | |
7 of the GNU General Public License, incorporated herein by reference. | |
8 """ | |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
9 |
1094 | 10 from node import * |
3893 | 11 from i18n import _ |
4610
b43f17691ae6
dirstate: move ignore to its own file
Matt Mackall <mpm@selenic.com>
parents:
4609
diff
changeset
|
12 import struct, os, time, bisect, stat, strutil, util, re, errno, ignore |
4372
9edc2d6f7c10
dirstate: speed up write by 50%.
Bryan O'Sullivan <bos@serpentine.com>
parents:
4371
diff
changeset
|
13 import cStringIO |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
14 |
4611 | 15 _unknown = ('?', 0, 0, 0) |
16 _format = ">cllll" | |
17 | |
1559
59b3639df0a9
Convert all classes to new-style classes by deriving them from object.
Eric Hopper <hopper@omnifarious.org>
parents:
1541
diff
changeset
|
18 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
|
19 |
244 | 20 def __init__(self, opener, ui, root): |
4615
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
21 self._opener = opener |
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
22 self._root = root |
4947
81078e177266
dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents:
4677
diff
changeset
|
23 self._dirty = False |
4965 | 24 self._dirtypl = False |
4615
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
25 self._ui = ui |
723 | 26 |
4604
0f6853c15606
dirstate: use getattr rather than lazyread
Matt Mackall <mpm@selenic.com>
parents:
4527
diff
changeset
|
27 def __getattr__(self, name): |
4615
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
28 if name == '_map': |
4616
9b00b73a5286
dirstate: hide some more internals
Matt Mackall <mpm@selenic.com>
parents:
4615
diff
changeset
|
29 self._read() |
4615
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
30 return self._map |
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
31 elif name == '_copymap': |
4616
9b00b73a5286
dirstate: hide some more internals
Matt Mackall <mpm@selenic.com>
parents:
4615
diff
changeset
|
32 self._read() |
4615
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
33 return self._copymap |
4605
c867c11426ad
dirstate: lazify copymap, _branch, and _pl
Matt Mackall <mpm@selenic.com>
parents:
4604
diff
changeset
|
34 elif name == '_branch': |
c867c11426ad
dirstate: lazify copymap, _branch, and _pl
Matt Mackall <mpm@selenic.com>
parents:
4604
diff
changeset
|
35 try: |
4633
ff7253a0d1da
Cleanup of whitespace, indentation and line continuation.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
4621
diff
changeset
|
36 self._branch = (self._opener("branch").read().strip() |
ff7253a0d1da
Cleanup of whitespace, indentation and line continuation.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
4621
diff
changeset
|
37 or "default") |
4605
c867c11426ad
dirstate: lazify copymap, _branch, and _pl
Matt Mackall <mpm@selenic.com>
parents:
4604
diff
changeset
|
38 except IOError: |
c867c11426ad
dirstate: lazify copymap, _branch, and _pl
Matt Mackall <mpm@selenic.com>
parents:
4604
diff
changeset
|
39 self._branch = "default" |
c867c11426ad
dirstate: lazify copymap, _branch, and _pl
Matt Mackall <mpm@selenic.com>
parents:
4604
diff
changeset
|
40 return self._branch |
4615
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
41 elif name == '_pl': |
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
42 self._pl = [nullid, nullid] |
4605
c867c11426ad
dirstate: lazify copymap, _branch, and _pl
Matt Mackall <mpm@selenic.com>
parents:
4604
diff
changeset
|
43 try: |
4615
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
44 st = self._opener("dirstate").read(40) |
4605
c867c11426ad
dirstate: lazify copymap, _branch, and _pl
Matt Mackall <mpm@selenic.com>
parents:
4604
diff
changeset
|
45 if len(st) == 40: |
4615
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
46 self._pl = st[:20], st[20:40] |
4605
c867c11426ad
dirstate: lazify copymap, _branch, and _pl
Matt Mackall <mpm@selenic.com>
parents:
4604
diff
changeset
|
47 except IOError, err: |
c867c11426ad
dirstate: lazify copymap, _branch, and _pl
Matt Mackall <mpm@selenic.com>
parents:
4604
diff
changeset
|
48 if err.errno != errno.ENOENT: raise |
4615
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
49 return self._pl |
4616
9b00b73a5286
dirstate: hide some more internals
Matt Mackall <mpm@selenic.com>
parents:
4615
diff
changeset
|
50 elif name == '_dirs': |
9b00b73a5286
dirstate: hide some more internals
Matt Mackall <mpm@selenic.com>
parents:
4615
diff
changeset
|
51 self._dirs = {} |
4615
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
52 for f in self._map: |
4616
9b00b73a5286
dirstate: hide some more internals
Matt Mackall <mpm@selenic.com>
parents:
4615
diff
changeset
|
53 self._incpath(f) |
9b00b73a5286
dirstate: hide some more internals
Matt Mackall <mpm@selenic.com>
parents:
4615
diff
changeset
|
54 return self._dirs |
4610
b43f17691ae6
dirstate: move ignore to its own file
Matt Mackall <mpm@selenic.com>
parents:
4609
diff
changeset
|
55 elif name == '_ignore': |
4949
fc61495ea9cf
dirstate: make wjoin function private
Matt Mackall <mpm@selenic.com>
parents:
4948
diff
changeset
|
56 files = [self._join('.hgignore')] |
4621
d97fd22a0ea9
dirstate: pull ignore smarts out of ui
Matt Mackall <mpm@selenic.com>
parents:
4617
diff
changeset
|
57 for name, path in self._ui.configitems("ui"): |
d97fd22a0ea9
dirstate: pull ignore smarts out of ui
Matt Mackall <mpm@selenic.com>
parents:
4617
diff
changeset
|
58 if name == 'ignore' or name.startswith('ignore.'): |
d97fd22a0ea9
dirstate: pull ignore smarts out of ui
Matt Mackall <mpm@selenic.com>
parents:
4617
diff
changeset
|
59 files.append(os.path.expanduser(path)) |
4615
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
60 self._ignore = ignore.ignore(self._root, files, self._ui.warn) |
4610
b43f17691ae6
dirstate: move ignore to its own file
Matt Mackall <mpm@selenic.com>
parents:
4609
diff
changeset
|
61 return self._ignore |
4612
86e5500a517e
dirstate: lazify and lambdafy _slash
Matt Mackall <mpm@selenic.com>
parents:
4611
diff
changeset
|
62 elif name == '_slash': |
4615
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
63 self._slash = self._ui.configbool('ui', 'slash') and os.sep != '/' |
4612
86e5500a517e
dirstate: lazify and lambdafy _slash
Matt Mackall <mpm@selenic.com>
parents:
4611
diff
changeset
|
64 return self._slash |
4604
0f6853c15606
dirstate: use getattr rather than lazyread
Matt Mackall <mpm@selenic.com>
parents:
4527
diff
changeset
|
65 else: |
0f6853c15606
dirstate: use getattr rather than lazyread
Matt Mackall <mpm@selenic.com>
parents:
4527
diff
changeset
|
66 raise AttributeError, name |
0f6853c15606
dirstate: use getattr rather than lazyread
Matt Mackall <mpm@selenic.com>
parents:
4527
diff
changeset
|
67 |
4949
fc61495ea9cf
dirstate: make wjoin function private
Matt Mackall <mpm@selenic.com>
parents:
4948
diff
changeset
|
68 def _join(self, f): |
4615
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
69 return os.path.join(self._root, f) |
723 | 70 |
870
a82eae840447
Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents:
839
diff
changeset
|
71 def getcwd(self): |
a82eae840447
Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents:
839
diff
changeset
|
72 cwd = os.getcwd() |
4615
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
73 if cwd == self._root: return '' |
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
74 # self._root ends with a path separator if self._root is '/' or 'C:\' |
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
75 rootsep = self._root |
4230
c93562fb12cc
Fix handling of paths when run outside the repo.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4229
diff
changeset
|
76 if not rootsep.endswith(os.sep): |
c93562fb12cc
Fix handling of paths when run outside the repo.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4229
diff
changeset
|
77 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
|
78 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
|
79 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
|
80 else: |
c93562fb12cc
Fix handling of paths when run outside the repo.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4229
diff
changeset
|
81 # 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
|
82 return cwd |
870
a82eae840447
Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents:
839
diff
changeset
|
83 |
4525
78b6add1f966
Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4507
diff
changeset
|
84 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
|
85 if cwd is None: |
78b6add1f966
Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4507
diff
changeset
|
86 cwd = self.getcwd() |
4615
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
87 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
|
88 if self._slash: |
4612
86e5500a517e
dirstate: lazify and lambdafy _slash
Matt Mackall <mpm@selenic.com>
parents:
4611
diff
changeset
|
89 return path.replace(os.sep, '/') |
4527
b422b558015b
Add ui.slash hgrc setting
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4525
diff
changeset
|
90 return path |
4525
78b6add1f966
Add dirstate.pathto and localrepo.pathto.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4507
diff
changeset
|
91 |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
92 def __getitem__(self, key): |
4950
30847b8af7ca
dirstate: add __contains__ and make __getitem__ more useful
Matt Mackall <mpm@selenic.com>
parents:
4949
diff
changeset
|
93 ''' current states: |
30847b8af7ca
dirstate: add __contains__ and make __getitem__ more useful
Matt Mackall <mpm@selenic.com>
parents:
4949
diff
changeset
|
94 n normal |
30847b8af7ca
dirstate: add __contains__ and make __getitem__ more useful
Matt Mackall <mpm@selenic.com>
parents:
4949
diff
changeset
|
95 m needs merging |
30847b8af7ca
dirstate: add __contains__ and make __getitem__ more useful
Matt Mackall <mpm@selenic.com>
parents:
4949
diff
changeset
|
96 r marked for removal |
30847b8af7ca
dirstate: add __contains__ and make __getitem__ more useful
Matt Mackall <mpm@selenic.com>
parents:
4949
diff
changeset
|
97 a marked for addition |
30847b8af7ca
dirstate: add __contains__ and make __getitem__ more useful
Matt Mackall <mpm@selenic.com>
parents:
4949
diff
changeset
|
98 ? not tracked''' |
30847b8af7ca
dirstate: add __contains__ and make __getitem__ more useful
Matt Mackall <mpm@selenic.com>
parents:
4949
diff
changeset
|
99 return self._map.get(key, ("?",))[0] |
220 | 100 |
101 def __contains__(self, key): | |
4615
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
102 return key in self._map |
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
103 |
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
104 def __iter__(self): |
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
105 a = self._map.keys() |
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
106 a.sort() |
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
107 for x in a: |
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
108 yield x |
220 | 109 |
227 | 110 def parents(self): |
4615
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
111 return self._pl |
227 | 112 |
4207
7e1c8a565a4f
Move branch read/write to dirstate where it belongs
Matt Mackall <mpm@selenic.com>
parents:
4173
diff
changeset
|
113 def branch(self): |
7e1c8a565a4f
Move branch read/write to dirstate where it belongs
Matt Mackall <mpm@selenic.com>
parents:
4173
diff
changeset
|
114 return self._branch |
7e1c8a565a4f
Move branch read/write to dirstate where it belongs
Matt Mackall <mpm@selenic.com>
parents:
4173
diff
changeset
|
115 |
1062 | 116 def setparents(self, p1, p2=nullid): |
4965 | 117 self._dirty = self._dirtypl = True |
4615
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
118 self._pl = p1, p2 |
227 | 119 |
4207
7e1c8a565a4f
Move branch read/write to dirstate where it belongs
Matt Mackall <mpm@selenic.com>
parents:
4173
diff
changeset
|
120 def setbranch(self, branch): |
7e1c8a565a4f
Move branch read/write to dirstate where it belongs
Matt Mackall <mpm@selenic.com>
parents:
4173
diff
changeset
|
121 self._branch = branch |
4615
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
122 self._opener("branch", "w").write(branch + '\n') |
4207
7e1c8a565a4f
Move branch read/write to dirstate where it belongs
Matt Mackall <mpm@selenic.com>
parents:
4173
diff
changeset
|
123 |
4616
9b00b73a5286
dirstate: hide some more internals
Matt Mackall <mpm@selenic.com>
parents:
4615
diff
changeset
|
124 def _read(self): |
4615
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
125 self._map = {} |
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
126 self._copymap = {} |
4934
a11921d24ec4
add dirstate._dirtypl variable
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4677
diff
changeset
|
127 if not self._dirtypl: |
a11921d24ec4
add dirstate._dirtypl variable
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4677
diff
changeset
|
128 self._pl = [nullid, nullid] |
4608
49dcac6ede26
dirstate: fold parse into read
Matt Mackall <mpm@selenic.com>
parents:
4607
diff
changeset
|
129 try: |
4615
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
130 st = self._opener("dirstate").read() |
4608
49dcac6ede26
dirstate: fold parse into read
Matt Mackall <mpm@selenic.com>
parents:
4607
diff
changeset
|
131 except IOError, err: |
49dcac6ede26
dirstate: fold parse into read
Matt Mackall <mpm@selenic.com>
parents:
4607
diff
changeset
|
132 if err.errno != errno.ENOENT: raise |
49dcac6ede26
dirstate: fold parse into read
Matt Mackall <mpm@selenic.com>
parents:
4607
diff
changeset
|
133 return |
49dcac6ede26
dirstate: fold parse into read
Matt Mackall <mpm@selenic.com>
parents:
4607
diff
changeset
|
134 if not st: |
49dcac6ede26
dirstate: fold parse into read
Matt Mackall <mpm@selenic.com>
parents:
4607
diff
changeset
|
135 return |
49dcac6ede26
dirstate: fold parse into read
Matt Mackall <mpm@selenic.com>
parents:
4607
diff
changeset
|
136 |
4934
a11921d24ec4
add dirstate._dirtypl variable
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4677
diff
changeset
|
137 if not self._dirtypl: |
a11921d24ec4
add dirstate._dirtypl variable
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4677
diff
changeset
|
138 self._pl = [st[:20], st[20: 40]] |
227 | 139 |
2427
150cde10ea21
dirstate.read: make 15% faster.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2425
diff
changeset
|
140 # deref fields so they will be local in loop |
4615
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
141 dmap = self._map |
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
142 copymap = self._copymap |
2427
150cde10ea21
dirstate.read: make 15% faster.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2425
diff
changeset
|
143 unpack = struct.unpack |
4611 | 144 e_size = struct.calcsize(_format) |
5327
f46ab9cacd3c
dirstate: speed up read and write
Matt Mackall <mpm@selenic.com>
parents:
5326
diff
changeset
|
145 pos1 = 40 |
f46ab9cacd3c
dirstate: speed up read and write
Matt Mackall <mpm@selenic.com>
parents:
5326
diff
changeset
|
146 l = len(st) |
2427
150cde10ea21
dirstate.read: make 15% faster.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2425
diff
changeset
|
147 |
5327
f46ab9cacd3c
dirstate: speed up read and write
Matt Mackall <mpm@selenic.com>
parents:
5326
diff
changeset
|
148 # the inner loop |
f46ab9cacd3c
dirstate: speed up read and write
Matt Mackall <mpm@selenic.com>
parents:
5326
diff
changeset
|
149 while pos1 < l: |
f46ab9cacd3c
dirstate: speed up read and write
Matt Mackall <mpm@selenic.com>
parents:
5326
diff
changeset
|
150 pos2 = pos1 + e_size |
f46ab9cacd3c
dirstate: speed up read and write
Matt Mackall <mpm@selenic.com>
parents:
5326
diff
changeset
|
151 e = unpack(">cllll", st[pos1:pos2]) # a literal here is faster |
f46ab9cacd3c
dirstate: speed up read and write
Matt Mackall <mpm@selenic.com>
parents:
5326
diff
changeset
|
152 pos1 = pos2 + e[4] |
f46ab9cacd3c
dirstate: speed up read and write
Matt Mackall <mpm@selenic.com>
parents:
5326
diff
changeset
|
153 f = st[pos2:pos1] |
515 | 154 if '\0' in f: |
363 | 155 f, c = f.split('\0') |
3156
b1f10d3223c1
dirstate: add copies function
Matt Mackall <mpm@selenic.com>
parents:
2962
diff
changeset
|
156 copymap[f] = c |
5327
f46ab9cacd3c
dirstate: speed up read and write
Matt Mackall <mpm@selenic.com>
parents:
5326
diff
changeset
|
157 dmap[f] = e # we hold onto e[4] because making a subtuple is slow |
363 | 158 |
4614
3a645af7fb76
localrepo and dirstate: rename reload to invalidate
Matt Mackall <mpm@selenic.com>
parents:
4613
diff
changeset
|
159 def invalidate(self): |
4656
4eeb91870d3b
dirstate: fix typo
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4635
diff
changeset
|
160 for a in "_map _copymap _branch _pl _dirs _ignore".split(): |
4935
6b3ed43f77ba
dirstate.invalidate: avoid rebuilding _map
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4934
diff
changeset
|
161 if a in self.__dict__: |
6b3ed43f77ba
dirstate.invalidate: avoid rebuilding _map
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4934
diff
changeset
|
162 delattr(self, a) |
4947
81078e177266
dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents:
4677
diff
changeset
|
163 self._dirty = False |
4373
109077e7048d
When reloading the dirstate, recompute ignore information if needed.
Bryan O'Sullivan <bos@serpentine.com>
parents:
4372
diff
changeset
|
164 |
363 | 165 def copy(self, source, dest): |
4947
81078e177266
dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents:
4677
diff
changeset
|
166 self._dirty = True |
4615
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
167 self._copymap[dest] = source |
363 | 168 |
169 def copied(self, file): | |
4615
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
170 return self._copymap.get(file, None) |
3156
b1f10d3223c1
dirstate: add copies function
Matt Mackall <mpm@selenic.com>
parents:
2962
diff
changeset
|
171 |
b1f10d3223c1
dirstate: add copies function
Matt Mackall <mpm@selenic.com>
parents:
2962
diff
changeset
|
172 def copies(self): |
4615
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
173 return self._copymap |
515 | 174 |
4616
9b00b73a5286
dirstate: hide some more internals
Matt Mackall <mpm@selenic.com>
parents:
4615
diff
changeset
|
175 def _incpath(self, path): |
5326
319c09685f30
dirstate: make dir collision logic faster
Matt Mackall <mpm@selenic.com>
parents:
5210
diff
changeset
|
176 c = path.rfind('/') |
319c09685f30
dirstate: make dir collision logic faster
Matt Mackall <mpm@selenic.com>
parents:
5210
diff
changeset
|
177 if c >= 0: |
319c09685f30
dirstate: make dir collision logic faster
Matt Mackall <mpm@selenic.com>
parents:
5210
diff
changeset
|
178 dirs = self._dirs |
319c09685f30
dirstate: make dir collision logic faster
Matt Mackall <mpm@selenic.com>
parents:
5210
diff
changeset
|
179 base = path[:c] |
319c09685f30
dirstate: make dir collision logic faster
Matt Mackall <mpm@selenic.com>
parents:
5210
diff
changeset
|
180 if base not in dirs: |
319c09685f30
dirstate: make dir collision logic faster
Matt Mackall <mpm@selenic.com>
parents:
5210
diff
changeset
|
181 self._incpath(base) |
319c09685f30
dirstate: make dir collision logic faster
Matt Mackall <mpm@selenic.com>
parents:
5210
diff
changeset
|
182 dirs[base] = 1 |
319c09685f30
dirstate: make dir collision logic faster
Matt Mackall <mpm@selenic.com>
parents:
5210
diff
changeset
|
183 else: |
319c09685f30
dirstate: make dir collision logic faster
Matt Mackall <mpm@selenic.com>
parents:
5210
diff
changeset
|
184 dirs[base] += 1 |
4616
9b00b73a5286
dirstate: hide some more internals
Matt Mackall <mpm@selenic.com>
parents:
4615
diff
changeset
|
185 |
9b00b73a5286
dirstate: hide some more internals
Matt Mackall <mpm@selenic.com>
parents:
4615
diff
changeset
|
186 def _decpath(self, path): |
5326
319c09685f30
dirstate: make dir collision logic faster
Matt Mackall <mpm@selenic.com>
parents:
5210
diff
changeset
|
187 if "_dirs" in self.__dict__: |
319c09685f30
dirstate: make dir collision logic faster
Matt Mackall <mpm@selenic.com>
parents:
5210
diff
changeset
|
188 c = path.rfind('/') |
319c09685f30
dirstate: make dir collision logic faster
Matt Mackall <mpm@selenic.com>
parents:
5210
diff
changeset
|
189 if c >= 0: |
319c09685f30
dirstate: make dir collision logic faster
Matt Mackall <mpm@selenic.com>
parents:
5210
diff
changeset
|
190 base = path[:c] |
319c09685f30
dirstate: make dir collision logic faster
Matt Mackall <mpm@selenic.com>
parents:
5210
diff
changeset
|
191 dirs = self._dirs |
319c09685f30
dirstate: make dir collision logic faster
Matt Mackall <mpm@selenic.com>
parents:
5210
diff
changeset
|
192 if dirs[base] == 1: |
319c09685f30
dirstate: make dir collision logic faster
Matt Mackall <mpm@selenic.com>
parents:
5210
diff
changeset
|
193 del dirs[base] |
319c09685f30
dirstate: make dir collision logic faster
Matt Mackall <mpm@selenic.com>
parents:
5210
diff
changeset
|
194 self._decpath(base) |
319c09685f30
dirstate: make dir collision logic faster
Matt Mackall <mpm@selenic.com>
parents:
5210
diff
changeset
|
195 else: |
319c09685f30
dirstate: make dir collision logic faster
Matt Mackall <mpm@selenic.com>
parents:
5210
diff
changeset
|
196 dirs[base] -= 1 |
2953 | 197 |
4617
70352337934e
dirstate: refactor checkinterfering
Matt Mackall <mpm@selenic.com>
parents:
4616
diff
changeset
|
198 def _incpathcheck(self, f): |
70352337934e
dirstate: refactor checkinterfering
Matt Mackall <mpm@selenic.com>
parents:
4616
diff
changeset
|
199 if '\r' in f or '\n' in f: |
70352337934e
dirstate: refactor checkinterfering
Matt Mackall <mpm@selenic.com>
parents:
4616
diff
changeset
|
200 raise util.Abort(_("'\\n' and '\\r' disallowed in filenames")) |
70352337934e
dirstate: refactor checkinterfering
Matt Mackall <mpm@selenic.com>
parents:
4616
diff
changeset
|
201 # shadows |
70352337934e
dirstate: refactor checkinterfering
Matt Mackall <mpm@selenic.com>
parents:
4616
diff
changeset
|
202 if f in self._dirs: |
5043
8b1ee1f59b3c
dirstate: improve error message on file/directory clash
Bryan O'Sullivan <bos@serpentine.com>
parents:
5004
diff
changeset
|
203 raise util.Abort(_('directory %r already in dirstate') % f) |
4617
70352337934e
dirstate: refactor checkinterfering
Matt Mackall <mpm@selenic.com>
parents:
4616
diff
changeset
|
204 for c in strutil.rfindall(f, '/'): |
70352337934e
dirstate: refactor checkinterfering
Matt Mackall <mpm@selenic.com>
parents:
4616
diff
changeset
|
205 d = f[:c] |
70352337934e
dirstate: refactor checkinterfering
Matt Mackall <mpm@selenic.com>
parents:
4616
diff
changeset
|
206 if d in self._dirs: |
70352337934e
dirstate: refactor checkinterfering
Matt Mackall <mpm@selenic.com>
parents:
4616
diff
changeset
|
207 break |
70352337934e
dirstate: refactor checkinterfering
Matt Mackall <mpm@selenic.com>
parents:
4616
diff
changeset
|
208 if d in self._map: |
5043
8b1ee1f59b3c
dirstate: improve error message on file/directory clash
Bryan O'Sullivan <bos@serpentine.com>
parents:
5004
diff
changeset
|
209 raise util.Abort(_('file %r in dirstate clashes with %r') % |
8b1ee1f59b3c
dirstate: improve error message on file/directory clash
Bryan O'Sullivan <bos@serpentine.com>
parents:
5004
diff
changeset
|
210 (d, f)) |
4617
70352337934e
dirstate: refactor checkinterfering
Matt Mackall <mpm@selenic.com>
parents:
4616
diff
changeset
|
211 self._incpath(f) |
2953 | 212 |
4948
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4947
diff
changeset
|
213 def normal(self, f): |
5210
90d9ec0dc69d
merge: forcefully mark files that we get from the second parent as dirty
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5082
diff
changeset
|
214 'mark a file normal and clean' |
4948
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4947
diff
changeset
|
215 self._dirty = True |
4949
fc61495ea9cf
dirstate: make wjoin function private
Matt Mackall <mpm@selenic.com>
parents:
4948
diff
changeset
|
216 s = os.lstat(self._join(f)) |
5327
f46ab9cacd3c
dirstate: speed up read and write
Matt Mackall <mpm@selenic.com>
parents:
5326
diff
changeset
|
217 self._map[f] = ('n', s.st_mode, s.st_size, s.st_mtime, 0) |
4948
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4947
diff
changeset
|
218 if self._copymap.has_key(f): |
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4947
diff
changeset
|
219 del self._copymap[f] |
220 | 220 |
5210
90d9ec0dc69d
merge: forcefully mark files that we get from the second parent as dirty
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5082
diff
changeset
|
221 def normallookup(self, f): |
4948
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4947
diff
changeset
|
222 'mark a file normal, but possibly dirty' |
4947
81078e177266
dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents:
4677
diff
changeset
|
223 self._dirty = True |
5327
f46ab9cacd3c
dirstate: speed up read and write
Matt Mackall <mpm@selenic.com>
parents:
5326
diff
changeset
|
224 self._map[f] = ('n', 0, -1, -1, 0) |
5210
90d9ec0dc69d
merge: forcefully mark files that we get from the second parent as dirty
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5082
diff
changeset
|
225 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:
5082
diff
changeset
|
226 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:
5082
diff
changeset
|
227 |
90d9ec0dc69d
merge: forcefully mark files that we get from the second parent as dirty
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5082
diff
changeset
|
228 def normaldirty(self, f): |
90d9ec0dc69d
merge: forcefully mark files that we get from the second parent as dirty
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5082
diff
changeset
|
229 'mark a file normal, but dirty' |
90d9ec0dc69d
merge: forcefully mark files that we get from the second parent as dirty
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5082
diff
changeset
|
230 self._dirty = True |
5327
f46ab9cacd3c
dirstate: speed up read and write
Matt Mackall <mpm@selenic.com>
parents:
5326
diff
changeset
|
231 self._map[f] = ('n', 0, -2, -1, 0) |
4948
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4947
diff
changeset
|
232 if f in self._copymap: |
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4947
diff
changeset
|
233 del self._copymap[f] |
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4947
diff
changeset
|
234 |
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4947
diff
changeset
|
235 def add(self, f): |
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4947
diff
changeset
|
236 'mark a file added' |
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4947
diff
changeset
|
237 self._dirty = True |
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4947
diff
changeset
|
238 self._incpathcheck(f) |
5327
f46ab9cacd3c
dirstate: speed up read and write
Matt Mackall <mpm@selenic.com>
parents:
5326
diff
changeset
|
239 self._map[f] = ('a', 0, -1, -1, 0) |
4948
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4947
diff
changeset
|
240 if f in self._copymap: |
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4947
diff
changeset
|
241 del self._copymap[f] |
4617
70352337934e
dirstate: refactor checkinterfering
Matt Mackall <mpm@selenic.com>
parents:
4616
diff
changeset
|
242 |
4948
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4947
diff
changeset
|
243 def remove(self, f): |
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4947
diff
changeset
|
244 'mark a file removed' |
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4947
diff
changeset
|
245 self._dirty = True |
5327
f46ab9cacd3c
dirstate: speed up read and write
Matt Mackall <mpm@selenic.com>
parents:
5326
diff
changeset
|
246 self._map[f] = ('r', 0, 0, 0, 0) |
4948
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4947
diff
changeset
|
247 self._decpath(f) |
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4947
diff
changeset
|
248 if f in self._copymap: |
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4947
diff
changeset
|
249 del self._copymap[f] |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
250 |
4948
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4947
diff
changeset
|
251 def merge(self, f): |
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4947
diff
changeset
|
252 'mark a file merged' |
4947
81078e177266
dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents:
4677
diff
changeset
|
253 self._dirty = True |
4949
fc61495ea9cf
dirstate: make wjoin function private
Matt Mackall <mpm@selenic.com>
parents:
4948
diff
changeset
|
254 s = os.lstat(self._join(f)) |
5327
f46ab9cacd3c
dirstate: speed up read and write
Matt Mackall <mpm@selenic.com>
parents:
5326
diff
changeset
|
255 self._map[f] = ('m', s.st_mode, s.st_size, s.st_mtime, 0) |
4948
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4947
diff
changeset
|
256 if f in self._copymap: |
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4947
diff
changeset
|
257 del self._copymap[f] |
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4947
diff
changeset
|
258 |
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4947
diff
changeset
|
259 def forget(self, f): |
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4947
diff
changeset
|
260 'forget a file' |
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4947
diff
changeset
|
261 self._dirty = True |
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4947
diff
changeset
|
262 try: |
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4947
diff
changeset
|
263 del self._map[f] |
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4947
diff
changeset
|
264 self._decpath(f) |
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4947
diff
changeset
|
265 except KeyError: |
6fd953d5faea
dirstate: break update into separate functions
Matt Mackall <mpm@selenic.com>
parents:
4947
diff
changeset
|
266 self._ui.warn(_("not in dirstate: %s!\n") % f) |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
267 |
5080
b304c2496f52
dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4935
diff
changeset
|
268 def clear(self): |
b304c2496f52
dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4935
diff
changeset
|
269 self._map = {} |
b304c2496f52
dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4935
diff
changeset
|
270 self._copymap = {} |
b304c2496f52
dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4935
diff
changeset
|
271 self._pl = [nullid, nullid] |
5082 | 272 self._dirty = True |
5080
b304c2496f52
dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4935
diff
changeset
|
273 |
1755
a8f7791e3680
add 'debugrebuildstate' to rebuild the dirstate from a given revision
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1749
diff
changeset
|
274 def rebuild(self, parent, files): |
5080
b304c2496f52
dirstate: fix rebuild; add a test
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4935
diff
changeset
|
275 self.clear() |
2844
e196aa1df169
Start using manifestflags methods
Matt Mackall <mpm@selenic.com>
parents:
2486
diff
changeset
|
276 for f in files: |
e196aa1df169
Start using manifestflags methods
Matt Mackall <mpm@selenic.com>
parents:
2486
diff
changeset
|
277 if files.execf(f): |
5327
f46ab9cacd3c
dirstate: speed up read and write
Matt Mackall <mpm@selenic.com>
parents:
5326
diff
changeset
|
278 self._map[f] = ('n', 0777, -1, 0, 0) |
1755
a8f7791e3680
add 'debugrebuildstate' to rebuild the dirstate from a given revision
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1749
diff
changeset
|
279 else: |
5327
f46ab9cacd3c
dirstate: speed up read and write
Matt Mackall <mpm@selenic.com>
parents:
5326
diff
changeset
|
280 self._map[f] = ('n', 0666, -1, 0, 0) |
4615
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
281 self._pl = (parent, nullid) |
4947
81078e177266
dirstate: use True and false for _dirty
Matt Mackall <mpm@selenic.com>
parents:
4677
diff
changeset
|
282 self._dirty = True |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
283 |
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
284 def write(self): |
4613
17ee7407097f
dirstate: simplify dirty handling
Matt Mackall <mpm@selenic.com>
parents:
4612
diff
changeset
|
285 if not self._dirty: |
1794
98b6c1cad58b
only write the dirstate when something changed
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1755
diff
changeset
|
286 return |
4372
9edc2d6f7c10
dirstate: speed up write by 50%.
Bryan O'Sullivan <bos@serpentine.com>
parents:
4371
diff
changeset
|
287 cs = cStringIO.StringIO() |
5327
f46ab9cacd3c
dirstate: speed up read and write
Matt Mackall <mpm@selenic.com>
parents:
5326
diff
changeset
|
288 copymap = self._copymap |
f46ab9cacd3c
dirstate: speed up read and write
Matt Mackall <mpm@selenic.com>
parents:
5326
diff
changeset
|
289 pack = struct.pack |
f46ab9cacd3c
dirstate: speed up read and write
Matt Mackall <mpm@selenic.com>
parents:
5326
diff
changeset
|
290 write = cs.write |
f46ab9cacd3c
dirstate: speed up read and write
Matt Mackall <mpm@selenic.com>
parents:
5326
diff
changeset
|
291 write("".join(self._pl)) |
4615
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
292 for f, e in self._map.iteritems(): |
5327
f46ab9cacd3c
dirstate: speed up read and write
Matt Mackall <mpm@selenic.com>
parents:
5326
diff
changeset
|
293 if f in copymap: |
f46ab9cacd3c
dirstate: speed up read and write
Matt Mackall <mpm@selenic.com>
parents:
5326
diff
changeset
|
294 f = "%s\0%s" % (f, copymap[f]) |
f46ab9cacd3c
dirstate: speed up read and write
Matt Mackall <mpm@selenic.com>
parents:
5326
diff
changeset
|
295 e = pack(_format, e[0], e[1], e[2], e[3], len(f)) |
f46ab9cacd3c
dirstate: speed up read and write
Matt Mackall <mpm@selenic.com>
parents:
5326
diff
changeset
|
296 write(e) |
f46ab9cacd3c
dirstate: speed up read and write
Matt Mackall <mpm@selenic.com>
parents:
5326
diff
changeset
|
297 write(f) |
4615
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
298 st = self._opener("dirstate", "w", atomictemp=True) |
4372
9edc2d6f7c10
dirstate: speed up write by 50%.
Bryan O'Sullivan <bos@serpentine.com>
parents:
4371
diff
changeset
|
299 st.write(cs.getvalue()) |
4507
289ec1f36b11
Use atomictemp files to write the dirstate.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4445
diff
changeset
|
300 st.rename() |
4965 | 301 self._dirty = self._dirtypl = False |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
302 |
4951
6a7659a0c07c
dirstate: make filterfiles private
Matt Mackall <mpm@selenic.com>
parents:
4950
diff
changeset
|
303 def _filter(self, files): |
879 | 304 ret = {} |
305 unknown = [] | |
306 | |
307 for x in files: | |
1541
bf4e7ef08741
fixed some stuff pychecker shows, marked unclear/wrong stuff with XXX
twaldmann@thinkmo.de
parents:
1529
diff
changeset
|
308 if x == '.': |
4615
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
309 return self._map.copy() |
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
310 if x not in self._map: |
879 | 311 unknown.append(x) |
312 else: | |
4615
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
313 ret[x] = self._map[x] |
919 | 314 |
879 | 315 if not unknown: |
316 return ret | |
317 | |
4615
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
318 b = self._map.keys() |
879 | 319 b.sort() |
320 blen = len(b) | |
321 | |
322 for x in unknown: | |
2486
3ea8111ead90
simplify filterfiles when filtering based on a directory
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
2485
diff
changeset
|
323 bs = bisect.bisect(b, "%s%s" % (x, '/')) |
879 | 324 while bs < blen: |
325 s = b[bs] | |
2485
885de96eb542
filterfiles: Search as long as the target is a prefix of current.
Brendan Cully <brendan@kublai.com>
parents:
2470
diff
changeset
|
326 if len(s) > len(x) and s.startswith(x): |
4615
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
327 ret[s] = self._map[s] |
879 | 328 else: |
329 break | |
330 bs += 1 | |
331 return ret | |
332 | |
5002
62e3fd2baca4
revlog: pass mode to _supported directly
Matt Mackall <mpm@selenic.com>
parents:
5001
diff
changeset
|
333 def _supported(self, f, mode, verbose=False): |
62e3fd2baca4
revlog: pass mode to _supported directly
Matt Mackall <mpm@selenic.com>
parents:
5001
diff
changeset
|
334 if stat.S_ISREG(mode) or stat.S_ISLNK(mode): |
1487
2bc6cd62a29c
fix handling of files of unsupported type in the walk code
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1476
diff
changeset
|
335 return True |
2bc6cd62a29c
fix handling of files of unsupported type in the walk code
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1476
diff
changeset
|
336 if verbose: |
2bc6cd62a29c
fix handling of files of unsupported type in the walk code
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1476
diff
changeset
|
337 kind = 'unknown' |
5002
62e3fd2baca4
revlog: pass mode to _supported directly
Matt Mackall <mpm@selenic.com>
parents:
5001
diff
changeset
|
338 if stat.S_ISCHR(mode): kind = _('character device') |
62e3fd2baca4
revlog: pass mode to _supported directly
Matt Mackall <mpm@selenic.com>
parents:
5001
diff
changeset
|
339 elif stat.S_ISBLK(mode): kind = _('block device') |
62e3fd2baca4
revlog: pass mode to _supported directly
Matt Mackall <mpm@selenic.com>
parents:
5001
diff
changeset
|
340 elif stat.S_ISFIFO(mode): kind = _('fifo') |
62e3fd2baca4
revlog: pass mode to _supported directly
Matt Mackall <mpm@selenic.com>
parents:
5001
diff
changeset
|
341 elif stat.S_ISSOCK(mode): kind = _('socket') |
62e3fd2baca4
revlog: pass mode to _supported directly
Matt Mackall <mpm@selenic.com>
parents:
5001
diff
changeset
|
342 elif stat.S_ISDIR(mode): kind = _('directory') |
4615
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
343 self._ui.warn(_('%s: unsupported file type (type is %s)\n') |
4633
ff7253a0d1da
Cleanup of whitespace, indentation and line continuation.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
4621
diff
changeset
|
344 % (self.pathto(f), kind)) |
1487
2bc6cd62a29c
fix handling of files of unsupported type in the walk code
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1476
diff
changeset
|
345 return False |
2bc6cd62a29c
fix handling of files of unsupported type in the walk code
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1476
diff
changeset
|
346 |
3560 | 347 def walk(self, files=None, match=util.always, badmatch=None): |
348 # filter out the stat | |
349 for src, f, st in self.statwalk(files, match, badmatch=badmatch): | |
350 yield src, f | |
351 | |
352 def statwalk(self, files=None, match=util.always, ignored=False, | |
4146
e287d61dd268
Yield directories in dirstate.statwalk()
Emanuele Aina <faina.mail@tiscali.it>
parents:
4081
diff
changeset
|
353 badmatch=None, directories=False): |
3560 | 354 ''' |
355 walk recursively through the directory tree, finding all files | |
356 matched by the match function | |
357 | |
358 results are yielded in a tuple (src, filename, st), where src | |
359 is one of: | |
360 'f' the file was found in the directory tree | |
4146
e287d61dd268
Yield directories in dirstate.statwalk()
Emanuele Aina <faina.mail@tiscali.it>
parents:
4081
diff
changeset
|
361 'd' the file is a directory of the tree |
3560 | 362 'm' the file was only in the dirstate and not in the tree |
3563 | 363 'b' file was not found and matched badmatch |
364 | |
3560 | 365 and st is the stat result if the file was found in the directory. |
366 ''' | |
879 | 367 |
723 | 368 # walk all files by default |
879 | 369 if not files: |
4173
b36bd7534c08
statwalk: don't put self.root in the files list
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4075
diff
changeset
|
370 files = ['.'] |
4615
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
371 dc = self._map.copy() |
3560 | 372 else: |
3567
ece5c53577eb
small refactoring of path normalization in dirstate.statwalk
Matt Mackall <mpm@selenic.com>
parents:
3565
diff
changeset
|
373 files = util.unique(files) |
4951
6a7659a0c07c
dirstate: make filterfiles private
Matt Mackall <mpm@selenic.com>
parents:
4950
diff
changeset
|
374 dc = self._filter(files) |
919 | 375 |
3560 | 376 def imatch(file_): |
4610
b43f17691ae6
dirstate: move ignore to its own file
Matt Mackall <mpm@selenic.com>
parents:
4609
diff
changeset
|
377 if file_ not in dc and self._ignore(file_): |
1183 | 378 return False |
1749
d457fec76ab0
fix warnings from pychecker (unused variables and shadowing)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1617
diff
changeset
|
379 return match(file_) |
1224
cc61d366bc3b
Fix Windows status problem from new dirstate walk code
mpm@selenic.com
parents:
1183
diff
changeset
|
380 |
4610
b43f17691ae6
dirstate: move ignore to its own file
Matt Mackall <mpm@selenic.com>
parents:
4609
diff
changeset
|
381 ignore = self._ignore |
4188
dd0d9bd91e0a
dirstate.statwalk: explicitly test for ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4173
diff
changeset
|
382 if ignored: |
dd0d9bd91e0a
dirstate.statwalk: explicitly test for ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4173
diff
changeset
|
383 imatch = match |
dd0d9bd91e0a
dirstate.statwalk: explicitly test for ignored directories
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4173
diff
changeset
|
384 ignore = util.never |
3565
549cb7b640fb
Simplify ignore logic in dirstate.walk
Matt Mackall <mpm@selenic.com>
parents:
3563
diff
changeset
|
385 |
4615
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
386 # self._root may end with a path separator when self._root == '/' |
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
387 common_prefix_len = len(self._root) |
a8be3c875988
dirstate: hide internal vars
Matt Mackall <mpm@selenic.com>
parents:
4614
diff
changeset
|
388 if not self._root.endswith(os.sep): |
2671
82864a2eb709
self.root == '/': prefix length computation out of the loop
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
2670
diff
changeset
|
389 common_prefix_len += 1 |
5001
46facb73ba8b
dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents:
4965
diff
changeset
|
390 |
46facb73ba8b
dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents:
4965
diff
changeset
|
391 normpath = util.normpath |
46facb73ba8b
dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents:
4965
diff
changeset
|
392 listdir = os.listdir |
46facb73ba8b
dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents:
4965
diff
changeset
|
393 lstat = os.lstat |
46facb73ba8b
dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents:
4965
diff
changeset
|
394 bisect_left = bisect.bisect_left |
46facb73ba8b
dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents:
4965
diff
changeset
|
395 isdir = os.path.isdir |
46facb73ba8b
dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents:
4965
diff
changeset
|
396 pconvert = util.pconvert |
46facb73ba8b
dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents:
4965
diff
changeset
|
397 join = os.path.join |
46facb73ba8b
dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents:
4965
diff
changeset
|
398 s_isdir = stat.S_ISDIR |
46facb73ba8b
dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents:
4965
diff
changeset
|
399 supported = self._supported |
5002
62e3fd2baca4
revlog: pass mode to _supported directly
Matt Mackall <mpm@selenic.com>
parents:
5001
diff
changeset
|
400 _join = self._join |
62e3fd2baca4
revlog: pass mode to _supported directly
Matt Mackall <mpm@selenic.com>
parents:
5001
diff
changeset
|
401 known = {'.hg': 1} |
5001
46facb73ba8b
dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents:
4965
diff
changeset
|
402 |
1183 | 403 # recursion free walker, faster than os.walk. |
404 def findfiles(s): | |
405 work = [s] | |
5003
4d079df2871a
dirstate: speed up sorting in findfiles
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
406 wadd = work.append |
4d079df2871a
dirstate: speed up sorting in findfiles
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
407 found = [] |
4d079df2871a
dirstate: speed up sorting in findfiles
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
408 add = found.append |
4146
e287d61dd268
Yield directories in dirstate.statwalk()
Emanuele Aina <faina.mail@tiscali.it>
parents:
4081
diff
changeset
|
409 if directories: |
5003
4d079df2871a
dirstate: speed up sorting in findfiles
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
410 add((normpath(s[common_prefix_len:]), 'd', lstat(s))) |
1183 | 411 while work: |
412 top = work.pop() | |
5001
46facb73ba8b
dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents:
4965
diff
changeset
|
413 names = listdir(top) |
1183 | 414 names.sort() |
415 # nd is the top of the repository dir tree | |
5001
46facb73ba8b
dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents:
4965
diff
changeset
|
416 nd = normpath(top[common_prefix_len:]) |
2061
5987c1eac2ce
support nested repositories.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2022
diff
changeset
|
417 if nd == '.': |
5987c1eac2ce
support nested repositories.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2022
diff
changeset
|
418 nd = '' |
5987c1eac2ce
support nested repositories.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2022
diff
changeset
|
419 else: |
2063
f1fda71e134e
benoit asked for comment to make avoid of recursive repo clearer.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2062
diff
changeset
|
420 # do not recurse into a repo contained in this |
f1fda71e134e
benoit asked for comment to make avoid of recursive repo clearer.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2062
diff
changeset
|
421 # one. use bisect to find .hg directory so speed |
f1fda71e134e
benoit asked for comment to make avoid of recursive repo clearer.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2062
diff
changeset
|
422 # is good on big directory. |
5001
46facb73ba8b
dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents:
4965
diff
changeset
|
423 hg = bisect_left(names, '.hg') |
2061
5987c1eac2ce
support nested repositories.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2022
diff
changeset
|
424 if hg < len(names) and names[hg] == '.hg': |
5001
46facb73ba8b
dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents:
4965
diff
changeset
|
425 if isdir(join(top, '.hg')): |
2061
5987c1eac2ce
support nested repositories.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2022
diff
changeset
|
426 continue |
1183 | 427 for f in names: |
5002
62e3fd2baca4
revlog: pass mode to _supported directly
Matt Mackall <mpm@selenic.com>
parents:
5001
diff
changeset
|
428 np = pconvert(join(nd, f)) |
62e3fd2baca4
revlog: pass mode to _supported directly
Matt Mackall <mpm@selenic.com>
parents:
5001
diff
changeset
|
429 if np in known: |
1183 | 430 continue |
5002
62e3fd2baca4
revlog: pass mode to _supported directly
Matt Mackall <mpm@selenic.com>
parents:
5001
diff
changeset
|
431 known[np] = 1 |
5001
46facb73ba8b
dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents:
4965
diff
changeset
|
432 p = join(top, f) |
1228
db950da49539
Fix dangling symlink bug in dirstate walk code
mpm@selenic.com
parents:
1224
diff
changeset
|
433 # don't trip over symlinks |
5001
46facb73ba8b
dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents:
4965
diff
changeset
|
434 st = lstat(p) |
46facb73ba8b
dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents:
4965
diff
changeset
|
435 if s_isdir(st.st_mode): |
4254
a7cae4e22749
Pass normalized directory names to the ignore function
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4188
diff
changeset
|
436 if not ignore(np): |
5003
4d079df2871a
dirstate: speed up sorting in findfiles
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
437 wadd(p) |
4146
e287d61dd268
Yield directories in dirstate.statwalk()
Emanuele Aina <faina.mail@tiscali.it>
parents:
4081
diff
changeset
|
438 if directories: |
5003
4d079df2871a
dirstate: speed up sorting in findfiles
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
439 add((np, 'd', st)) |
5002
62e3fd2baca4
revlog: pass mode to _supported directly
Matt Mackall <mpm@selenic.com>
parents:
5001
diff
changeset
|
440 if np in dc and match(np): |
5003
4d079df2871a
dirstate: speed up sorting in findfiles
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
441 add((np, 'm', st)) |
3560 | 442 elif imatch(np): |
5002
62e3fd2baca4
revlog: pass mode to _supported directly
Matt Mackall <mpm@selenic.com>
parents:
5001
diff
changeset
|
443 if supported(np, st.st_mode): |
5003
4d079df2871a
dirstate: speed up sorting in findfiles
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
444 add((np, 'f', st)) |
1487
2bc6cd62a29c
fix handling of files of unsupported type in the walk code
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1476
diff
changeset
|
445 elif np in dc: |
5003
4d079df2871a
dirstate: speed up sorting in findfiles
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
446 add((np, 'm', st)) |
4d079df2871a
dirstate: speed up sorting in findfiles
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
447 found.sort() |
4d079df2871a
dirstate: speed up sorting in findfiles
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
448 return found |
1183 | 449 |
450 # step one, find all files that match our criteria | |
451 files.sort() | |
3567
ece5c53577eb
small refactoring of path normalization in dirstate.statwalk
Matt Mackall <mpm@selenic.com>
parents:
3565
diff
changeset
|
452 for ff in files: |
5001
46facb73ba8b
dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents:
4965
diff
changeset
|
453 nf = normpath(ff) |
5002
62e3fd2baca4
revlog: pass mode to _supported directly
Matt Mackall <mpm@selenic.com>
parents:
5001
diff
changeset
|
454 f = _join(ff) |
1183 | 455 try: |
5001
46facb73ba8b
dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents:
4965
diff
changeset
|
456 st = lstat(f) |
1183 | 457 except OSError, inst: |
1564
34579a67fa71
Re: [PATCH 2 of 3] remove walk warning about nonexistent files
Benoit Boissinot <bboissin@gmail.com>
parents:
1562
diff
changeset
|
458 found = False |
34579a67fa71
Re: [PATCH 2 of 3] remove walk warning about nonexistent files
Benoit Boissinot <bboissin@gmail.com>
parents:
1562
diff
changeset
|
459 for fn in dc: |
34579a67fa71
Re: [PATCH 2 of 3] remove walk warning about nonexistent files
Benoit Boissinot <bboissin@gmail.com>
parents:
1562
diff
changeset
|
460 if nf == fn or (fn.startswith(nf) and fn[len(nf)] == '/'): |
34579a67fa71
Re: [PATCH 2 of 3] remove walk warning about nonexistent files
Benoit Boissinot <bboissin@gmail.com>
parents:
1562
diff
changeset
|
461 found = True |
34579a67fa71
Re: [PATCH 2 of 3] remove walk warning about nonexistent files
Benoit Boissinot <bboissin@gmail.com>
parents:
1562
diff
changeset
|
462 break |
34579a67fa71
Re: [PATCH 2 of 3] remove walk warning about nonexistent files
Benoit Boissinot <bboissin@gmail.com>
parents:
1562
diff
changeset
|
463 if not found: |
2042
a514c7509fa9
small changes to revert command.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2022
diff
changeset
|
464 if inst.errno != errno.ENOENT or not badmatch: |
4633
ff7253a0d1da
Cleanup of whitespace, indentation and line continuation.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
4621
diff
changeset
|
465 self._ui.warn('%s: %s\n' % |
ff7253a0d1da
Cleanup of whitespace, indentation and line continuation.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
4621
diff
changeset
|
466 (self.pathto(ff), inst.strerror)) |
3565
549cb7b640fb
Simplify ignore logic in dirstate.walk
Matt Mackall <mpm@selenic.com>
parents:
3563
diff
changeset
|
467 elif badmatch and badmatch(ff) and imatch(nf): |
2042
a514c7509fa9
small changes to revert command.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2022
diff
changeset
|
468 yield 'b', ff, None |
1183 | 469 continue |
5001
46facb73ba8b
dirstate: localize a bunch of methods for findfiles
Matt Mackall <mpm@selenic.com>
parents:
4965
diff
changeset
|
470 if s_isdir(st.st_mode): |
5003
4d079df2871a
dirstate: speed up sorting in findfiles
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
471 for f, src, st in findfiles(f): |
4d079df2871a
dirstate: speed up sorting in findfiles
Matt Mackall <mpm@selenic.com>
parents:
5002
diff
changeset
|
472 yield src, f, st |
1392
32d8068b3e36
add a check for filetype when walking
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1276
diff
changeset
|
473 else: |
5002
62e3fd2baca4
revlog: pass mode to _supported directly
Matt Mackall <mpm@selenic.com>
parents:
5001
diff
changeset
|
474 if nf in known: |
62e3fd2baca4
revlog: pass mode to _supported directly
Matt Mackall <mpm@selenic.com>
parents:
5001
diff
changeset
|
475 continue |
62e3fd2baca4
revlog: pass mode to _supported directly
Matt Mackall <mpm@selenic.com>
parents:
5001
diff
changeset
|
476 known[nf] = 1 |
62e3fd2baca4
revlog: pass mode to _supported directly
Matt Mackall <mpm@selenic.com>
parents:
5001
diff
changeset
|
477 if match(nf): |
62e3fd2baca4
revlog: pass mode to _supported directly
Matt Mackall <mpm@selenic.com>
parents:
5001
diff
changeset
|
478 if supported(ff, st.st_mode, verbose=True): |
3567
ece5c53577eb
small refactoring of path normalization in dirstate.statwalk
Matt Mackall <mpm@selenic.com>
parents:
3565
diff
changeset
|
479 yield 'f', nf, st |
1487
2bc6cd62a29c
fix handling of files of unsupported type in the walk code
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1476
diff
changeset
|
480 elif ff in dc: |
3567
ece5c53577eb
small refactoring of path normalization in dirstate.statwalk
Matt Mackall <mpm@selenic.com>
parents:
3565
diff
changeset
|
481 yield 'm', nf, st |
536 | 482 |
1183 | 483 # step two run through anything left in the dc hash and yield |
484 # if we haven't already seen it | |
485 ks = dc.keys() | |
486 ks.sort() | |
487 for k in ks: | |
5002
62e3fd2baca4
revlog: pass mode to _supported directly
Matt Mackall <mpm@selenic.com>
parents:
5001
diff
changeset
|
488 if k in known: |
62e3fd2baca4
revlog: pass mode to _supported directly
Matt Mackall <mpm@selenic.com>
parents:
5001
diff
changeset
|
489 continue |
62e3fd2baca4
revlog: pass mode to _supported directly
Matt Mackall <mpm@selenic.com>
parents:
5001
diff
changeset
|
490 known[k] = 1 |
62e3fd2baca4
revlog: pass mode to _supported directly
Matt Mackall <mpm@selenic.com>
parents:
5001
diff
changeset
|
491 if imatch(k): |
1471
f56f38a1a85f
rewrote changes function in dirstate to use generic walk code
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1402
diff
changeset
|
492 yield 'm', k, None |
669
8aa2a282eda4
.hgignore speedups patch incorporating Matt's feedback.
mwilli2@localhost.localdomain
parents:
667
diff
changeset
|
493 |
4952
8c294ee7047e
dirstate: get rid of default args for status
Matt Mackall <mpm@selenic.com>
parents:
4951
diff
changeset
|
494 def status(self, files, match, list_ignored, list_clean): |
2022
a59da8cc35e4
New option -i/--ignored for 'hg status' to show ignored files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
2008
diff
changeset
|
495 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
|
496 removed, deleted, clean = [], [], [] |
723 | 497 |
5004
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5003
diff
changeset
|
498 _join = self._join |
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5003
diff
changeset
|
499 lstat = os.lstat |
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5003
diff
changeset
|
500 cmap = self._copymap |
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5003
diff
changeset
|
501 dmap = self._map |
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5003
diff
changeset
|
502 ladd = lookup.append |
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5003
diff
changeset
|
503 madd = modified.append |
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5003
diff
changeset
|
504 aadd = added.append |
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5003
diff
changeset
|
505 uadd = unknown.append |
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5003
diff
changeset
|
506 iadd = ignored.append |
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5003
diff
changeset
|
507 radd = removed.append |
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5003
diff
changeset
|
508 dadd = deleted.append |
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5003
diff
changeset
|
509 cadd = clean.append |
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5003
diff
changeset
|
510 |
2661
5c10b7ed3411
status: add -c (clean) and -A (all files) options
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2486
diff
changeset
|
511 for src, fn, st in self.statwalk(files, match, ignored=list_ignored): |
5004
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5003
diff
changeset
|
512 if fn in dmap: |
5327
f46ab9cacd3c
dirstate: speed up read and write
Matt Mackall <mpm@selenic.com>
parents:
5326
diff
changeset
|
513 type_, mode, size, time, foo = dmap[fn] |
5004
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5003
diff
changeset
|
514 else: |
4610
b43f17691ae6
dirstate: move ignore to its own file
Matt Mackall <mpm@selenic.com>
parents:
4609
diff
changeset
|
515 if list_ignored and self._ignore(fn): |
5004
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5003
diff
changeset
|
516 iadd(fn) |
2022
a59da8cc35e4
New option -i/--ignored for 'hg status' to show ignored files.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
2008
diff
changeset
|
517 else: |
5004
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5003
diff
changeset
|
518 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
|
519 continue |
1476
17e8c70fb670
fix dirstate.change: it should walk ignored files
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1471
diff
changeset
|
520 if src == 'm': |
1487
2bc6cd62a29c
fix handling of files of unsupported type in the walk code
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1476
diff
changeset
|
521 nonexistent = True |
2bc6cd62a29c
fix handling of files of unsupported type in the walk code
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1476
diff
changeset
|
522 if not st: |
2bc6cd62a29c
fix handling of files of unsupported type in the walk code
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1476
diff
changeset
|
523 try: |
5004
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5003
diff
changeset
|
524 st = lstat(_join(fn)) |
1487
2bc6cd62a29c
fix handling of files of unsupported type in the walk code
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1476
diff
changeset
|
525 except OSError, inst: |
2bc6cd62a29c
fix handling of files of unsupported type in the walk code
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1476
diff
changeset
|
526 if inst.errno != errno.ENOENT: |
2bc6cd62a29c
fix handling of files of unsupported type in the walk code
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1476
diff
changeset
|
527 raise |
2bc6cd62a29c
fix handling of files of unsupported type in the walk code
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1476
diff
changeset
|
528 st = None |
2bc6cd62a29c
fix handling of files of unsupported type in the walk code
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1476
diff
changeset
|
529 # We need to re-check that it is a valid file |
5002
62e3fd2baca4
revlog: pass mode to _supported directly
Matt Mackall <mpm@selenic.com>
parents:
5001
diff
changeset
|
530 if st and self._supported(fn, st.st_mode): |
1487
2bc6cd62a29c
fix handling of files of unsupported type in the walk code
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1476
diff
changeset
|
531 nonexistent = False |
1476
17e8c70fb670
fix dirstate.change: it should walk ignored files
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1471
diff
changeset
|
532 # XXX: what to do with file no longer present in the fs |
17e8c70fb670
fix dirstate.change: it should walk ignored files
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1471
diff
changeset
|
533 # who are not removed in the dirstate ? |
1749
d457fec76ab0
fix warnings from pychecker (unused variables and shadowing)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1617
diff
changeset
|
534 if nonexistent and type_ in "nm": |
5004
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5003
diff
changeset
|
535 dadd(fn) |
1476
17e8c70fb670
fix dirstate.change: it should walk ignored files
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1471
diff
changeset
|
536 continue |
1471
f56f38a1a85f
rewrote changes function in dirstate to use generic walk code
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1402
diff
changeset
|
537 # check the common case first |
1749
d457fec76ab0
fix warnings from pychecker (unused variables and shadowing)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1617
diff
changeset
|
538 if type_ == 'n': |
1471
f56f38a1a85f
rewrote changes function in dirstate to use generic walk code
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1402
diff
changeset
|
539 if not st: |
5004
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5003
diff
changeset
|
540 st = lstat(_join(fn)) |
4677
de8ec7e1753a
dirstate.status: if a file is marked as copied, consider it modified
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4657
diff
changeset
|
541 if (size >= 0 and (size != st.st_size |
de8ec7e1753a
dirstate.status: if a file is marked as copied, consider it modified
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4657
diff
changeset
|
542 or (mode ^ st.st_mode) & 0100) |
5210
90d9ec0dc69d
merge: forcefully mark files that we get from the second parent as dirty
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
5082
diff
changeset
|
543 or size == -2 |
4677
de8ec7e1753a
dirstate.status: if a file is marked as copied, consider it modified
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4657
diff
changeset
|
544 or fn in self._copymap): |
5004
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5003
diff
changeset
|
545 madd(fn) |
2962
882e703eaa94
dirstate.py: when comparing mtimes, use only the integer part.
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
2953
diff
changeset
|
546 elif time != int(st.st_mtime): |
5004
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5003
diff
changeset
|
547 ladd(fn) |
2661
5c10b7ed3411
status: add -c (clean) and -A (all files) options
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2486
diff
changeset
|
548 elif list_clean: |
5004
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5003
diff
changeset
|
549 cadd(fn) |
1749
d457fec76ab0
fix warnings from pychecker (unused variables and shadowing)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1617
diff
changeset
|
550 elif type_ == 'm': |
5004
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5003
diff
changeset
|
551 madd(fn) |
1749
d457fec76ab0
fix warnings from pychecker (unused variables and shadowing)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1617
diff
changeset
|
552 elif type_ == 'a': |
5004
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5003
diff
changeset
|
553 aadd(fn) |
1749
d457fec76ab0
fix warnings from pychecker (unused variables and shadowing)
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
1617
diff
changeset
|
554 elif type_ == 'r': |
5004
4b1acb3ecb3c
dirstate: localize a bunch of methods in status fastpath
Matt Mackall <mpm@selenic.com>
parents:
5003
diff
changeset
|
555 radd(fn) |
1183 | 556 |
2661
5c10b7ed3411
status: add -c (clean) and -A (all files) options
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2486
diff
changeset
|
557 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
|
558 clean) |