← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tree.py

  • Committer: Martin Pool
  • Date: 2005-05-15 02:36:04 UTC
  • Revision ID: mbp@sourcefrog.net-20050515023603-7328f6cbabd2b09a
- Merge aaron's merge command

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tree.py
17
17
"""Tree classes, representing directory at point in time.
18
18
"""
19
19
 
20
 
import os
 
20
from sets import Set
 
21
import os.path, os, fnmatch
 
22
 
 
23
from osutils import pumpfile, 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
21
32
 
22
33
import bzrlib
23
 
from bzrlib.trace import mutter, note
24
 
from bzrlib.errors import BzrError
25
 
from bzrlib.inventory import Inventory
26
 
from bzrlib.osutils import pumpfile, appendpath, fingerprint_file
27
 
 
28
 
 
29
 
exporters = {}
30
 
 
31
 
class Tree(object):
 
34
 
 
35
class Tree:
32
36
    """Abstract file tree.
33
37
 
34
38
    There are several subclasses:
59
63
 
60
64
    __contains__ = has_id
61
65
 
 
66
    def id_set(self):
 
67
        """Return set of all ids in this tree."""
 
68
        return self.inventory.id_set()
 
69
 
62
70
    def __iter__(self):
63
71
        return iter(self.inventory)
64
72
 
67
75
 
68
76
    def _get_inventory(self):
69
77
        return self._inventory
70
 
    
71
 
    def get_file_by_path(self, path):
72
 
        return self.get_file(self._inventory.path2id(path))
73
78
 
74
79
    inventory = property(_get_inventory,
75
80
                         doc="Inventory of this Tree")
80
85
        
81
86
        if ie.text_size != None:
82
87
            if ie.text_size != fp['size']:
83
 
                raise BzrError("mismatched size for file %r in %r" % (ie.file_id, self._store),
 
88
                bailout("mismatched size for file %r in %r" % (ie.file_id, self._store),
84
89
                        ["inventory expects %d bytes" % ie.text_size,
85
90
                         "file is actually %d bytes" % fp['size'],
86
91
                         "store is probably damaged/corrupt"])
87
92
 
88
93
        if ie.text_sha1 != fp['sha1']:
89
 
            raise BzrError("wrong SHA-1 for file %r in %r" % (ie.file_id, self._store),
 
94
            bailout("wrong SHA-1 for file %r in %r" % (ie.file_id, self._store),
90
95
                    ["inventory expects %s" % ie.text_sha1,
91
96
                     "file is actually %s" % fp['sha1'],
92
97
                     "store is probably damaged/corrupt"])
98
103
        pumpfile(self.get_file(fileid), sys.stdout)
99
104
        
100
105
        
101
 
    def export(self, dest, format='dir', root=None):
102
 
        """Export this tree."""
103
 
        try:
104
 
            exporter = exporters[format]
105
 
        except KeyError:
106
 
            from bzrlib.errors import BzrCommandError
107
 
            raise BzrCommandError("export format %r not supported" % format)
108
 
        exporter(self, dest, root)
 
106
    def export(self, dest):        
 
107
        """Export this tree to a new directory.
 
108
 
 
109
        `dest` should not exist, and will be created holding the
 
110
        contents of this tree.
 
111
 
 
112
        TODO: To handle subdirectories we need to create the
 
113
               directories first.
 
114
 
 
115
        :note: If the export fails, the destination directory will be
 
116
               left in a half-assed state.
 
117
        """
 
118
        os.mkdir(dest)
 
119
        mutter('export version %r' % self)
 
120
        inv = self.inventory
 
121
        for dp, ie in inv.iter_entries():
 
122
            kind = ie.kind
 
123
            fullpath = appendpath(dest, dp)
 
124
            if kind == 'directory':
 
125
                os.mkdir(fullpath)
 
126
            elif kind == 'file':
 
127
                pumpfile(self.get_file(ie.file_id), file(fullpath, 'wb'))
 
128
            else:
 
129
                bailout("don't know how to export {%s} of kind %r" % (ie.file_id, kind))
 
130
            mutter("  export {%s} kind %s to %s" % (ie.file_id, kind, fullpath))
109
131
 
110
132
 
111
133
 
135
157
 
136
158
    def get_file_sha1(self, file_id):
137
159
        ie = self._inventory[file_id]
138
 
        if ie.kind == "file":
139
 
            return ie.text_sha1
 
160
        return ie.text_sha1
140
161
 
141
162
    def has_filename(self, filename):
142
163
        return bool(self.inventory.path2id(filename))
158
179
        if False:  # just to make it a generator
159
180
            yield None
160
181
    
161
 
    def __contains__(self, file_id):
162
 
        return file_id in self._inventory
163
 
 
164
182
 
165
183
 
166
184
######################################################################
227
245
        if old_name != new_name:
228
246
            yield (old_name, new_name)
229
247
            
230
 
 
231
 
 
232
 
######################################################################
233
 
# export
234
 
 
235
 
def dir_exporter(tree, dest, root):
236
 
    """Export this tree to a new directory.
