« back to all changes in this revision
Viewing changes to bzrlib/tree.py
- browse files at revision 439
- compare with another revision
- download diff
- download tarball
- view history from revision 439
- Committer: Martin Pool
- Date: 2005-05-10 07:06:05 UTC
- Revision ID: mbp@sourcefrog.net-20050510070605-0a2453ae5db6fc3c
- new command 'bzr added'
- files added:
- bzrlib/statcache.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.
143
382
144
383
145
384
class EmptyTree(Tree):
146
def __init__(self, root_id):
147
from bzrlib.inventory import Inventory
148
self._inventory = Inventory(root_id)
385
def __init__(self):
386
self._inventory = Inventory()
149
387
150
388
def has_filename(self, filename):
151
389
return False
220
458
if old_name != new_name:
221
459
yield (old_name, new_name)
222
460
223
224
225
######################################################################
226
# export
227
228
def dir_exporter(tree, dest, root):
229
"""Export this tree to a new directory.
230
231
`dest` should not exist, and will be created holding the
232
contents of this tree.
233
234
TODO: To handle subdirectories we need to create the
235
directories first.
236
237
:note: If the export fails, the destination directory will be
238
left in a half-assed state.
239
"""
240
import os
241
os.mkdir(dest)
242
mutter('export version %r' % tree)
243
inv = tree.inventory
244
for dp, ie in inv.iter_entries():
245
kind = ie.kind
246
fullpath = appendpath(dest, dp)
247
if kind == 'directory':
248
os.mkdir(fullpath)
249
elif kind == 'file':
250
pumpfile(tree.get_file(ie.file_id), file(fullpath, 'wb'))
251
else:
252
raise BzrError("don't know how to export {%s} of kind %r" % (ie.file_id, kind))
253
mutter(" export {%s} kind %s to %s" % (ie.file_id, kind, fullpath))
254
exporters['dir'] = dir_exporter
255
256
try:
257
import tarfile
258
except ImportError:
259
pass
260
else:
261
def get_root_name(dest):
262
"""Get just the root name for a tarball.
263
264
>>> get_root_name('mytar.tar')
265
'mytar'
266
>>> get_root_name('mytar.tar.bz2')
267
'mytar'
268
>>> get_root_name('tar.tar.tar.tgz')
269
'tar.tar.tar'
270
>>> get_root_name('bzr-0.0.5.tar.gz')
271
'bzr-0.0.5'
272
>>> get_root_name('a/long/path/mytar.tgz')
273
'mytar'
274
>>> get_root_name('../parent/../dir/other.tbz2')
275
'other'
276
"""
277
endings = ['.tar', '.tar.gz', '.tgz', '.tar.bz2', '.tbz2']
278
dest = os.path.basename(dest)
279
for end in endings:
280
if dest.endswith(end):
281
return dest[:-len(end)]
282
283
def tar_exporter(tree, dest, root, compression=None):
284
"""Export this tree to a new tar file.
285
286
`dest` will be created holding the contents of this tree; if it
287
already exists, it will be clobbered, like with "tar -c".
288
"""
289
from time import time
290
now = time()
291
compression = str(compression or '')
292
if root is None:
293
root = get_root_name(dest)
294
try:
295
ball = tarfile.open(dest, 'w:' + compression)
296
except tarfile.CompressionError, e:
297
raise BzrError(str(e))
298
mutter('export version %r' % tree)
299
inv = tree.inventory
300
for dp, ie in inv.iter_entries():
301
mutter(" export {%s} kind %s to %s" % (ie.file_id, ie.kind, dest))
302
item = tarfile.TarInfo(os.path.join(root, dp))
303
# TODO: would be cool to actually set it to the timestamp of the
304
# revision it was last changed
305
item.mtime = now
306
if ie.kind == 'directory':
307
item.type = tarfile.DIRTYPE
308
fileobj = None
309
item.name += '/'
310
item.size = 0
311
item.mode = 0755
312
elif ie.kind == 'file':
313
item.type = tarfile.REGTYPE
314
fileobj = tree.get_file(ie.file_id)
315
item.size = _find_file_size(fileobj)
316
item.mode = 0644
317
else:
318
raise BzrError("don't know how to export {%s} of kind %r" %
319
(ie.file_id, ie.kind))
320
321
ball.addfile(item, fileobj)
322
ball.close()
323
exporters['tar'] = tar_exporter
324
325
def tgz_exporter(tree, dest, root):
326
tar_exporter(tree, dest, root, compression='gz')
327
exporters['tgz'] = tgz_exporter
328
329
def tbz_exporter(tree, dest, root):
330
tar_exporter(tree, dest, root, compression='bz2')
331
exporters['tbz2'] = tbz_exporter
332
333
334
def _find_file_size(fileobj):
335
offset = fileobj.tell()
336
try:
337
fileobj.seek(0, 2)
338
size = fileobj.tell()
339
except TypeError:
340
# gzip doesn't accept second argument to seek()
341
fileobj.seek(0)
342
size = 0
343
while True:
344
nread = len(fileobj.read())
345
if nread == 0:
346
break
347
size += nread
348
fileobj.seek(offset)
349
return size
Loggerhead is a web-based interface for Breezy
Version: 2.0.1