annotate mercurial/dirstate.py @ 1183:d9e85a75dbda

Optimize dirstate walking This generally cuts the time for hg status/diff in half, from 2s down to 1s. The main parts I'm trying to optimize are: 1) os.walk stats every file. dirstate.changes then stats every file again. 2) os.walk yields every file and subdir to dirstate.traverse who yields every file and everything in the dirstate map. dirstate.walk then filters this mass and yields every file to the caller. There should be fewer steps in here, and fewer duplicate strings yielded. 3) dirstate.walk runs util.unique on the results from dirstate.traverse, even though it is also passing things through dirstate.seen to look for duplicates. I've turned os.walk into something hg specific that takes all the dirstate ignore and matching rules into account. The new function also takes an function arg (statmatch()) the caller supplies to help filter out files it doesn't care about. dirstate.changes uses this to update state for each file, avoiding the second stat call. dirstate.walk is changed to turn the match function it is passed into a statmatch function. The only real difference is that a statmatch function takes the stat data as a second parameter. It now calls dirstate.walkhelper, who requires a statmatch function to be passed. This fails test-walk, but right now I think this is from a sorting error fixed by this patch. Index: crew/mercurial/dirstate.py ===================================================================
author mason@suse.com
date Thu, 01 Sep 2005 07:34:53 -0700
parents 30ab5b8ee8ec
children cc61d366bc3b
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
1089
142b5d5ec9cc Break apart hg.py
mpm@selenic.com
parents: 1072
diff changeset
1 """
142b5d5ec9cc Break apart hg.py
mpm@selenic.com
parents: 1072
diff changeset
2 dirstate.py - working directory tracking for mercurial
142b5d5ec9cc Break apart hg.py
mpm@selenic.com
parents: 1072
diff changeset
3
142b5d5ec9cc Break apart hg.py
mpm@selenic.com
parents: 1072
diff changeset
4 Copyright 2005 Matt Mackall <mpm@selenic.com>
142b5d5ec9cc Break apart hg.py
mpm@selenic.com
parents: 1072
diff changeset
5
142b5d5ec9cc Break apart hg.py
mpm@selenic.com
parents: 1072
diff changeset
6 This software may be used and distributed according to the terms
142b5d5ec9cc Break apart hg.py
mpm@selenic.com
parents: 1072
diff changeset
7 of the GNU General Public License, incorporated herein by reference.
142b5d5ec9cc Break apart hg.py
mpm@selenic.com
parents: 1072
diff changeset
8 """
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
9
1094
221b5252864c Adjust some imports
mpm@selenic.com
parents: 1089
diff changeset
10 import struct, os
221b5252864c Adjust some imports
mpm@selenic.com
parents: 1089
diff changeset
11 from node import *
262
3db700146536 implement demand loading hack
mpm@selenic.com
parents: 256
diff changeset
12 from demandload import *
1104
98988cc3723a Fix dirstate imports
mpm@selenic.com
parents: 1094
diff changeset
13 demandload(globals(), "time bisect stat util re")
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
14
220
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
15 class dirstate:
244
43105253cf5e root relative IO and valid commit states
mpm@selenic.com
parents: 241
diff changeset
16 def __init__(self, opener, ui, root):
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
17 self.opener = opener
244
43105253cf5e root relative IO and valid commit states
mpm@selenic.com
parents: 241
diff changeset
18 self.root = root
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
19 self.dirty = 0
20
a664c2b624cf The actual hg remove fix from Thomas Hein
mpm@selenic.com
parents: 19
diff changeset
20 self.ui = ui
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
21 self.map = None
227
f57519cddd3d move repo.current to dirstate.parents()
mpm@selenic.com
parents: 225
diff changeset
22 self.pl = None
363
ae96b7e1318d Add hg copy
mpm@selenic.com
parents: 360
diff changeset
23 self.copies = {}
723
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
24 self.ignorefunc = None
1183
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
25 self.blockignore = False
723
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
26
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
27 def wjoin(self, f):
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
28 return os.path.join(self.root, f)
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
29
870
a82eae840447 Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents: 839
diff changeset
30 def getcwd(self):
a82eae840447 Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents: 839
diff changeset
31 cwd = os.getcwd()
a82eae840447 Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents: 839
diff changeset
32 if cwd == self.root: return ''
a82eae840447 Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents: 839
diff changeset
33 return cwd[len(self.root) + 1:]
a82eae840447 Teach walk code about absolute paths.
Bryan O'Sullivan <bos@serpentine.com>
parents: 839
diff changeset
34
723
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
35 def ignore(self, f):
1183
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
36 if self.blockignore:
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
37 return False
723
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
38 if not self.ignorefunc:
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
39 bigpat = []
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
40 try:
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
41 l = file(self.wjoin(".hgignore"))
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
42 for pat in l:
911
d46af8e6b858 Fix .hgignore parsing if last line has no EOL, ignore trailing white space.
Thomas Arendsen Hein <thomas@intevation.de>
parents: 903
diff changeset
43 p = pat.rstrip()
d46af8e6b858 Fix .hgignore parsing if last line has no EOL, ignore trailing white space.
Thomas Arendsen Hein <thomas@intevation.de>
parents: 903
diff changeset
44 if p:
723
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
45 try:
886
509de8ab6f31 Fix walk path handling on Windows
Bryan O'Sullivan <bos@serpentine.com>
parents: 884
diff changeset
46 re.compile(p)
723
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
47 except:
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
48 self.ui.warn("ignoring invalid ignore"
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
49 + " regular expression '%s'\n" % p)
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
50 else:
886
509de8ab6f31 Fix walk path handling on Windows
Bryan O'Sullivan <bos@serpentine.com>
parents: 884
diff changeset
51 bigpat.append(p)
723
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
52 except IOError: pass
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
53
735
3433b228bbb3 An empty .hgignore file must cause us to ignore nothing, not everything!
Bryan O'Sullivan <bos@serpentine.com>
parents: 730
diff changeset
54 if bigpat:
3433b228bbb3 An empty .hgignore file must cause us to ignore nothing, not everything!
Bryan O'Sullivan <bos@serpentine.com>
parents: 730
diff changeset
55 s = "(?:%s)" % (")|(?:".join(bigpat))
3433b228bbb3 An empty .hgignore file must cause us to ignore nothing, not everything!
Bryan O'Sullivan <bos@serpentine.com>
parents: 730
diff changeset
56 r = re.compile(s)
3433b228bbb3 An empty .hgignore file must cause us to ignore nothing, not everything!
Bryan O'Sullivan <bos@serpentine.com>
parents: 730
diff changeset
57 self.ignorefunc = r.search
3433b228bbb3 An empty .hgignore file must cause us to ignore nothing, not everything!
Bryan O'Sullivan <bos@serpentine.com>
parents: 730
diff changeset
58 else:
3433b228bbb3 An empty .hgignore file must cause us to ignore nothing, not everything!
Bryan O'Sullivan <bos@serpentine.com>
parents: 730
diff changeset
59 self.ignorefunc = util.never
723
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
60
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
61 return self.ignorefunc(f)
220
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
62
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
63 def __del__(self):
220
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
64 if self.dirty:
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
65 self.write()
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
66
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
67 def __getitem__(self, key):
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
68 try:
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
69 return self.map[key]
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
70 except TypeError:
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
71 self.read()
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
72 return self[key]
220
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
73
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
74 def __contains__(self, key):
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
75 if not self.map: self.read()
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
76 return key in self.map
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
77
227
f57519cddd3d move repo.current to dirstate.parents()
mpm@selenic.com
parents: 225
diff changeset
78 def parents(self):
f57519cddd3d move repo.current to dirstate.parents()
mpm@selenic.com
parents: 225
diff changeset
79 if not self.pl:
f57519cddd3d move repo.current to dirstate.parents()
mpm@selenic.com
parents: 225
diff changeset
80 self.read()
f57519cddd3d move repo.current to dirstate.parents()
mpm@selenic.com
parents: 225
diff changeset
81 return self.pl
f57519cddd3d move repo.current to dirstate.parents()
mpm@selenic.com
parents: 225
diff changeset
82
723
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
83 def markdirty(self):
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
84 if not self.dirty:
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
85 self.dirty = 1
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
86
1062
6d5a62a549fa pep-0008 cleanup
benoit.boissinot@ens-lyon.fr
parents: 1040
diff changeset
87 def setparents(self, p1, p2=nullid):
723
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
88 self.markdirty()
227
f57519cddd3d move repo.current to dirstate.parents()
mpm@selenic.com
parents: 225
diff changeset
89 self.pl = p1, p2
f57519cddd3d move repo.current to dirstate.parents()
mpm@selenic.com
parents: 225
diff changeset
90
220
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
91 def state(self, key):
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
92 try:
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
93 return self[key][0]
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
94 except KeyError:
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
95 return "?"
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
96
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
97 def read(self):
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
98 if self.map is not None: return self.map
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
99
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
100 self.map = {}
227
f57519cddd3d move repo.current to dirstate.parents()
mpm@selenic.com
parents: 225
diff changeset
101 self.pl = [nullid, nullid]
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
102 try:
220
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
103 st = self.opener("dirstate").read()
311
3b17056b72dc fix KeyErrors from reading empty dirstate
mpm@selenic.com
parents: 308
diff changeset
104 if not st: return
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
105 except: return
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
106
227
f57519cddd3d move repo.current to dirstate.parents()
mpm@selenic.com
parents: 225
diff changeset
107 self.pl = [st[:20], st[20: 40]]
f57519cddd3d move repo.current to dirstate.parents()
mpm@selenic.com
parents: 225
diff changeset
108
f57519cddd3d move repo.current to dirstate.parents()
mpm@selenic.com
parents: 225
diff changeset
109 pos = 40
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
110 while pos < len(st):
220
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
111 e = struct.unpack(">cllll", st[pos:pos+17])
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
112 l = e[4]
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
113 pos += 17
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
114 f = st[pos:pos + l]
515
03f27b1381f9 Whitespace cleanups
mpm@selenic.com
parents: 514
diff changeset
115 if '\0' in f:
363
ae96b7e1318d Add hg copy
mpm@selenic.com
parents: 360
diff changeset
116 f, c = f.split('\0')
ae96b7e1318d Add hg copy
mpm@selenic.com
parents: 360
diff changeset
117 self.copies[f] = c
220
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
118 self.map[f] = e[:4]
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
119 pos += l
363
ae96b7e1318d Add hg copy
mpm@selenic.com
parents: 360
diff changeset
120
ae96b7e1318d Add hg copy
mpm@selenic.com
parents: 360
diff changeset
121 def copy(self, source, dest):
ae96b7e1318d Add hg copy
mpm@selenic.com
parents: 360
diff changeset
122 self.read()
723
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
123 self.markdirty()
363
ae96b7e1318d Add hg copy
mpm@selenic.com
parents: 360
diff changeset
124 self.copies[dest] = source
ae96b7e1318d Add hg copy
mpm@selenic.com
parents: 360
diff changeset
125
ae96b7e1318d Add hg copy
mpm@selenic.com
parents: 360
diff changeset
126 def copied(self, file):
ae96b7e1318d Add hg copy
mpm@selenic.com
parents: 360
diff changeset
127 return self.copies.get(file, None)
515
03f27b1381f9 Whitespace cleanups
mpm@selenic.com
parents: 514
diff changeset
128
862
d70c1c31fd45 Fix 3-way-merge of original parent, workdir and new parent.
Thomas Arendsen Hein <thomas@intevation.de>
parents: 861
diff changeset
129 def update(self, files, state, **kw):
220
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
130 ''' current states:
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
131 n normal
231
15e7c6cee929 add 'm' state to dirstates
mpm@selenic.com
parents: 230
diff changeset
132 m needs merging
220
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
133 r marked for removal
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
134 a marked for addition'''
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
135
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
136 if not files: return
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
137 self.read()
723
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
138 self.markdirty()
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
139 for f in files:
220
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
140 if state == "r":
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
141 self.map[f] = ('r', 0, 0, 0)
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
142 else:
253
2da0a56aa1fd Remove invalid state from dirstate
mpm@selenic.com
parents: 251
diff changeset
143 s = os.stat(os.path.join(self.root, f))
862
d70c1c31fd45 Fix 3-way-merge of original parent, workdir and new parent.
Thomas Arendsen Hein <thomas@intevation.de>
parents: 861
diff changeset
144 st_size = kw.get('st_size', s.st_size)
d70c1c31fd45 Fix 3-way-merge of original parent, workdir and new parent.
Thomas Arendsen Hein <thomas@intevation.de>
parents: 861
diff changeset
145 st_mtime = kw.get('st_mtime', s.st_mtime)
865
2d2fee33ec68 Cleanup after previous changes:
Thomas Arendsen Hein <thomas@intevation.de>
parents: 863
diff changeset
146 self.map[f] = (state, s.st_mode, st_size, st_mtime)
1117
30ab5b8ee8ec fix some rename/copy bugs
mpm@selenic.com
parents: 1104
diff changeset
147 if self.copies.has_key(f):
30ab5b8ee8ec fix some rename/copy bugs
mpm@selenic.com
parents: 1104
diff changeset
148 del self.copies[f]
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
149
220
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
150 def forget(self, files):
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
151 if not files: return
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
152 self.read()
723
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
153 self.markdirty()
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
154 for f in files:
20
a664c2b624cf The actual hg remove fix from Thomas Hein
mpm@selenic.com
parents: 19
diff changeset
155 try:
a664c2b624cf The actual hg remove fix from Thomas Hein
mpm@selenic.com
parents: 19
diff changeset
156 del self.map[f]
a664c2b624cf The actual hg remove fix from Thomas Hein
mpm@selenic.com
parents: 19
diff changeset
157 except KeyError:
220
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
158 self.ui.warn("not in dirstate: %s!\n" % f)
20
a664c2b624cf The actual hg remove fix from Thomas Hein
mpm@selenic.com
parents: 19
diff changeset
159 pass
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
160
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
161 def clear(self):
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
162 self.map = {}
723
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
163 self.markdirty()
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
164
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
165 def write(self):
220
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
166 st = self.opener("dirstate", "w")
227
f57519cddd3d move repo.current to dirstate.parents()
mpm@selenic.com
parents: 225
diff changeset
167 st.write("".join(self.pl))
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
168 for f, e in self.map.items():
363
ae96b7e1318d Add hg copy
mpm@selenic.com
parents: 360
diff changeset
169 c = self.copied(f)
ae96b7e1318d Add hg copy
mpm@selenic.com
parents: 360
diff changeset
170 if c:
ae96b7e1318d Add hg copy
mpm@selenic.com
parents: 360
diff changeset
171 f = f + "\0" + c
220
3113a94c1bff change dircache into dirstate
mpm@selenic.com
parents: 217
diff changeset
172 e = struct.pack(">cllll", e[0], e[1], e[2], e[3], len(f))
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
173 st.write(e + f)
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
174 self.dirty = 0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
175
879
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
176 def filterfiles(self, files):
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
177 ret = {}
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
178 unknown = []
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
179
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
180 for x in files:
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
181 if x is '.':
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
182 return self.map.copy()
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
183 if x not in self.map:
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
184 unknown.append(x)
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
185 else:
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
186 ret[x] = self.map[x]
919
1458d20df2a8 whitespace cleanup
mpm@selenic.com
parents: 911
diff changeset
187
879
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
188 if not unknown:
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
189 return ret
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
190
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
191 b = self.map.keys()
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
192 b.sort()
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
193 blen = len(b)
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
194
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
195 for x in unknown:
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
196 bs = bisect.bisect(b, x)
919
1458d20df2a8 whitespace cleanup
mpm@selenic.com
parents: 911
diff changeset
197 if bs != 0 and b[bs-1] == x:
879
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
198 ret[x] = self.map[x]
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
199 continue
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
200 while bs < blen:
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
201 s = b[bs]
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
202 if len(s) > len(x) and s.startswith(x) and s[len(x)] == '/':
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
203 ret[s] = self.map[s]
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
204 else:
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
205 break
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
206 bs += 1
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
207 return ret
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
208
1062
6d5a62a549fa pep-0008 cleanup
benoit.boissinot@ens-lyon.fr
parents: 1040
diff changeset
209 def walk(self, files=None, match=util.always, dc=None):
0
9117c6561b0b Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff changeset
210 self.read()
879
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
211
723
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
212 # walk all files by default
879
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
213 if not files:
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
214 files = [self.root]
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
215 if not dc:
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
216 dc = self.map.copy()
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
217 elif not dc:
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
218 dc = self.filterfiles(files)
919
1458d20df2a8 whitespace cleanup
mpm@selenic.com
parents: 911
diff changeset
219
1183
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
220 def statmatch(file, stat):
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
221 if file not in dc and self.ignore(file):
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
222 return False
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
223 return match(file)
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
224 return self.walkhelper(files=files, statmatch=statmatch, dc=dc)
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
225
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
226 # walk recursively through the directory tree, finding all files
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
227 # matched by the statmatch function
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
228 #
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
229 # results are yielded in a tuple (src, filename), where src is one of:
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
230 # 'f' the file was found in the directory tree
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
231 # 'm' the file was only in the dirstate and not in the tree
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
232 #
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
233 # dc is an optional arg for the current dirstate. dc is not modified
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
234 # directly by this function, but might be modified by your statmatch call.
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
235 #
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
236 def walkhelper(self, files, statmatch, dc):
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
237 # recursion free walker, faster than os.walk.
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
238 def findfiles(s):
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
239 retfiles = []
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
240 work = [s]
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
241 while work:
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
242 top = work.pop()
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
243 names = os.listdir(top)
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
244 names.sort()
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
245 # nd is the top of the repository dir tree
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
246 nd = util.normpath(top[len(self.root) + 1:])
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
247 if nd == '.': nd = ''
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
248 for f in names:
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
249 np = os.path.join(nd, f)
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
250 if seen(np):
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
251 continue
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
252 p = os.path.join(top, f)
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
253 st = os.stat(p)
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
254 if stat.S_ISDIR(st.st_mode):
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
255 ds = os.path.join(nd, f +'/')
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
256 if statmatch(ds, st):
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
257 work.append(p)
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
258 else:
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
259 if statmatch(np, st):
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
260 yield np
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
261
821
72d9bd4841f3 Ensure that dirstate.walk only yields names once.
Bryan O'Sullivan <bos@serpentine.com>
parents: 820
diff changeset
262 known = {'.hg': 1}
72d9bd4841f3 Ensure that dirstate.walk only yields names once.
Bryan O'Sullivan <bos@serpentine.com>
parents: 820
diff changeset
263 def seen(fn):
72d9bd4841f3 Ensure that dirstate.walk only yields names once.
Bryan O'Sullivan <bos@serpentine.com>
parents: 820
diff changeset
264 if fn in known: return True
72d9bd4841f3 Ensure that dirstate.walk only yields names once.
Bryan O'Sullivan <bos@serpentine.com>
parents: 820
diff changeset
265 known[fn] = 1
1183
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
266
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
267 # step one, find all files that match our criteria
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
268 files.sort()
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
269 for ff in util.unique(files):
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
270 f = os.path.join(self.root, ff)
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
271 try:
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
272 st = os.stat(f)
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
273 except OSError, inst:
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
274 if ff not in dc: self.ui.warn('%s: %s\n' % (
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
275 util.pathto(self.getcwd(), ff),
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
276 inst.strerror))
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
277 continue
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
278 if stat.S_ISDIR(st.st_mode):
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
279 sorted = [ x for x in findfiles(f) ]
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
280 sorted.sort()
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
281 for fl in sorted:
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
282 yield 'f', fl
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
283 elif stat.S_ISREG(st.st_mode):
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
284 ff = util.normpath(ff)
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
285 if seen(ff):
884
087771ebe2e6 Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents: 883
diff changeset
286 continue
1183
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
287 found = False
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
288 self.blockignore = True
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
289 if statmatch(ff, st):
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
290 found = True
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
291 self.blockignore = False
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
292 if found:
884
087771ebe2e6 Fix walk code for files that do not exist anywhere, and unhandled types.
Bryan O'Sullivan <bos@serpentine.com>
parents: 883
diff changeset
293 yield 'f', ff
1183
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
294 else:
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
295 kind = 'unknown'
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
296 if stat.S_ISCHR(st.st_mode): kind = 'character device'
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
297 elif stat.S_ISBLK(st.st_mode): kind = 'block device'
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
298 elif stat.S_ISFIFO(st.st_mode): kind = 'fifo'
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
299 elif stat.S_ISLNK(st.st_mode): kind = 'symbolic link'
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
300 elif stat.S_ISSOCK(st.st_mode): kind = 'socket'
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
301 self.ui.warn('%s: unsupported file type (type is %s)\n' % (
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
302 util.pathto(self.getcwd(), ff),
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
303 kind))
536
c15b4bc0a11c Refactor diffrevs/diffdir into changes
mpm@selenic.com
parents: 529
diff changeset
304
1183
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
305 # step two run through anything left in the dc hash and yield
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
306 # if we haven't already seen it
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
307 ks = dc.keys()
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
308 ks.sort()
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
309 for k in ks:
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
310 if not seen(k) and (statmatch(k, None)):
726
809a870a0e73 Add a source designator to the walk methods.
Bryan O'Sullivan <bos@serpentine.com>
parents: 725
diff changeset
311 yield 'm', k
669
8aa2a282eda4 .hgignore speedups patch incorporating Matt's feedback.
mwilli2@localhost.localdomain
parents: 667
diff changeset
312
861
cbe5c4d016b7 dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents: 856
diff changeset
313 def changes(self, files=None, match=util.always):
723
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
314 self.read()
879
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
315 if not files:
1183
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
316 files = [self.root]
879
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
317 dc = self.map.copy()
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
318 else:
953ccddd57bd dirstate walking optimizations
mason@suse.com
parents: 871
diff changeset
319 dc = self.filterfiles(files)
861
cbe5c4d016b7 dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents: 856
diff changeset
320 lookup, modified, added, unknown = [], [], [], []
cbe5c4d016b7 dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents: 856
diff changeset
321 removed, deleted = [], []
723
9e0f3ba4a9c2 Work on walk code.
Bryan O'Sullivan <bos@serpentine.com>
parents: 705
diff changeset
322
1183
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
323 # statmatch function to eliminate entries from the dirstate copy
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
324 # and put files into the appropriate array. This gets passed
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
325 # to the walking code
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
326 def statmatch(fn, s):
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
327 def checkappend(l, fn):
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
328 if match is util.always or match(fn):
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
329 l.append(fn)
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
330
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
331 if not s or stat.S_ISDIR(s.st_mode):
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
332 return self.ignore(fn) and False or match(fn)
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
333
861
cbe5c4d016b7 dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents: 856
diff changeset
334 if not stat.S_ISREG(s.st_mode):
1183
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
335 return False
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
336 c = dc.pop(fn, None)
861
cbe5c4d016b7 dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents: 856
diff changeset
337 if c:
1183
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
338 type, mode, size, time = c
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
339 # check the common case first
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
340 if type == 'n':
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
341 if size != s.st_size or (mode ^ s.st_mode) & 0100:
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
342 checkappend(modified, fn)
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
343 elif time != s.st_mtime:
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
344 checkappend(lookup, fn)
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
345 elif type == 'm':
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
346 checkappend(modified, fn)
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
347 elif type == 'a':
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
348 checkappend(added, fn)
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
349 elif type == 'r':
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
350 checkappend(unknown, fn)
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
351 else:
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
352 if not self.ignore(fn) and match(fn):
536
c15b4bc0a11c Refactor diffrevs/diffdir into changes
mpm@selenic.com
parents: 529
diff changeset
353 unknown.append(fn)
1183
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
354 # return false because we've already handled all cases above.
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
355 # there's no need for the walking code to process the file
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
356 # any further.
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
357 return False
536
c15b4bc0a11c Refactor diffrevs/diffdir into changes
mpm@selenic.com
parents: 529
diff changeset
358
1183
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
359 # because our statmatch always returns false, self.walk will only
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
360 # return files in the dirstate map that are not present in the FS.
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
361 # But, we still need to iterate through the results to force the
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
362 # walk to complete
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
363 for src, fn in self.walkhelper(files, statmatch, dc):
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
364 pass
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
365
d9e85a75dbda Optimize dirstate walking
mason@suse.com
parents: 1117
diff changeset
366 # anything left in dc didn't exist in the filesystem
861
cbe5c4d016b7 dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents: 856
diff changeset
367 for fn, c in [(fn, c) for fn, c in dc.items() if match(fn)]:
cbe5c4d016b7 dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents: 856
diff changeset
368 if c[0] == 'r':
cbe5c4d016b7 dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents: 856
diff changeset
369 removed.append(fn)
cbe5c4d016b7 dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents: 856
diff changeset
370 else:
cbe5c4d016b7 dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents: 856
diff changeset
371 deleted.append(fn)
cbe5c4d016b7 dirstate.changes() now distinguishes 'hg remove'd or just deleted files.
Thomas Arendsen Hein <thomas@intevation.de>
parents: 856
diff changeset
372 return (lookup, modified, added, removed + deleted, unknown)