← 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-17 06:56:16 UTC
  • Revision ID: mbp@sourcefrog.net-20050517065616-6f23381d6184a8aa
- add space for un-merged patches

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
 
    def get_file_sha1(self, file_id):
165
 
        assert self._inventory[file_id].kind == "root_directory"
166
 
        return None
167
 
 
168
 
 
169
182
 
170
183
 
171
184
######################################################################
232
245
        if old_name != new_name:
233
246
            yield (old_name, new_name)
234
247
            
235
 
 
236
 
 
237
 
######################################################################
238
 
# export
239
 
 
240
 
def dir_exporter(tree, dest, root):
241
 
    """Export this tree to a new directory.
242
 
 
243
 
    `dest` should not exist, and will be created holding the
244
 
    contents of this tree.
245
 
 
246
 
    TODO: To handle subdirectories we need to create the
247
 
           directories first.
248
 
 
249
 
    :note: If the export fails, the destination directory will be
250
 
           left in a half-assed state.
251
 
    """
252
 
    import os
253
 
    os.mkdir(dest)
254
 
    mutter('export version %r' % tree)
255
 
    inv = tree.inventory
256
 
    for dp, ie in inv.iter_entries():
257
 
        kind = ie.kind
258
 
        fullpath = appendpath(dest, dp)
259
 
        if kind == 'directory':
260
 
            os.mkdir(fullpath)
261
 
        elif kind == 'file':
262
 
            pumpfile(tree.get_file(ie.file_id), file(fullpath, 'wb'))
263
 
        else:
264
 
            raise BzrError("don't know how to export {%s} of kind %r" % (ie.file_id, kind))
265
 
        mutter("  export {%s} kind %s to %s" % (ie.file_id, kind, fullpath))
266
 
exporters['dir'] = dir_exporter
267
 
 
268
 
try:
269
 
    import tarfile
270
 
except ImportError:
271
 
    pass
272
 
else:
273
 
    def get_root_name(dest):
274
 
        """Get just the root name for a tarball.
275
 
 
276
 
        >>> get_root_name('mytar.tar')
277
 
        'mytar'
278
 
        >>> get_root_name('mytar.tar.bz2')
279
 
        'mytar'
280
 
        >>> get_root_name('tar.tar.tar.tgz')
281
 
        'tar.tar.tar'
282
 
        >>> get_root_name('bzr-0.0.5.tar.gz')
283
 
        'bzr-0.0.5'
284
 
        >>> get_root_name('a/long/path/mytar.tgz')
285
 
        'mytar'
286
 
        >>> get_root_name('../parent/../dir/other.tbz2')
287
 
        'other'
288
 
        """
289
 
        endings = ['.tar', '.tar.gz', '.tgz', '.tar.bz2', '.tbz2']
290
 
        dest = os.path.basename(dest)
291
 
        for end in endings:
292
 
            if dest.endswith(end):
293
 
                return dest[:-len(end)]
294
 
 
295
 
    def tar_exporter(tree, dest, root, compression=None):
296
 
        """Export this tree to a new tar file.
297
 
 
298
 
        `dest` will be created holding the contents of this tree; if it
299
 
        already exists, it will be clobbered, like with "tar -c".
300
 
        """
301
 
        from time import time
302
 
        now = time()
303
 
        compression = str(compression or '')
304
 
        if root is None:
305
 
            root = get_root_name(dest)
306
 
        try:
307
 
            ball = tarfile.open(dest, 'w:' + compression)
308
 
        except tarfile.CompressionError, e:
309
 
            raise BzrError(str(e))
310
 
        mutter('export version %r' % tree)
311
 
        inv = tree.inventory
312
 
        for dp, ie in inv.iter_entries():
313
 
            mutter("  export {%s} kind %s to %s" % (ie.file_id, ie.kind, dest))
314
 
            item = tarfile.TarInfo(os.path.join(root, dp))
315
 
            # TODO: would be cool to actually set it to the timestamp of the
316
 
            # revision it was last changed
317
 
            item.mtime = now
318
 
            if ie.kind == 'directory':
319
 
                item.type = tarfile.DIRTYPE
320
 
                fileobj = None
321
 
                item.name += '/'
322
 
                item.size = 0
323
 
                item.mode = 0755
324
 
            elif ie.kind == 'file':
325
 
                item.type = tarfile.REGTYPE
326
 
                fileobj = tree.get_file(ie.file_id)
327
 
                item.size = _find_file_size(fileobj)
328
 
                item.mode = 0644
329
 
            else:
330
 
                raise BzrError("don't know how to export {%s} of kind %r" %
331
 
                        (ie.file_id, ie.kind))
332
 
 
333
 
            ball.addfile(item, fileobj)
334
 
        ball.close()
335
 
    exporters['tar'] = tar_exporter
336
 
 
337
 
    def tgz_exporter(tree, dest, root):
338
 
        tar_exporter(tree, dest, root, compression='gz')
339
 
    exporters['tgz'] = tgz_exporter
340
 
 
341
 
    def tbz_exporter(tree, dest, root):
342
 
        tar_exporter(tree, dest, root, compression='bz2')
343
 
    exporters['tbz2'] = tbz_exporter
344
 
 
345
 
 
346
 
def _find_file_size(fileobj):
347
 
    offset = fileobj.tell()
348
 
    try:
349
 
        fileobj.seek(0, 2)
350
 
        size = fileobj.tell()
351
 
    except TypeError:
352
 
        # gzip doesn't accept second argument to seek()
353
 
        fileobj.seek(0)
354
 
        size = 0
355
 
        while True:
356
 
            nread = len(fileobj.read())
357
 
            if nread == 0:
358
 
                break
359
 
            size += nread
360
 
    fileobj.seek(offset)
361
 
    return size