« back to all changes in this revision
Viewing changes to bzrlib/tree.py
- browse files at revision 331
- compare with another revision
- download diff
- download tarball
- view history from revision 331
- Committer: Martin Pool
- Date: 2005-05-03 07:48:54 UTC
- Revision ID: mbp@sourcefrog.net-20050503074854-adb6f9d6382e27a9
- sketchy experiments in bash and zsh completion
- files added:
- bzrlib/tests.py
- files removed:
- bzr-man.py
- bzrlib/selftest
- patches
- files renamed:
- contrib/bash/bzr.simple => contrib/bash/bzr
- files modified:
- .bzrignore
added
removed
bzrlib/tree.py
18
18
"""
19
19
20
20
from sets import Set
21
import os.path, os, fnmatch, time
21
import os.path, os, fnmatch
22
22
23
from osutils import pumpfile, filesize, quotefn, sha_file, \
23
from osutils import pumpfile, compare_files, filesize, quotefn, sha_file, \
24
24
joinpath, splitpath, appendpath, isdir, isfile, file_kind, fingerprint_file
25
25
import errno
26
26
from stat import S_ISREG, S_ISDIR, ST_MODE, ST_SIZE
27
27
28
from bzrlib.inventory import Inventory
29
from bzrlib.trace import mutter, note
30
from bzrlib.errors import BzrError
28
from inventory import Inventory
29
from trace import mutter, note
30
from errors import bailout
31
31
import branch
32
32
33
33
import bzrlib
34
34
35
exporters = {}
36
37
class Tree(object):
35
class Tree:
38
36
"""Abstract file tree.
39
37
40
38
There are several subclasses:
63
61
def has_id(self, file_id):
64
62
return self.inventory.has_id(file_id)
65
63
66
__contains__ = has_id
67
68
def __iter__(self):
69
return iter(self.inventory)
64
def id_set(self):
65
"""Return set of all ids in this tree."""
66
return self.inventory.id_set()
70
67
71
68
def id2path(self, file_id):
72
69
return self.inventory.id2path(file_id)
83
80
84
81
if ie.text_size != None:
85
82
if ie.text_size != fp['size']:
86
raise BzrError("mismatched size for file %r in %r" % (ie.file_id, self._store),
83
bailout("mismatched size for file %r in %r" % (ie.file_id, self._store),
87
84
["inventory expects %d bytes" % ie.text_size,
88
85
"file is actually %d bytes" % fp['size'],
89
86
"store is probably damaged/corrupt"])
90
87
91
88
if ie.text_sha1 != fp['sha1']:
92
raise BzrError("wrong SHA-1 for file %r in %r" % (ie.file_id, self._store),
89
bailout("wrong SHA-1 for file %r in %r" % (ie.file_id, self._store),
93
90
["inventory expects %s" % ie.text_sha1,
94
91
"file is actually %s" % fp['sha1'],
95
92
"store is probably damaged/corrupt"])
101
98
pumpfile(self.get_file(fileid), sys.stdout)
102
99
103
100
104
def export(self, dest, format='dir'):
105
"""Export this tree."""
106
try:
107
exporter = exporters[format]
108
except KeyError:
109
raise BzrCommandError("export format %r not supported" % format)
110
exporter(self, dest)
111
112
101
def export(self, dest):
102
"""Export this tree to a new directory.
103
104
`dest` should not exist, and will be created holding the
105
contents of this tree.
106
107
TODO: To handle subdirectories we need to create the
108
directories first.
109
110
:note: If the export fails, the destination directory will be
111
left in a half-assed state.
112
"""
113
os.mkdir(dest)
114
mutter('export version %r' % self)
115
inv = self.inventory
116
for dp, ie in inv.iter_entries():
117
kind = ie.kind
118
fullpath = appendpath(dest, dp)
119
if kind == 'directory':
120
os.mkdir(fullpath)
121
elif kind == 'file':
122
pumpfile(self.get_file(ie.file_id), file(fullpath, 'wb'))
123
else:
124
bailout("don't know how to export {%s} of kind %r" % (fid, kind))
125
mutter(" export {%s} kind %s to %s" % (ie.file_id, kind, fullpath))
126
127
128
129
class WorkingTree(Tree):
130
"""Working copy tree.
131
132
The inventory is held in the `Branch` working-inventory, and the
133
files are in a directory on disk.
134
135
It is possible for a `WorkingTree` to have a filename which is
136
not listed in the Inventory and vice versa.
137
"""
138
def __init__(self, basedir, inv):
139
self._inventory = inv
140
self.basedir = basedir
141
self.path2id = inv.path2id
142
143
def __repr__(self):
144
return "<%s of %s>" % (self.__class__.__name__,
145
self.basedir)
146
147
def abspath(self, filename):
148
return os.path.join(self.basedir, filename)
149
150
def has_filename(self, filename):
151
return os.path.exists(self.abspath(filename))
152
153
def get_file(self, file_id):
154
return self.get_file_byname(self.id2path(file_id))
155
156
def get_file_byname(self, filename):
157
return file(self.abspath(filename), 'rb')
158
159
def _get_store_filename(self, file_id):
160
## XXX: badly named; this isn't in the store at all
161
return self.abspath(self.id2path(file_id))
162
163
def has_id(self, file_id):
164
# files that have been deleted are excluded
165
if not self.inventory.has_id(file_id):
166
return False
167
return os.access(self.abspath(self.inventory.id2path(file_id)), os.F_OK)
168
169
def get_file_size(self, file_id):
170
return os.stat(self._get_store_filename(file_id))[ST_SIZE]
171
172
def get_file_sha1(self, file_id):
173
f = self.get_file(file_id)
174
return sha_file(f)
175
176
177
def file_class(self, filename):
178
if self.path2id(filename):
179
return 'V'
180
elif self.is_ignored(filename):
181
return 'I'
182
else:
183
return '?'
184
185
186
def list_files(self):
187
"""Recursively list all files as (path, class, kind, id).
188
189
Lists, but does not descend into unversioned directories.
190
191
This does not include files that have been deleted in this
192
tree.
193
194
Skips the control directory.
195
"""
196
inv = self.inventory
197
198
def descend(from_dir_relpath, from_dir_id, dp):
199
ls = os.listdir(dp)
200
ls.sort()
201
for f in ls:
202
## TODO: If we find a subdirectory with its own .bzr
203
## directory, then that is a separate tree and we
204
## should exclude it.
205
if bzrlib.BZRDIR == f:
206
continue
207
208
# path within tree
209
fp = appendpath(from_dir_relpath, f)
210
211
# absolute path
212
fap = appendpath(dp, f)
213
214
f_ie = inv.get_child(from_dir_id, f)
215
if f_ie:
216
c = 'V'
217
elif self.is_ignored(fp):
218
c = 'I'
219
else:
220
c = '?'
221
222
fk = file_kind(fap)
223
224
if f_ie:
225
if f_ie.kind != fk:
226
bailout("file %r entered as kind %r id %r, now of kind %r"
227
% (fap, f_ie.kind, f_ie.file_id, fk))
228
229
yield fp, c, fk, (f_ie and f_ie.file_id)
230
231
if fk != 'directory':
232
continue
233
234
if c != 'V':
235
# don't descend unversioned directories
236
continue
237
238
for ff in descend(fp, f_ie.file_id, fap):
239
yield ff
240
241
for f in descend('', inv.root.file_id, self.basedir):
242
yield f
243
244
245
246
def unknowns(self):
247
for subp in self.extras():
248
if not self.is_ignored(subp):
249
yield subp
250
251
252
def extras(self):
253
"""Yield all unknown files in this WorkingTree.
254
255
If there are any unknown directories then only the directory is
256
returned, not all its children. But if there are unknown files
257
under a versioned subdirectory, they are returned.
258
259
Currently returned depth-first, sorted by name within directories.
260
"""
261
## TODO: Work from given directory downwards
262
263
for path, dir_entry in self.inventory.directories():
264
mutter("search for unknowns in %r" % path)
265
dirabs = self.abspath(path)
266
if not isdir(dirabs):
267
# e.g. directory deleted
268
continue
269
270
fl = []
271
for subf in os.listdir(dirabs):
272
if (subf != '.bzr'
273
and (subf not in dir_entry.children)):
274
fl.append(subf)
275
276
fl.sort()
277
for subf in fl:
278
subp = appendpath(path, subf)
279
yield subp
280
281
282
def ignored_files(self):
283
"""Yield list of PATH, IGNORE_PATTERN"""
284
for subp in self.extras():
285
pat = self.is_ignored(subp)
286
if pat != None:
287
yield subp, pat
288
289
290
def get_ignore_list(self):
291
"""Return list of ignore patterns.
292
293
Cached in the Tree object after the first call.
294
"""
295
if hasattr(self, '_ignorelist'):
296
return self._ignorelist
297
298
l = bzrlib.DEFAULT_IGNORE[:]
299
if self.has_filename(bzrlib.IGNORE_FILENAME):
300
f = self.get_file_byname(bzrlib.IGNORE_FILENAME)
301
l.extend([line.rstrip("\n\r") for line in f.readlines()])
302
self._ignorelist = l
303
return l
304
305
306
def is_ignored(self, filename):
307
r"""Check whether the filename matches an ignore pattern.
308
309
Patterns containing '/' or '\' need to match the whole path;
310
others match against only the last component.
311
312
If the file is ignored, returns the pattern which caused it to
313
be ignored, otherwise None. So this can simply be used as a
314
boolean if desired."""
315
316
# TODO: Use '**' to match directories, and other extended
317
# globbing stuff from cvs/rsync.
318
319
# XXX: fnmatch is actually not quite what we want: it's only
320
# approximately the same as real Unix fnmatch, and doesn't
321
# treat dotfiles correctly and allows * to match /.
322
# Eventually it should be replaced with something more
323
# accurate.
324
325
for pat in self.get_ignore_list():
326
if '/' in pat or '\\' in pat:
327
328
# as a special case, you can put ./ at the start of a
329
# pattern; this is good to match in the top-level
330
# only;
331
332
if (pat[:2] == './') or (pat[:2] == '.\\'):
333
newpat = pat[2:]
334
else:
335
newpat = pat
336
if fnmatch.fnmatchcase(filename, newpat):
337
return pat
338
else:
339
if fnmatch.fnmatchcase(splitpath(filename)[-1], pat):
340
return pat
341
return None
342
343
344
345
113
346
114
347
class RevisionTree(Tree):
115
348
"""Tree viewing a previous revision.
225
458
if old_name != new_name:
226
459
yield (old_name, new_name)
227
460
228
229
230
######################################################################
231
# export
232
233
def dir_exporter(tree, dest):
234
"""Export this tree to a new directory.
235
236
`dest` should not exist, and will be created holding the
237
contents of this tree.
238
239
TODO: To handle subdirectories we need to create the
240
directories first.
241
242
:note: If the export fails, the destination directory will be
243
left in a half-assed state.
244
"""
245
os.mkdir(dest)
246
mutter('export version %r' % tree)
247
inv = tree.inventory
248
for dp, ie in inv.iter_entries():
249
kind = ie.kind
250
fullpath = appendpath(dest, dp)
251
if kind == 'directory':
252
os.mkdir(fullpath)
253
elif kind == 'file':
254
pumpfile(tree.get_file(ie.file_id), file(fullpath, 'wb'))
255
else:
256
raise BzrError("don't know how to export {%s} of kind %r" % (ie.file_id, kind))
257
mutter(" export {%s} kind %s to %s" % (ie.file_id, kind, fullpath))
258
exporters['dir'] = dir_exporter
259
260
try:
261
import tarfile
262
except ImportError:
263
pass
264
else:
265
def tar_exporter(tree, dest, compression=None):
266
"""Export this tree to a new tar file.
267
268
`dest` will be created holding the contents of this tree; if it
269
already exists, it will be clobbered, like with "tar -c".
270
"""
271
now = time.time()
272
compression = str(compression or '')
273
try:
274
ball = tarfile.open(dest, 'w:' + compression)
275
except tarfile.CompressionError, e:
276
raise BzrError(str(e))
277
mutter('export version %r' % tree)
278
inv = tree.inventory
279
for dp, ie in inv.iter_entries():
280
mutter(" export {%s} kind %s to %s" % (ie.file_id, ie.kind, dest))
281
item = tarfile.TarInfo(dp)
282
# TODO: would be cool to actually set it to the timestamp of the
283
# revision it was last changed
284
item.mtime = now
285
if ie.kind == 'directory':
286
item.type = tarfile.DIRTYPE
287
fileobj = None
288
item.name += '/'
289
item.size = 0
290
item.mode = 0755
291
elif ie.kind == 'file':
292
item.type = tarfile.REGTYPE
293
fileobj = tree.get_file(ie.file_id)
294
item.size = _find_file_size(fileobj)
295
item.mode = 0644
296
else:
297
raise BzrError("don't know how to export {%s} of kind %r" %
298
(ie.file_id, ie.kind))
299
300
ball.addfile(item, fileobj)
301
ball.close()
302
exporters['tar'] = tar_exporter
303
304
def tgz_exporter(tree, dest):
305
tar_exporter(tree, dest, compression='gz')
306
exporters['tgz'] = tgz_exporter
307
308
def tbz_exporter(tree, dest):
309
tar_exporter(tree, dest, compression='bz2')
310
exporters['tbz2'] = tbz_exporter
311
312
313
def _find_file_size(fileobj):
314
offset = fileobj.tell()
315
try:
316
fileobj.seek(0, 2)
317
size = fileobj.tell()
318
except TypeError:
319
# gzip doesn't accept second argument to seek()
320
fileobj.seek(0)
321
size = 0
322
while True:
323
nread = len(fileobj.read())
324
if nread == 0:
325
break
326
size += nread
327
fileobj.seek(offset)
328
return size
Loggerhead is a web-based interface for Breezy
Version: 2.0.1