/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tree.py

Update news and readme

- better explanation of dependencies

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tree.py
 
1
# Copyright (C) 2005 Canonical Ltd
 
2
 
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
 
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
 
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
"""Tree classes, representing directory at point in time.
 
18
"""
 
19
 
 
20
import os
 
21
from cStringIO import StringIO
 
22
 
 
23
import bzrlib
 
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 appendpath, fingerprint_file
 
28
 
 
29
 
 
30
exporters = {}
 
31
 
 
32
class Tree(object):
 
33
    """Abstract file tree.
 
34
 
 
35
    There are several subclasses:
 
36
    
 
37
    * `WorkingTree` exists as files on disk editable by the user.
 
38
 
 
39
    * `RevisionTree` is a tree as recorded at some point in the past.
 
40
 
 
41
    * `EmptyTree`
 
42
 
 
43
    Trees contain an `Inventory` object, and also know how to retrieve
 
44
    file texts mentioned in the inventory, either from a working
 
45
    directory or from a store.
 
46
 
 
47
    It is possible for trees to contain files that are not described
 
48
    in their inventory or vice versa; for this use `filenames()`.
 
49
 
 
50
    Trees can be compared, etc, regardless of whether they are working
 
51
    trees or versioned trees.
 
52
    """
 
53
    
 
54
    def has_filename(self, filename):
 
55
        """True if the tree has given filename."""
 
56
        raise NotImplementedError()
 
57
 
 
58
    def has_id(self, file_id):
 
59
        return self.inventory.has_id(file_id)
 
60
 
 
61
    def has_or_had_id(self, file_id):
 
62
        if file_id == self.inventory.root.file_id:
 
63
            return True
 
64
        return self.inventory.has_id(file_id)
 
65
 
 
66
    __contains__ = has_id
 
67
 
 
68
    def __iter__(self):
 
69
        return iter(self.inventory)
 
70
 
 
71
    def id2path(self, file_id):
 
72
        return self.inventory.id2path(file_id)
 
73
 
 
74
    def _get_inventory(self):
 
75
        return self._inventory
 
76
    
 
77
    def get_file_by_path(self, path):
 
78
        return self.get_file(self._inventory.path2id(path))
 
79
 
 
80
    inventory = property(_get_inventory,
 
81
                         doc="Inventory of this Tree")
 
82
 
 
83
    def _check_retrieved(self, ie, f):
 
84
        if not __debug__:
 
85
            return  
 
86
        fp = fingerprint_file(f)
 
87
        f.seek(0)
 
88
        
 
89
        if ie.text_size != None:
 
90
            if ie.text_size != fp['size']:
 
91
                raise BzrError("mismatched size for file %r in %r" % (ie.file_id, self._store),
 
92
                        ["inventory expects %d bytes" % ie.text_size,
 
93
                         "file is actually %d bytes" % fp['size'],
 
94
                         "store is probably damaged/corrupt"])
 
95
 
 
96
        if ie.text_sha1 != fp['sha1']:
 
97
            raise BzrError("wrong SHA-1 for file %r in %r" % (ie.file_id, self._store),
 
98
                    ["inventory expects %s" % ie.text_sha1,
 
99
                     "file is actually %s" % fp['sha1'],
 
100
                     "store is probably damaged/corrupt"])
 
101
 
 
102
 
 
103
    def print_file(self, file_id):
 
104
        """Print file with id `file_id` to stdout."""
 
105
        import sys
 
106
        sys.stdout.write(self.get_file_text(file_id))
 
107
        
 
108
        
 
109
    def export(self, dest, format='dir', root=None):
 
110
        """Export this tree."""
 
111
        try:
 
112
            exporter = exporters[format]
 
113
        except KeyError:
 
114
            from bzrlib.errors import BzrCommandError
 
115
            raise BzrCommandError("export format %r not supported" % format)
 
116
        exporter(self, dest, root)
 
117
 
 
118
 
 
119
 
 
120
class RevisionTree(Tree):
 
121
    """Tree viewing a previous revision.
 
122
 
 
123
    File text can be retrieved from the text store.
 
124
 
 
125
    TODO: Some kind of `__repr__` method, but a good one
 
126
           probably means knowing the branch and revision number,
 
127
           or at least passing a description to the constructor.
 
128
    """
 
129
    
 
130
    def __init__(self, weave_store, inv, revision_id):
 
