« back to all changes in this revision
Viewing changes to bzrlib/tree.py
- browse files at revision 423
- compare with another revision
- download diff
- download tarball
- view history from revision 423
- Committer: Martin Pool
- Date: 2005-05-10 03:55:34 UTC
- Revision ID: mbp@sourcefrog.net-20050510035534-643062e821052ac5
- Add fortune-cookie external plugin demonstration
- files added:
- bzrlib/cache.py
- files removed:
- bzr-man.py
- bzrlib/selftest
- effbot
- effbot/org
- patches
- plugins
- plugins/changeset
- tools
- 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
import os
22
23
from bzrlib.trace import mutter, note
24
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
25
32
26
33
import bzrlib
27
34
28
exporters = {}
29
30
class Tree(object):
35
class Tree:
31
36
"""Abstract file tree.
32
37
33
38
There are several subclasses:
56
61
def has_id(self, file_id):
57
62
return self.inventory.has_id(file_id)
58
63
59
__contains__ = has_id
60
61
def __iter__(self):
62
return iter(self.inventory)
64
def id_set(self):
65
"""Return set of all ids in this tree."""
66
return self.inventory.id_set()
63
67
64
68
def id2path(self, file_id):
65
69
return self.inventory.id2path(file_id)
76
80
77
81
if ie.text_size != None:
78
82
if ie.text_size != fp['size']:
79
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),
80
84
["inventory expects %d bytes" % ie.text_size,
81
85
"file is actually %d bytes" % fp['size'],
82
86
"store is probably damaged/corrupt"])
83
87
84
88
if ie.text_sha1 != fp['sha1']:
85
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),
86
90
["inventory expects %s" % ie.text_sha1,
87
91
"file is actually %s" % fp['sha1'],
88
92
"store is probably damaged/corrupt"])
94
98
pumpfile(self.get_file(fileid), sys.stdout)
95
99
96
100
97
def export(self, dest, format='dir', root=None):
98
"""Export this tree."""
99
try:
100
exporter = exporters[format]
101
except KeyError:
102
from bzrlib.errors import BzrCommandError
103
raise BzrCommandError("export format %r not supported" % format)
104
exporter(self, dest, root)
105
106
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
107
346
108
347
class RevisionTree(Tree):
109
348
"""Tree viewing a previous revision.
131
370
132
371
def get_file_sha1(self, file_id):
133
372
ie = self._inventory[file_id]
134
if ie.kind == "file":
135
return ie.text_sha1
373
return ie.text_sha1
136
374
137
375
def has_filename(self, filename):
138
376
return bool(self.inventory.path2id(filename))
144
382
145
383
146
384
class EmptyTree(Tree):
147
def __init__(self, root_id):
148
from bzrlib.inventory import Inventory
149
self._inventory = Inventory(root_id)
385
def __init__(self):
386
self._inventory = Inventory()
150
387
151
388
def has_filename(self, filename):
152
389
return False
155
392
if False: # just to make it a generator
156
393
yield None
157
394
158
def __contains__(self, file_id):
159
return file_id in self._inventory
160
161
def get_file_sha1(self, file_id):
162
assert self._inventory[file_id].kind == "root_directory"
163
return None
164
165
166
395
167
396
168
397
######################################################################
229
458
if old_name != new_name:
230
459
yield (old_name, new_name)
231
460
232
233
234
######################################################################
235
# export
236
237
def dir_exporter(tree, dest, root):
238
"""Export this tree to a new directory.
239
240
`dest` should not exist, and will be created holding the
241
contents of this tree.
242
243
TODO: To handle subdirectories we need to create the
244
directories first.
245
246
:note: If the export fails, the destination directory will be
247
left in a half-assed state.
248
"""
249
import os
250
os.mkdir(dest)
251
mutter('export version %r' % tree)
252
inv = tree.inventory
253
for dp, ie in inv.iter_entries():
254
kind = ie.kind
255
fullpath = appendpath(dest, dp)
256
if kind == 'directory':
257
os.mkdir(fullpath)
258
elif kind == 'file':
259
pumpfile(tree.get_file(ie.file_id), file(fullpath, 'wb'))
260
else:
261
raise BzrError("don't know how to export {%s} of kind %r" % (ie.file_id, kind))
262
mutter(" export {%s} kind %s to %s" % (ie.file_id, kind, fullpath))
263
exporters['dir'] = dir_exporter
264
265
try:
266
import tarfile
267
except ImportError:
268
pass
269
else:
270
def get_root_name(dest):
271
"""Get just the root name for a tarball.
272
273
>>> get_root_name('mytar.tar')
274
'mytar'
275
>>> get_root_name('mytar.tar.bz2')
276
'mytar'
277
>>> get_root_name('tar.tar.tar.tgz')
278
'tar.tar.tar'
279
>>> get_root_name('bzr-0.0.5.tar.gz')
280
'bzr-0.0.5'
281
>>> get_root_name('a/long/path/mytar.tgz')
282
'mytar'
283
>>> get_root_name('../parent/../dir/other.tbz2')
284
'other'
285
"""
286
endings = ['.tar', '.tar.gz', '.tgz', '.tar.bz2', '.tbz2']
287
dest = os.path.basename(dest)
288
for end in endings:
289
if dest.endswith(end):
290
return dest[:-len(end)]
291
292
def tar_exporter(tree, dest, root, compression=None):
293
"""Export this tree to a new tar file.
294
295
`dest` will be created holding the contents of this tree; if it
296
already exists, it will be clobbered, like with "tar -c".
297
"""
298
from time import time
299
now = time()
300
compression = str(compression or '')
301
if root is None:
302
root = get_root_name(dest)
303
try:
304
ball = tarfile.open(dest, 'w:' + compression)
305
except tarfile.CompressionError, e:
306
raise BzrError(str(e))
307
mutter('export version %r' % tree)
308
inv = tree.inventory
309
for dp, ie in inv.iter_entries():
310
mutter(" export {%s} kind %s to %s" % (ie.file_id, ie.kind, dest))
311
item = tarfile.TarInfo(os.path.join(root, dp))
312
# TODO: would be cool to actually set it to the timestamp of the
313
# revision it was last changed
314
item.mtime = now
315
if ie.kind == 'directory':
316
item.type = tarfile.DIRTYPE
317
fileobj = None
318
item.name += '/'
319
item.size = 0
320
item.mode = 0755
321
elif ie.kind == 'file':
322
item.type = tarfile.REGTYPE
323
fileobj = tree.get_file(ie.file_id)
324
item.size = _find_file_size(fileobj)
325
item.mode = 0644
326
else:
327
raise BzrError("don't know how to export {%s} of kind %r" %
328
(ie.file_id, ie.kind))
329
330
ball.addfile(item, fileobj)
331
ball.close()
332
exporters['tar'] = tar_exporter
333
334
def tgz_exporter(tree, dest, root):
335
tar_exporter(tree, dest, root, compression='gz')
336
exporters['tgz'] = tgz_exporter
337
338
def tbz_exporter(tree, dest, root):
339
tar_exporter(tree, dest, root, compression='bz2')
340
exporters['tbz2'] = tbz_exporter
341
342
343
def _find_file_size(fileobj):
344
offset = fileobj.tell()
345
try:
346
fileobj.seek(0, 2)
347
size = fileobj.tell()
348
except TypeError:
349
# gzip doesn't accept second argument to seek()
350
fileobj.seek(0)
351
size = 0
352
while True:
353
nread = len(fileobj.read())
354
if nread == 0:
355
break
356
size += nread
357
fileobj.seek(offset)
358
return size
Loggerhead is a web-based interface for Breezy
Version: 2.0.1