237
 
 
238
 
    `dest` should not exist, and will be created holding the
239
 
    contents of this tree.
240
 
 
241
 
    TODO: To handle subdirectories we need to create the
242
 
           directories first.
243
 
 
244
 
    :note: If the export fails, the destination directory will be
245
 
           left in a half-assed state.
246
 
    """
247
 
    import os
248
 
    os.mkdir(dest)
249
 
    mutter('export version %r' % tree)
250
 
    inv = tree.inventory
251
 
    for dp, ie in inv.iter_entries():
252
 
        kind = ie.kind
253
 
        fullpath = appendpath(dest, dp)
254
 
        if kind == 'directory':
255
 
            os.mkdir(fullpath)
256
 
        elif kind == 'file':
257
 
            pumpfile(tree.get_file(ie.file_id), file(fullpath, 'wb'))
258
 
        else:
259
 
            raise BzrError("don't know how to export {%s} of kind %r" % (ie.file_id, kind))
260
 
        mutter("  export {%s} kind %s to %s" % (ie.file_id, kind, fullpath))
261
 
exporters['dir'] = dir_exporter
262
 
 
263
 
try:
264
 
    import tarfile
265
 
except ImportError:
266
 
    pass
267
 
else:
268
 
    def get_root_name(dest):
269
 
        """Get just the root name for a tarball.
270
 
 
271
 
        >>> get_root_name('mytar.tar')
272
 
        'mytar'
273
 
        >>> get_root_name('mytar.tar.bz2')
274
 
        'mytar'
275
 
        >>> get_root_name('tar.tar.tar.tgz')
276
 
        'tar.tar.tar'
277
 
        >>> get_root_name('bzr-0.0.5.tar.gz')
278
 
        'bzr-0.0.5'
279
 
        >>> get_root_name('a/long/path/mytar.tgz')
280
 
        'mytar'
281
 
        >>> get_root_name('../parent/../dir/other.tbz2')
282
 
        'other'
283
 
        """
284
 
        endings = ['.tar', '.tar.gz', '.tgz', '.tar.bz2', '.tbz2']
285
 
        dest = os.path.basename(dest)
286
 
        for end in endings:
287
 
            if dest.endswith(end):
288
 
                return dest[:-len(end)]
289
 
 
290
 
    def tar_exporter(tree, dest, root, compression=None):
291
 
        """Export this tree to a new tar file.
292
 
 
293
 
        `dest` will be created holding the contents of this tree; if it
294
 
        already exists, it will be clobbered, like with "tar -c".
295
 
        """
296
 
        from time import time
297
 
        now = time()
298
 
        compression = str(compression or '')
299
 
        if root is None:
300
 
            root = get_root_name(dest)
301
 
        try:
302
 
            ball = tarfile.open(dest, 'w:' + compression)
303
 
        except tarfile.CompressionError, e:
304
 
            raise BzrError(str(e))
305
 
        mutter('export version %r' % tree)
306
 
        inv = tree.inventory
307
 
        for dp, ie in inv.iter_entries():
308
 
            mutter("  export {%s} kind %s to %s" % (ie.file_id, ie.kind, dest))
309
 
            item = tarfile.TarInfo(os.path.join(root, dp))
310
 
            # TODO: would be cool to actually set it to the timestamp of the
311
 
            # revision it was last changed
312
 
            item.mtime = now
313
 
            if ie.kind == 'directory':
314
 
                item.type = tarfile.DIRTYPE
315
 
                fileobj = None
316
 
                item.name += '/'
317
 
                item.size = 0
318
 
                item.mode = 0755
319
 
            elif ie.kind == 'file':
320
 
                item.type = tarfile.REGTYPE
321
 
                fileobj = tree.get_file(ie.file_id)
322
 
                item.size = _find_file_size(fileobj)
323
 
                item.mode = 0644
324
 
            else:
325
 
                raise BzrError("don't know how to export {%s} of kind %r" %
326
 
                        (ie.file_id, ie.kind))
327
 
 
328
 
            ball.addfile(item, fileobj)
329
 
        ball.close()
330
 
    exporters['tar'] = tar_exporter
331
 
 
332
 
    def tgz_exporter(tree, dest, root):
333
 
        tar_exporter(tree, dest, root, compression='gz')
334
 
    exporters['tgz'] = tgz_exporter
335
 
 
336
 
    def tbz_exporter(tree, dest, root):
337
 
        tar_exporter(tree, dest, root, compression='bz2')
338
 
    exporters['tbz2'] = tbz_exporter
339
 
 
340
 
 
341
 
def _find_file_size(fileobj):
342
 
    offset = fileobj.tell()
343
 
    try:
344
 
        fileobj.seek(0, 2)
345
 
        size = fileobj.tell()
346
 
    except TypeError:
347
 
        # gzip doesn't accept second argument to seek()
348
 
        fileobj.seek(0)
349
 
        size = 0
350
 
        while True:
351
 
            nread = len(fileobj.read())
352
 
            if nread == 0:
353
 
                break
354
 
            size += nread
355
 
    fileobj.seek(offset)
356
 
    return size