131
        self._weave_store = weave_store
 
132
        self._inventory = inv
 
133
        self._revision_id = revision_id
 
134
 
 
135
    def get_weave(self, file_id):
 
136
        # FIXME: RevisionTree should be given a branch
 
137
        # not a store, or the store should know the branch.
 
138
        import bzrlib.transactions as transactions
 
139
        return self._weave_store.get_weave(file_id,
 
140
            transactions.PassThroughTransaction())
 
141
 
 
142
 
 
143
    def get_file_lines(self, file_id):
 
144
        ie = self._inventory[file_id]
 
145
        weave = self.get_weave(file_id)
 
146
        return weave.get(ie.revision)
 
147
        
 
148
 
 
149
    def get_file_text(self, file_id):
 
150
        return ''.join(self.get_file_lines(file_id))
 
151
 
 
152
 
 
153
    def get_file(self, file_id):
 
154
        return StringIO(self.get_file_text(file_id))
 
155
 
 
156
    def get_file_size(self, file_id):
 
157
        return self._inventory[file_id].text_size
 
158
 
 
159
    def get_file_sha1(self, file_id):
 
160
        ie = self._inventory[file_id]
 
161
        if ie.kind == "file":
 
162
            return ie.text_sha1
 
163
 
 
164
    def is_executable(self, file_id):
 
165
        ie = self._inventory[file_id]
 
166
        if ie.kind != "file":
 
167
            return None 
 
168
        return self._inventory[file_id].executable
 
169
 
 
170
    def has_filename(self, filename):
 
171
        return bool(self.inventory.path2id(filename))
 
172
 
 
173
    def list_files(self):
 
174
        # The only files returned by this are those from the version
 
175
        for path, entry in self.inventory.iter_entries():
 
176
            yield path, 'V', entry.kind, entry.file_id, entry
 
177
 
 
178
    def get_symlink_target(self, file_id):
 
179
        ie = self._inventory[file_id]
 
180
        return ie.symlink_target;
 
181
 
 
182
    def kind(self, file_id):
 
183
        return self._inventory[file_id].kind
 
184
 
 
185
class EmptyTree(Tree):
 
186
    def __init__(self):
 
187
        self._inventory = Inventory()
 
188
 
 
189
    def get_symlink_target(self, file_id):
 
190
        return None
 
191
 
 
192
    def has_filename(self, filename):
 
193
        return False
 
194
 
 
195
    def list_files(self):
 
196
        return iter([])
 
197
    
 
198
    def __contains__(self, file_id):
 
199
        return file_id in self._inventory
 
200
 
 
201
    def get_file_sha1(self, file_id):
 
202
        assert self._inventory[file_id].kind == "root_directory"
 
203
        return None
 
204
 
 
205
 
 
206
######################################################################
 
207
# diff
 
208
 
 
209
# TODO: Merge these two functions into a single one that can operate
 
210
# on either a whole tree or a set of files.
 
211
 
 
212
# TODO: Return the diff in order by filename, not by category or in
 
213
# random order.  Can probably be done by lock-stepping through the
 
214
# filenames from both trees.
 
215
 
 
216
 
 
217
def file_status(filename, old_tree, new_tree):
 
218
    """Return single-letter status, old and new names for a file.
 
219
 
 
220
    The complexity here is in deciding how to represent renames;
 
221
    many complex cases are possible.
 
222
    """
 
223
    old_inv = old_tree.inventory
 
224
    new_inv = new_tree.inventory
 
225
    new_id = new_inv.path2id(filename)
 
226
    old_id = old_inv.path2id(filename)
 
227
 
 
228
    if not new_id and not old_id:
 
229
        # easy: doesn't exist in either; not versioned at all
 
230
        if new_tree.is_ignored(filename):
 
231
            return 'I', None, None
 
232
        else:
 
233
            return '?', None, None
 
234
    elif new_id:
 
235
        # There is now a file of this name, great.
 
236
        pass
 
237
    else:
 
238
        # There is no longer a file of this name, but we can describe
 
239
        # what happened to the file that used to have
 
240
        # this name.  There are two possibilities: either it was
 
241
        # deleted entirely, or renamed.
 
242
        assert old_id
 
243
        if new_inv.has_id(old_id):
 
244
            return 'X', old_inv.id2path(old_id), new_inv.id2path(old_id)
 
245
        else:
 
