« back to all changes in this revision
Viewing changes to bzrlib/tree.py
- browse files at revision 351
- compare with another revision
- download diff
- download tarball
- view history from revision 351
- Committer: Martin Pool
- Date: 2005-05-05 02:59:39 UTC
- Revision ID: mbp@sourcefrog.net-20050505025938-8399b9ca401a1176
- Split out help functions into bzrlib.help
- files added:
- bzrlib/tests.py
- files removed:
- bzr-man.py
- bzrlib/selftest
- effbot
- effbot/org
- patches
- plugins
- plugins/changeset
- plugins/rsync
- files renamed:
- contrib/bash/bzr.simple => contrib/bash/bzr
- files modified:
- .bzrignore
added
removed
bzrlib/tree.py
17
17
"""Tree classes, representing directory at point in time.
18
18
"""
19
19
20
from osutils import pumpfile, appendpath, fingerprint_file
21
22
from bzrlib.trace import mutter, note
23
from bzrlib.errors import BzrError
20
from sets import Set
21
import os.path, os, fnmatch
22
23
from osutils import pumpfile, compare_files, filesize, quotefn, sha_file, \
24
joinpath, splitpath, appendpath, isdir, isfile, file_kind, fingerprint_file
25
import errno
26
from stat import S_ISREG, S_ISDIR, ST_MODE, ST_SIZE
27
28
from inventory import Inventory
29
from trace import mutter, note
30
from errors import bailout
31
import branch
24
32
25
33
import bzrlib
26
34
27
exporters = {}
28
29
class Tree(object):
35
class Tree:
30
36
"""Abstract file tree.
31
37
32
38
There are several subclasses:
55
61
def has_id(self, file_id):
56
62
return self.inventory.has_id(file_id)
57
63
58
__contains__ = has_id
59
60
def __iter__(self):
61
return iter(self.inventory)
64
def id_set(self):
65
"""Return set of all ids in this tree."""
66
return self.inventory.id_set()
62
67
63
68
def id2path(self, file_id):
64
69
return self.inventory.id2path(file_id)
75
80
76
81
if ie.text_size != None:
77
82
if ie.text_size != fp['size']:
78
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),
79
84
["inventory expects %d bytes" % ie.text_size,
80
85
"file is actually %d bytes" % fp['size'],
81
86
"store is probably damaged/corrupt"])
82
87
83
88
if ie.text_sha1 != fp['sha1']:
84
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),
85
90
["inventory expects %s" % ie.text_sha1,
86
91
"file is actually %s" % fp['sha1'],
87
92
"store is probably damaged/corrupt"])
93
98
pumpfile(self.get_file(fileid), sys.stdout)
94
99
95
100
96
def export(self, dest, format='dir'):
97
"""Export this tree."""
98
try:
99
exporter = exporters[format]
100
except KeyError:
101
raise BzrCommandError("export format %r not supported" % format)
102
exporter(self, dest)
103
104
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
105
346
106
347
class RevisionTree(Tree):
107
348
"""Tree viewing a previous revision.
142
383
143
384
class EmptyTree(Tree):
144
385
def __init__(self):
145
from bzrlib.inventory import Inventory
146
386
self._inventory = Inventory()
147
387
148
388
def has_filename(self, filename):
218
458
if old_name != new_name:
219
459
yield (old_name, new_name)
220
460
221
222
223
######################################################################
224
# export
225
226
def dir_exporter(tree, dest):
227
"""Export this tree to a new directory.
228
229
`dest` should not exist, and will be created holding the
230
contents of this tree.
231
232
TODO: To handle subdirectories we need to create the
233
directories first.
234
235
:note: If the export fails, the destination directory will be
236
left in a half-assed state.
237
"""
238
import os
239
os.mkdir(dest)
240
mutter('export version %r' % tree)
241
inv = tree.inventory
242
for dp, ie in inv.iter_entries():
243
kind = ie.kind
244
fullpath = appendpath(dest, dp)
245
if kind == 'directory':
246
os.mkdir(fullpath)
247
elif kind == 'file':
248
pumpfile(tree.get_file(ie.file_id), file(fullpath, 'wb'))
249
else:
250
raise BzrError("don't know how to export {%s} of kind %r" % (ie.file_id, kind))
251
mutter(" export {%s} kind %s to %s" % (ie.file_id, kind, fullpath))
252
exporters['dir'] = dir_exporter
253
254
try:
255
import tarfile
256
except ImportError:
257
pass
258
else:
259
def tar_exporter(tree, dest, compression=None):
260
"""Export this tree to a new tar file.
261
262
`dest` will be created holding the contents of this tree; if it
263
already exists, it will be clobbered, like with "tar -c".
264
"""
265
from time import time
266
now = time()
267
compression = str(compression or '')
268
try:
269
ball = tarfile.open(dest, 'w:' + compression)
270
except tarfile.CompressionError, e:
271
raise BzrError(str(e))
272
mutter('export version %r' % tree)
273
inv = tree.inventory
274
for dp, ie in inv.iter_entries():
275
mutter(" export {%s} kind %s to %s" % (ie.file_id, ie.kind, dest))
276
item = tarfile.TarInfo(dp)
277
# TODO: would be cool to actually set it to the timestamp of the
278
# revision it was last changed
279
item.mtime = now
280
if ie.kind == 'directory':
281
item.type = tarfile.DIRTYPE
282
fileobj = None
283
item.name += '/'
284
item.size = 0
285
item.mode = 0755
286
elif ie.kind == 'file':
287
item.type = tarfile.REGTYPE
288
fileobj = tree.get_file(ie.file_id)
289
item.size = _find_file_size(fileobj)
290
item.mode = 0644
291
else:
292
raise BzrError("don't know how to export {%s} of kind %r" %
293
(ie.file_id, ie.kind))
294
295
ball.addfile(item, fileobj)
296
ball.close()
297
exporters['tar'] = tar_exporter
298
299
def tgz_exporter(tree, dest):
300
tar_exporter(tree, dest, compression='gz')
301
exporters['tgz'] = tgz_exporter
302
303
def tbz_exporter(tree, dest):
304
tar_exporter(tree, dest, compression='bz2')
305
exporters['tbz2'] = tbz_exporter
306
307
308
def _find_file_size(fileobj):
309
offset = fileobj.tell()
310
try:
311
fileobj.seek(0, 2)
312
size = fileobj.tell()
313
except TypeError:
314
# gzip doesn't accept second argument to seek()
315
fileobj.seek(0)
316
size = 0
317
while True:
318
nread = len(fileobj.read())
319
if nread == 0:
320
break
321
size += nread
322
fileobj.seek(offset)
323
return size
Loggerhead is a web-based interface for Breezy
Version: 2.0.1