/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

  • Committer: Martin Pool
  • Date: 2005-07-08 07:09:32 UTC
  • Revision ID: mbp@sourcefrog.net-20050708070932-4cc012f68281e3e5
doc

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