← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tree.py

- merge improved merge base selection from aaron
aaron.bentley@utoronto.ca-20050912025534-43d7275dd948e4ad

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
 
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
 
20
import os
32
21
 
33
22
import bzrlib
34
 
 
35
 
class Tree:
 
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):
36
32
    """Abstract file tree.
37
33
 
38
34
    There are several subclasses:
63
59
 
64
60
    __contains__ = has_id
65
61
 
66
 
    def id_set(self):
67
 
        """Return set of all ids in this tree."""
68
 
        return self.inventory.id_set()
69
 
 
70
62
    def __iter__(self):
71
63
        return iter(self.inventory)
72
64
 
75
67
 
76
68
    def _get_inventory(self):
77
69
        return self._inventory
 
70
    
 
71
    def get_file_by_path(self, path):
 
72
        return self.get_file(self._inventory.path2id(path))
78
73
 
79
74
    inventory = property(_get_inventory,
80
75
                         doc="Inventory of this Tree")
85
80
        
86
81
        if ie.text_size != None:
87
82
            if ie.text_size != fp['size']:
88
 
                bailout("mismatched size for file %r in %r" % (ie.file_id, self._store),
 
83
                raise BzrError("mismatched size for file %r in %r" % (ie.file_id, self._store),
89
84
                        ["inventory expects %d bytes" % ie.text_size,
90
85
                         "file is actually %d bytes" % fp['size'],
91
86
                         "store is probably damaged/corrupt"])
92
87
 
93
88
        if ie.text_sha1 != fp['sha1']:
94
 
            bailout("wrong SHA-1 for file %r in %r" % (ie.file_id, self._store),
 
89
            raise BzrError("wrong SHA-1 for file %r in %r" % (ie.file_id, self._store),
95
90
                    ["inventory expects %s" % ie.text_sha1,
96
91
                     "file is actually %s" % fp['sha1'],
97
92
                     "store is probably damaged/corrupt"])
103
98
        pumpfile(self.get_file(fileid), sys.stdout)
104
99
        
105
100
        
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))
 
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)
131
109
 
132
110
 
133
111
 
157
135
 
158
136
    def get_file_sha1(self, file_id):
159
137
        ie = self._inventory[file_id]
160
 
        return ie.text_sha1
 
138
        if ie.kind == "file":
 
139
            return ie.text_sha1
161
140
 
162
141
    def has_filename(self, filename):
163
142
        return bool(self.inventory.path2id(filename))
179
158
        if False:  # just to make it a generator
180
159
            yield None
181
160
    
 
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
 
182
169
 
183
170
 
184
171
######################################################################
245
232
        if old_name != new_name:
246
233
            yield (old_name, new_name)
247
234
            
 
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