← 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-09-12 09:00:11 UTC
  • Revision ID: mbp@sourcefrog.net-20050912090011-97e81abfaeeb8948
- fix bug in Inventory.copy() 
  
  must copy inventory top-down so that directories are added before
  their children

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