246
            return 'D', old_inv.id2path(old_id), None
 
247
 
 
248
    # if the file_id is new in this revision, it is added
 
249
    if new_id and not old_inv.has_id(new_id):
 
250
        return 'A'
 
251
 
 
252
    # if there used to be a file of this name, but that ID has now
 
253
    # disappeared, it is deleted
 
254
    if old_id and not new_inv.has_id(old_id):
 
255
        return 'D'
 
256
 
 
257
    return 'wtf?'
 
258
 
 
259
    
 
260
 
 
261
def find_renames(old_inv, new_inv):
 
262
    for file_id in old_inv:
 
263
        if file_id not in new_inv:
 
264
            continue
 
265
        old_name = old_inv.id2path(file_id)
 
266
        new_name = new_inv.id2path(file_id)
 
267
        if old_name != new_name:
 
268
            yield (old_name, new_name)
 
269
            
 
270
 
 
271
 
 
272
######################################################################
 
273
# export
 
274
 
 
275
def dir_exporter(tree, dest, root):
 
276
    """Export this tree to a new directory.
 
277
 
 
278
    `dest` should not exist, and will be created holding the
 
279
    contents of this tree.
 
280
 
 
281
    TODO: To handle subdirectories we need to create the
 
282
           directories first.
 
283
 
 
284
    :note: If the export fails, the destination directory will be
 
285
           left in a half-assed state.
 
286
    """
 
287
    import os
 
288
    os.mkdir(dest)
 
289
    mutter('export version %r' % tree)
 
290
    inv = tree.inventory
 
291
    for dp, ie in inv.iter_entries():
 
292
        ie.put_on_disk(dest, dp, tree)
 
293
 
 
294
exporters['dir'] = dir_exporter
 
295
 
 
296
try:
 
297
    import tarfile
 
298
except ImportError:
 
299
    pass
 
300
else:
 
301
    def get_root_name(dest):
 
302
        """Get just the root name for a tarball.
 
303
 
 
304
        >>> get_root_name('mytar.tar')
 
305
        'mytar'
 
306
        >>> get_root_name('mytar.tar.bz2')
 
307
        'mytar'
 
308
        >>> get_root_name('tar.tar.tar.tgz')
 
309
        'tar.tar.tar'
 
310
        >>> get_root_name('bzr-0.0.5.tar.gz')
 
311
        'bzr-0.0.5'
 
312
        >>> get_root_name('a/long/path/mytar.tgz')
 
313
        'mytar'
 
314
        >>> get_root_name('../parent/../dir/other.tbz2')
 
315
        'other'
 
316
        """
 
317
        endings = ['.tar', '.tar.gz', '.tgz', '.tar.bz2', '.tbz2']
 
318
        dest = os.path.basename(dest)
 
319
        for end in endings:
 
320
            if dest.endswith(end):
 
321
                return dest[:-len(end)]
 
322
 
 
323
    def tar_exporter(tree, dest, root, compression=None):
 
324
        """Export this tree to a new tar file.
 
325
 
 
326
        `dest` will be created holding the contents of this tree; if it
 
327
        already exists, it will be clobbered, like with "tar -c".
 
328
        """
 
329
        from time import time
 
330
        now = time()
 
331
        compression = str(compression or '')
 
332
        if root is None:
 
333
            root = get_root_name(dest)
 
334
        try:
 
335
            ball = tarfile.open(dest, 'w:' + compression)
 
336
        except tarfile.CompressionError, e:
 
337
            raise BzrError(str(e))
 
338
        mutter('export version %r' % tree)
 
339
        inv = tree.inventory
 
340
        for dp, ie in inv.iter_entries():
 
341
            mutter("  export {%s} kind %s to %s" % (ie.file_id, ie.kind, dest))
 
342
            item, fileobj = ie.get_tar_item(root, dp, now, tree)
 
343
            ball.addfile(item, fileobj)
 
344
        ball.close()
 
345
 
 
346
    exporters['tar'] = tar_exporter
 
347
 
 
348
    def tgz_exporter(tree, dest, root):
 
349
        tar_exporter(tree, dest, root, compression='gz')
 
350
    exporters['tgz'] = tgz_exporter
 
351
 
 
352
    def tbz_exporter(tree, dest, root):
 
353
        tar_exporter(tree, dest, root, compression='bz2')
 
354
    exporters['tbz2'] = tbz_exporter