← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tree.py

- stub for revision properties

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tree.py
26
26
from bzrlib.inventory import Inventory
27
27
from bzrlib.osutils import appendpath, fingerprint_file
28
28
 
 
29
 
 
30
exporters = {}
 
31
 
29
32
class Tree(object):
30
33
    """Abstract file tree.
31
34
 
55
58
    def has_id(self, file_id):
56
59
        return self.inventory.has_id(file_id)
57
60
 
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
61
    __contains__ = has_id
64
62
 
65
63
    def __iter__(self):
68
66
    def id2path(self, file_id):
69
67
        return self.inventory.id2path(file_id)
70
68
 
71
 
    def kind(self, file_id):
72
 
        raise NotImplementedError("subclasses must implement kind")
73
 
 
74
69
    def _get_inventory(self):
75
70
        return self._inventory
76
71
    
104
99
        """Print file with id `file_id` to stdout."""
105
100
        import sys
106
101
        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
 
        
 
102
        
 
103
        
 
104
    def export(self, dest, format='dir', root=None):
 
105
        """Export this tree."""
 
106
        try:
 
107
            exporter = exporters[format]
 
108
        except KeyError:
 
109
            from bzrlib.errors import BzrCommandError
 
110
            raise BzrCommandError("export format %r not supported" % format)
 
111
        exporter(self, dest, root)
 
112
 
 
113
 
 
114
 
126
115
class RevisionTree(Tree):
127
116
    """Tree viewing a previous revision.
128
117
 
133
122
           or at least passing a description to the constructor.
134
123
    """
135
124
    
136
 
    def __init__(self, branch, inv, revision_id):
137
 
        self._branch = branch
138
 
        self._weave_store = branch.weave_store
 
125
    def __init__(self, weave_store, inv, revision_id):
 
126
        self._weave_store = weave_store
139
127
        self._inventory = inv
140
128
        self._revision_id = revision_id
141
129
 
142
130
    def get_weave(self, file_id):
 
131
        # FIXME: RevisionTree should be given a branch
 
132
        # not a store, or the store should know the branch.
 
133
        import bzrlib.transactions as transactions
143
134
        return self._weave_store.get_weave(file_id,
144
 
                self._branch.get_transaction())
 
135
            transactions.PassThroughTransaction())
 
136
 
145
137
 
146
138
    def get_file_lines(self, file_id):
147
139
        ie = self._inventory[file_id]
148
140
        weave = self.get_weave(file_id)
149
 
        return weave.get_lines(ie.revision)
 
141
        return weave.get(ie.revision)
 
142
        
150
143
 
151
144
    def get_file_text(self, file_id):
152
145
        return ''.join(self.get_file_lines(file_id))
153
146
 
 
147
 
154
148
    def get_file(self, file_id):
155
149
        return StringIO(self.get_file_text(file_id))
156
150
 
163
157
            return ie.text_sha1
164
158
 
165
159
    def is_executable(self, file_id):
166
 
        ie = self._inventory[file_id]
167
 
        if ie.kind != "file":
168
 
            return None 
169
160
        return self._inventory[file_id].executable
170
161
 
171
162
    def has_filename(self, filename):
180
171
        ie = self._inventory[file_id]
181
172
        return ie.symlink_target;
182
173
 
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()
191
 
 
192
174
 
193
175
class EmptyTree(Tree):
194
176
    def __init__(self):
200
182
    def has_filename(self, filename):
201
183
        return False
202
184
 
203
 
    def kind(self, file_id):
204
 
        assert self._inventory[file_id].kind == "root_directory"
205
 
        return "root_directory"
206
 
 
207
185
    def list_files(self):
208
186
        return iter([])
209
187
    
281
259
            
282
260
 
283
261
 
 
262
######################################################################
 
263
# export
 
264
 
 
265
def dir_exporter(tree, dest, root):
 
266
    """Export this tree to a new directory.
 
267
 
 
268
    `dest` should not exist, and will be created holding the
 
269
    contents of this tree.
 
270
 
 
271
    TODO: To handle subdirectories we need to create the
 
272
           directories first.
 
273
 
 
274
    :note: If the export fails, the destination directory will be
 
275
           left in a half-assed state.
 
276
    """
 
277
    import os
 
278
    os.mkdir(dest)
 
279
    mutter('export version %r' % tree)
 
280
    inv = tree.inventory
 
281
    for dp, ie in inv.iter_entries():
 
282
        ie.put_on_disk(dest, dp, tree)
 
283
 
 
284
exporters['dir'] = dir_exporter
 
285
 
 
286
try:
 
287
    import tarfile
 
288
except ImportError:
 
289
    pass
 
290
else:
 
291
    def get_root_name(dest):
 
292
        """Get just the root name for a tarball.
 
293
 
 
294
        >>> get_root_name('mytar.tar')
 
295
        'mytar'
 
296
        >>> get_root_name('mytar.tar.bz2')
 
297
        'mytar'
 
298
        >>> get_root_name('tar.tar.tar.tgz')
 
299
        'tar.tar.tar'
 
300
        >>> get_root_name('bzr-0.0.5.tar.gz')
 
301
        'bzr-0.0.5'
 
302
        >>> get_root_name('a/long/path/mytar.tgz')
 
303
        'mytar'
 
304
        >>> get_root_name('../parent/../dir/other.tbz2')
 
305
        'other'
 
306
        """
 
307
        endings = ['.tar', '.tar.gz', '.tgz', '.tar.bz2', '.tbz2']
 
308
        dest = os.path.basename(dest)
 
309
        for end in endings:
 
310
            if dest.endswith(end):
 
311
                return dest[:-len(end)]
 
312
 
 
313
    def tar_exporter(tree, dest, root, compression=None):
 
314
        """Export this tree to a new tar file.
 
315
 
 
316
        `dest` will be created holding the contents of this tree; if it
 
317
        already exists, it will be clobbered, like with "tar -c".
 
318
        """
 
319
        from time import time
 
320
        now = time()
 
321
        compression = str(compression or '')
 
322
        if root is None:
 
323
            root = get_root_name(dest)
 
324
        try:
 
325
            ball = tarfile.open(dest, 'w:' + compression)
 
326
        except tarfile.CompressionError, e:
 
327
            raise BzrError(str(e))
 
328
        mutter('export version %r' % tree)
 
329
        inv = tree.inventory
 
330
        for dp, ie in inv.iter_entries():
 
331
            mutter("  export {%s} kind %s to %s" % (ie.file_id, ie.kind, dest))
 
332
            item, fileobj = ie.get_tar_item(root, dp, now, tree)
 
333
            ball.addfile(item, fileobj)
 
334
        ball.close()
 
335
 
 
336
    exporters['tar'] = tar_exporter
 
337
 
 
338
    def tgz_exporter(tree, dest, root):
 
339
        tar_exporter(tree, dest, root, compression='gz')
 
340
    exporters['tgz'] = tgz_exporter
 
341
 
 
342
    def tbz_exporter(tree, dest, root):
 
343
        tar_exporter(tree, dest, root, compression='bz2')
 
344
    exporters['tbz2'] = tbz_exporter