← 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-11 06:20:05 UTC
  • Revision ID: mbp@sourcefrog.net-20050511062005-297af3451635dae0
- Don't lose first line of command help!

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 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:
58
63
 
59
64
    __contains__ = has_id
60
65
 
 
66
    def id_set(self):
 
67
        """Return set of all ids in this tree."""
 
68
        return self.inventory.id_set()
 
69
 
61
70
    def __iter__(self):
62
71
        return iter(self.inventory)
63
72
 
66
75
 
67
76
    def _get_inventory(self):
68
77
        return self._inventory
69
 
    
70
 
    def get_file_by_path(self, path):
71
 
        return self.get_file(self._inventory.path2id(path))
72
78
 
73
79
    inventory = property(_get_inventory,
74
80
                         doc="Inventory of this Tree")
79
85
        
80
86
        if ie.text_size != None:
81
87
            if ie.text_size != fp['size']:
82
 
                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),
83
89
                        ["inventory expects %d bytes" % ie.text_size,
84
90
                         "file is actually %d bytes" % fp['size'],
85
91
                         "store is probably damaged/corrupt"])
86
92
 
87
93
        if ie.text_sha1 != fp['sha1']:
88
 
            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),
89
95
                    ["inventory expects %s" % ie.text_sha1,
90
96
                     "file is actually %s" % fp['sha1'],
91
97
                     "store is probably damaged/corrupt"])
97
103
        pumpfile(self.get_file(fileid), sys.stdout)
98
104
        
99
105
        
100
 
    def export(self, dest, format='dir', root=None):
101
 
        """Export this tree."""
102
 
        try:
103
 
            exporter = exporters[format]
104
 
        except KeyError:
105
 
            from bzrlib.errors import BzrCommandError
106
 
            raise BzrCommandError("export format %r not supported" % format)
107
 
        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))
108
131
 
109
132
 
110
133
 
146
169
 
147
170
 
148
171
class EmptyTree(Tree):
149
 
    def __init__(self, root_id):
150
 
        from bzrlib.inventory import Inventory
151
 
        self._inventory = Inventory(root_id)
 
172
    def __init__(self):
 
173
        self._inventory = Inventory()
152
174
 
153
175
    def has_filename(self, filename):
154
176
        return False
223
245
        if old_name != new_name:
224
246
            yield (old_name, new_name)
225
247
            
226
 
 
227
 
 
228
 
######################################################################
229
 
# export
230
 
 
231
 
def dir_exporter(tree, dest, root):
232
 
    """Export this tree to a new directory.
233
 
 
234
 
    `dest` should not exist, and will be created holding the
235
 
    contents of this tree.
236
 
 
237
 
    TODO: To handle subdirectories we need to create the
238
 
           directories first.
239
 
 
240
 
    :note: If the export fails, the destination directory will be
241
 
           left in a half-assed state.
242
 
    """
243
 
    import os
244
 
    os.mkdir(dest)
245
 
    mutter('export version %r' % tree)
246
 
    inv = tree.inventory
247
 
    for dp, ie in inv.iter_entries():
248
 
        kind = ie.kind
249
 
        fullpath = appendpath(dest, dp)
250
 
        if kind == 'directory':
251
 
            os.mkdir(fullpath)
252
 
        elif kind == 'file':
253
 
            pumpfile(tree.get_file(ie.file_id), file(fullpath, 'wb'))
254
 
        else:
255
 
            raise BzrError("don't know how to export {%s} of kind %r" % (ie.file_id, kind))
256
 
        mutter("  export {%s} kind %s to %s" % (ie.file_id, kind, fullpath))
257
 
exporters['dir'] = dir_exporter
258
 
 
259
 
try:
260
 
    import tarfile
261
 
except ImportError:
262
 
    pass
263
 
else:
264
 
    def get_root_name(dest):
265
 
        """Get just the root name for a tarball.
266
 
 
267
 
        >>> get_root_name('mytar.tar')
268
 
        'mytar'
269
 
        >>> get_root_name('mytar.tar.bz2')
270
 
        'mytar'
271
 
        >>> get_root_name('tar.tar.tar.tgz')
272
 
        'tar.tar.tar'
273
 
        >>> get_root_name('bzr-0.0.5.tar.gz')
274
 
        'bzr-0.0.5'
275
 
        >>> get_root_name('a/long/path/mytar.tgz')
276
 
        'mytar'
277
 
        >>> get_root_name('../parent/../dir/other.tbz2')
278
 
        'other'
279
 
        """
280
 
        endings = ['.tar', '.tar.gz', '.tgz', '.tar.bz2', '.tbz2']
281
 
        dest = os.path.basename(dest)
282
 
        for end in endings:
283
 
            if dest.endswith(end):
284
 
                return dest[:-len(end)]
285
 
 
286
 
    def tar_exporter(tree, dest, root, compression=None):
287
 
        """Export this tree to a new tar file.
288
 
 
289
 
        `dest` will be created holding the contents of this tree; if it
290
 
        already exists, it will be clobbered, like with "tar -c".
291
 
        """
292
 
        from time import time
293
 
        now = time()
294
 
        compression = str(compression or '')
295
 
        if root is None:
296
 
            root = get_root_name(dest)
297
 
        try:
298
 
            ball = tarfile.open(dest, 'w:' + compression)
299
 
        except tarfile.CompressionError, e:
300
 
            raise BzrError(str(e))
301
 
        mutter('export version %r' % tree)
302
 
        inv = tree.inventory
303
 
        for dp, ie in inv.iter_entries():
304
 
            mutter("  export {%s} kind %s to %s" % (ie.file_id, ie.kind, dest))
305
 
            item = tarfile.TarInfo(os.path.join(root, dp))
306
 
            # TODO: would be cool to actually set it to the timestamp of the
307
 
            # revision it was last changed
308
 
            item.mtime = now
309
 
            if ie.kind == 'directory':
310
 
                item.type = tarfile.DIRTYPE
311
 
                fileobj = None
312
 
                item.name += '/'
313
 
                item.size = 0
314
 
                item.mode = 0755
315
 
            elif ie.kind == 'file':
316
 
                item.type = tarfile.REGTYPE
317
 
                fileobj = tree.get_file(ie.file_id)
318
 
                item.size = _find_file_size(fileobj)
319
 
                item.mode = 0644
320
 
            else:
321
 
                raise BzrError("don't know how to export {%s} of kind %r" %
322
 
                        (ie.file_id, ie.kind))
323
 
 
324
 
            ball.addfile(item, fileobj)
325
 
        ball.close()
326
 
    exporters['tar'] = tar_exporter
327
 
 
328
 
    def tgz_exporter(tree, dest, root):
329
 
        tar_exporter(tree, dest, root, compression='gz')
330
 
    exporters['tgz'] = tgz_exporter
331
 
 
332
 
    def tbz_exporter(tree, dest, root):
333
 
        tar_exporter(tree, dest, root, compression='bz2')
334
 
    exporters['tbz2'] = tbz_exporter
335
 
 
336
 
 
337
 
def _find_file_size(fileobj):
338
 
    offset = fileobj.tell()
339
 
    try:
340
 
        fileobj.seek(0, 2)
341
 
        size = fileobj.tell()
342
 
    except TypeError:
343
 
        # gzip doesn't accept second argument to seek()
344
 
        fileobj.seek(0)
345
 
        size = 0
346
 
        while True:
347
 
            nread = len(fileobj.read())
348
 
            if nread == 0:
349
 
                break
350
 
            size += nread
351
 
    fileobj.seek(offset)
352
 
    return size