← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tree.py

merge merge tweaks from aaron, which includes latest .dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tree.py
18
18
"""
19
19
 
20
20
import os
21
 
from cStringIO import StringIO
22
21
 
23
22
import bzrlib
24
23
from bzrlib.trace import mutter, note
25
 
from bzrlib.errors import BzrError, BzrCheckError
 
24
from bzrlib.errors import BzrError
26
25
from bzrlib.inventory import Inventory
27
 
from bzrlib.osutils import appendpath, fingerprint_file
 
26
from bzrlib.osutils import pumpfile, appendpath, fingerprint_file
 
27
 
 
28
 
 
29
exporters = {}
28
30
 
29
31
class Tree(object):
30
32
    """Abstract file tree.
55
57
    def has_id(self, file_id):
56
58
        return self.inventory.has_id(file_id)
57
59
 
58
 
    def has_or_had_id(self, file_id):
59
 
        if file_id == self.inventory.root.file_id:
60
 
            return True
61
 
        return self.inventory.has_id(file_id)
62
 
 
63
60
    __contains__ = has_id
64
61
 
65
62
    def __iter__(self):
68
65
    def id2path(self, file_id):
69
66
        return self.inventory.id2path(file_id)
70
67
 
71
 
    def kind(self, file_id):
72
 
        raise NotImplementedError("subclasses must implement kind")
73
 
 
74
68
    def _get_inventory(self):
75
69
        return self._inventory
76
70
    
81
75
                         doc="Inventory of this Tree")
82
76
 
83
77
    def _check_retrieved(self, ie, f):
84
 
        if not __debug__:
85
 
            return  
86
78
        fp = fingerprint_file(f)
87
79
        f.seek(0)
88
80
        
100
92
                     "store is probably damaged/corrupt"])
101
93
 
102
94
 
103
 
    def print_file(self, file_id):
104
 
        """Print file with id `file_id` to stdout."""
 
95
    def print_file(self, fileid):
 
96
        """Print file with id `fileid` to stdout."""
105
97
        import sys
106
 
        sys.stdout.write(self.get_file_text(file_id))
107
 
 
108
 
    def lock_read(self):
109
 
        pass
110
 
 
111
 
    def unlock(self):
112
 
        pass
113
 
 
114
 
    def filter_unversioned_files(self, paths):
115
 
        """Filter out paths that are not versioned.
116
 
 
117
 
        :return: set of paths.
118
 
        """
119
 
        # NB: we specifically *don't* call self.has_filename, because for
120
 
        # WorkingTrees that can indicate files that exist on disk but that 
121
 
        # are not versioned.
122
 
        pred = self.inventory.has_filename
123
 
        return set((p for p in paths if not pred(p)))
124
 
        
125
 
        
 
98
        pumpfile(self.get_file(fileid), sys.stdout)
 
99
        
 
100
        
 
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)
 
109
 
 
110
 
 
111
 
126
112
class RevisionTree(Tree):
127
113
    """Tree viewing a previous revision.
128
114
 
133
119
           or at least passing a description to the constructor.
134
120
    """
135
121
    
136
 
    def __init__(self, branch, inv, revision_id):
137
 
        self._branch = branch
138
 
        self._weave_store = branch.weave_store
 
122
    def __init__(self, store, inv):
 
123
        self._store = store
139
124
        self._inventory = inv
140
 
        self._revision_id = revision_id
141
 
 
142
 
    def get_weave(self, file_id):
143
 
        return self._weave_store.get_weave(file_id,
144
 
                self._branch.get_transaction())
145
 
 
146
 
    def get_file_lines(self, file_id):
147
 
        ie = self._inventory[file_id]
148
 
        weave = self.get_weave(file_id)
149
 
        return weave.get_lines(ie.revision)
150
 
 
151
 
    def get_file_text(self, file_id):
152
 
        return ''.join(self.get_file_lines(file_id))
153
125
 
154
126
    def get_file(self, file_id):
155
 
        return StringIO(self.get_file_text(file_id))
 
127
        ie = self._inventory[file_id]
 
128
        f = self._store[ie.text_id]
 
129
        mutter("  get fileid{%s} from %r" % (file_id, self))
 
130
        self._check_retrieved(ie, f)
 
131
        return f
156
132
 
157
133
    def get_file_size(self, file_id):
158
134
        return self._inventory[file_id].text_size
162
138
        if ie.kind == "file":
163
139
            return ie.text_sha1
164
140
 
165
 
    def is_executable(self, file_id):
166
 
        ie = self._inventory[file_id]
167
 
        if ie.kind != "file":
168
 
            return None 
169
 
        return self._inventory[file_id].executable
170
 
 
171
141
    def has_filename(self, filename):
172
142
        return bool(self.inventory.path2id(filename))
173
143
 
174
144
    def list_files(self):
175
145
        # The only files returned by this are those from the version
176
146
        for path, entry in self.inventory.iter_entries():
177
 
            yield path, 'V', entry.kind, entry.file_id, entry
178
 
 
179
 
    def get_symlink_target(self, file_id):
180
 
        ie = self._inventory[file_id]
181
 
        return ie.symlink_target;
182
 
 
183
 
    def kind(self, file_id):
184
 
        return self._inventory[file_id].kind
185
 
 
186
 
    def lock_read(self):
187
 
        self._branch.lock_read()
188
 
 
189
 
    def unlock(self):
190
 
        self._branch.unlock()
 
147
            yield path, 'V', entry.kind, entry.file_id
191
148
 
192
149
 
193
150
class EmptyTree(Tree):
194
151
    def __init__(self):
195
152
        self._inventory = Inventory()
196
153
 
197
 
    def get_symlink_target(self, file_id):
198
 
        return None
199
 
 
200
154
    def has_filename(self, filename):
201
155
        return False
202
156
 
203
 
    def kind(self, file_id):
204
 
        assert self._inventory[file_id].kind == "root_directory"
205
 
        return "root_directory"
206
 
 
207
157
    def list_files(self):
208
 
        return iter([])
 
158
        if False:  # just to make it a generator
 
159
            yield None
209
160
    
210
161
    def __contains__(self, file_id):
211
162
        return file_id in self._inventory
215
166
        return None
216
167
 
217
168
 
 
169
 
 
170
 
218
171
######################################################################
219
172
# diff
220
173
 
281
234
            
282
235
 
283
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