~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tree.py

  • Committer: mbp at sourcefrog
  • Date: 2005-03-19 08:19:38 UTC
  • Revision ID: mbp@sourcefrog.net-20050319081938-596d89f99a644569
use "/usr/bin/env python" for shebang"

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005 Canonical Ltd
 
1
#! /usr/bin/env python
 
2
# -*- coding: UTF-8 -*-
2
3
 
3
4
# This program is free software; you can redistribute it and/or modify
4
5
# it under the terms of the GNU General Public License as published by
17
18
"""Tree classes, representing directory at point in time.
18
19
"""
19
20
 
20
 
import os
21
 
from cStringIO import StringIO
 
21
from sets import Set
 
22
import os.path, os, fnmatch
 
23
 
 
24
from inventory import Inventory
 
25
from trace import mutter, note
 
26
from osutils import pumpfile, compare_files, filesize, quotefn, sha_file, \
 
27
     joinpath, splitpath, appendpath, isdir, isfile, file_kind
 
28
from errors import bailout
 
29
import branch
 
30
from stat import S_ISREG, S_ISDIR, ST_MODE, ST_SIZE
22
31
 
23
32
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 pumpfile, appendpath, fingerprint_file
28
 
 
29
 
 
30
 
exporters = {}
31
 
 
32
 
class Tree(object):
 
33
 
 
34
class Tree:
33
35
    """Abstract file tree.
34
36
 
35
37
    There are several subclasses:
58
60
    def has_id(self, file_id):
59
61
        return self.inventory.has_id(file_id)
60
62
 
61
 
    __contains__ = has_id
62
 
 
63
 
    def __iter__(self):
64
 
        return iter(self.inventory)
 
63
    def id_set(self):
 
64
        """Return set of all ids in this tree."""
 
65
        return self.inventory.id_set()
65
66
 
66
67
    def id2path(self, file_id):
67
68
        return self.inventory.id2path(file_id)
68
69
 
69
70
    def _get_inventory(self):
70
71
        return self._inventory
71
 
    
72
 
    def get_file_by_path(self, path):
73
 
        return self.get_file(self._inventory.path2id(path))
74
72
 
75
73
    inventory = property(_get_inventory,
76
74
                         doc="Inventory of this Tree")
77
75
 
78
76
    def _check_retrieved(self, ie, f):
79
 
        fp = fingerprint_file(f)
80
 
        f.seek(0)
81
 
        
82
 
        if ie.text_size != None:
83
 
            if ie.text_size != fp['size']:
84
 
                raise BzrError("mismatched size for file %r in %r" % (ie.file_id, self._store),
 
77
        # TODO: Test this check by damaging the store?
 
78
        if ie.text_size is not None:
 
79
            fs = filesize(f)
 
80
            if fs != ie.text_size:
 
81
                bailout("mismatched size for file %r in %r" % (ie.file_id, self._store),
85
82
                        ["inventory expects %d bytes" % ie.text_size,
86
 
                         "file is actually %d bytes" % fp['size'],
 
83
                         "file is actually %d bytes" % fs,
87
84
                         "store is probably damaged/corrupt"])
88
85
 
89
 
        if ie.text_sha1 != fp['sha1']:
90
 
            raise BzrError("wrong SHA-1 for file %r in %r" % (ie.file_id, self._store),
 
86
        f_hash = sha_file(f)
 
87
        f.seek(0)
 
88
        if ie.text_sha1 != f_hash:
 
89
            bailout("wrong SHA-1 for file %r in %r" % (ie.file_id, self._store),
91
90
                    ["inventory expects %s" % ie.text_sha1,
92
 
                     "file is actually %s" % fp['sha1'],
 
91
                     "file is actually %s" % f_hash,
93
92
                     "store is probably damaged/corrupt"])
94
93
 
95
94
 
96
 
    def print_file(self, file_id):
97
 
        """Print file with id `file_id` to stdout."""
98
 
        import sys
99
 
        sys.stdout.write(self.get_file_text(file_id))
100
 
        
101
 
        
102
 
    def export(self, dest, format='dir', root=None):
103
 
        """Export this tree."""
104
 
        try:
105
 
            exporter = exporters[format]
106
 
        except KeyError:
107
 
            from bzrlib.errors import BzrCommandError
108
 
            raise BzrCommandError("export format %r not supported" % format)
109
 
        exporter(self, dest, root)
110
 
 
111
 
 
 
95
    def export(self, dest):
 
96
        """Export this tree to a new directory.
 
97
 
 
98
        `dest` should not exist, and will be created holding the
 
99
        contents of this tree.
 
100
 
 
101
        :todo: To handle subdirectories we need to create the
 
102
               directories first.
 
103
 
 
104
        :note: If the export fails, the destination directory will be
 
105
               left in a half-assed state.
 
106
        """
 
107
        os.mkdir(dest)
 
108
        mutter('export version %r' % self)
 
109
        inv = self.inventory
 
110
        for dp, ie in inv.iter_entries():
 
111
            kind = ie.kind
 
112
            fullpath = appendpath(dest, dp)
 
113
            if kind == 'directory':
 
114
                os.mkdir(fullpath)
 
115
            elif kind == 'file':
 
116
                pumpfile(self.get_file(ie.file_id), file(fullpath, 'wb'))
 
117
            else:
 
118
                bailout("don't know how to export {%s} of kind %r", fid, kind)
 
119
            mutter("  export {%s} kind %s to %s" % (ie.file_id, kind, fullpath))
 
120
 
 
121
 
 
122
 
 
123
class WorkingTree(Tree):
 
124
    """Working copy tree.
 
125
 
 
126
    The inventory is held in the `Branch` working-inventory, and the
 
127
    files are in a directory on disk.
 
128
 
 
129
    It is possible for a `WorkingTree` to have a filename which is
 
130
    not listed in the Inventory and vice versa.
 
131
    """
 
132
    def __init__(self, basedir, inv):
 
133
        self._inventory = inv
 
134
        self.basedir = basedir
 
135
        self.path2id = inv.path2id
 
136
 
 
137
    def __repr__(self):
 
138
        return "<%s of %s>" % (self.__class__.__name__,
 
139
                               self.basedir)
 
140
 
 
141
    def _rel(self, filename):
 
142
        return os.path.join(self.basedir, filename)
 
143
 
 
144
    def has_filename(self, filename):
 
145
        return os.path.exists(self._rel(filename))
 
146
 
 
147
    def get_file(self, file_id):
 
148
        return self.get_file_byname(self.id2path(file_id))
 
149
 
 
150
    def get_file_byname(self, filename):
 
151
        return file(self._rel(filename), 'rb')
 
152
 
 
153
    def _get_store_filename(self, file_id):
 
154
        return self._rel(self.id2path(file_id))
 
155
 
 
156
    def has_id(self, file_id):
 
157
        # files that have been deleted are excluded
 
158
        if not self.inventory.has_id(file_id):
 
159
            return False
 
160
        return os.access(self._rel(self.inventory.id2path(file_id)), os.F_OK)
 
161
 
 
162
    def get_file_size(self, file_id):
 
163
        return os.stat(self._get_store_filename(file_id))[ST_SIZE]
 
164
 
 
165
    def get_file_sha1(self, file_id):
 
166
        f = self.get_file(file_id)
 
167
        return sha_file(f)
 
168
 
 
169
 
 
170
    def file_class(self, filename):
 
171
        if self.path2id(filename):
 
172
            return 'V'
 
173
        elif self.is_ignored(filename):
 
174
            return 'I'
 
175
        else:
 
176
            return '?'
 
177
 
 
178
 
 
179
    def file_kind(self, filename):
 
180
        if isfile(self._rel(filename)):
 
181
            return 'file'
 
182
        elif isdir(self._rel(filename)):
 
183
            return 'directory'
 
184
        else:
 
185
            return 'unknown'
 
186
 
 
187
 
 
188
    def list_files(self):
 
189
        """Recursively list all files as (path, class, kind, id).
 
190
 
 
191
        Lists, but does not descend into unversioned directories.
 
192
 
 
193
        This does not include files that have been deleted in this
 
194
        tree.
 
195
 
 
196
        Skips the control directory.
 
197
        """
 
198
        inv = self.inventory
 
199
 
 
200
        def descend(from_dir, from_dir_id, dp):
 
201
            ls = os.listdir(dp)
 
202
            ls.sort()
 
203
            for f in ls:
 
204
                if bzrlib.BZRDIR == f:
 
205
                    continue
 
206
 
 
207
                # path within tree
 
208
                fp = appendpath(from_dir, f)
 
209
 
 
210
                # absolute path
 
211
                fap = appendpath(dp, f)
 
212
                
 
213
                f_ie = inv.get_child(from_dir_id, f)
 
214
                if f_ie:
 
215
                    c = 'V'
 
216
                elif self.is_ignored(fp):
 
217
                    c = 'I'
 
218
                else:
 
219
                    c = '?'
 
220
 
 
221
                fk = file_kind(fap)
 
222
 
 
223
                if f_ie:
 
224
                    if f_ie.kind != fk:
 
225
                        bailout("file %r entered as kind %r id %r, now of kind %r"
 
226
                                % (fap, f_ie.kind, f_ie.file_id, fk))
 
227
 
 
228
                yield fp, c, fk, (f_ie and f_ie.file_id)
 
229
 
 
230
                if fk != 'directory':
 
231
                    continue
 
232
 
 
233
                if c != 'V':
 
234
                    # don't descend unversioned directories
 
235
                    continue
 
236
                
 
237
                for ff in descend(fp, f_ie.file_id, fap):
 
238
                    yield ff
 
239
 
 
240
        for f in descend('', None, self.basedir):
 
241
            yield f
 
242
            
 
243
 
 
244
 
 
245
    def unknowns(self, path='', dir_id=None):
 
246
        """Yield names of unknown files in this WorkingTree.
 
247
 
 
248
        If there are any unknown directories then only the directory is
 
249
        returned, not all its children.  But if there are unknown files
 
250
        under a versioned subdirectory, they are returned.
 
251
 
 
252
        Currently returned depth-first, sorted by name within directories.
 
253
        """
 
254
        for fpath, fclass, fkind, fid in self.list_files():
 
255
            if fclass == '?':
 
256
                yield fpath
 
257
                
 
258
 
 
259
    def ignored_files(self):
 
260
        for fpath, fclass, fkind, fid in self.list_files():
 
261
            if fclass == 'I':
 
262
                yield fpath
 
263
 
 
264
 
 
265
    def get_ignore_list(self):
 
266
        """Return list of ignore patterns."""
 
267
        if self.has_filename(bzrlib.IGNORE_FILENAME):
 
268
            f = self.get_file_byname(bzrlib.IGNORE_FILENAME)
 
269
            return [line.rstrip("\n\r") for line in f.readlines()]
 
270
        else:
 
271
            return bzrlib.DEFAULT_IGNORE
 
272
 
 
273
 
 
274
    def is_ignored(self, filename):
 
275
        """Check whether the filename matches an ignore pattern.
 
276
 
 
277
        Patterns containing '/' need to match the whole path; others
 
278
        match against only the last component."""
 
279
        ## TODO: Take them from a file, not hardcoded
 
280
        ## TODO: Use extended zsh-style globs maybe?
 
281
        ## TODO: Use '**' to match directories?
 
282
        for pat in self.get_ignore_list():
 
283
            if '/' in pat:
 
284
                if fnmatch.fnmatchcase(filename, pat):
 
285
                    return True
 
286
            else:
 
287
                if fnmatch.fnmatchcase(splitpath(filename)[-1], pat):
 
288
                    return True
 
289
        return False
 
290
        
 
291
 
 
292
        
 
293
        
112
294
 
113
295
class RevisionTree(Tree):
114
296
    """Tree viewing a previous revision.
115
297
 
116
298
    File text can be retrieved from the text store.
117
299
 
118
 
    TODO: Some kind of `__repr__` method, but a good one
 
300
    :todo: Some kind of `__repr__` method, but a good one
119
301
           probably means knowing the branch and revision number,
120
302
           or at least passing a description to the constructor.
121
303
    """
122
304
    
123
 
    def __init__(self, weave_store, inv, revision_id):
124
 
        self._weave_store = weave_store
 
305
    def __init__(self, store, inv):
 
306
        self._store = store
125
307
        self._inventory = inv
126
 
        self._revision_id = revision_id
127
 
 
128
 
    def get_weave(self, file_id):
129
 
        return self._weave_store.get_weave(file_id)
130
 
        
131
 
 
132
 
    def get_file_text(self, file_id):
 
308
 
 
309
    def get_file(self, file_id):
133
310
        ie = self._inventory[file_id]
134
 
        weave = self.get_weave(file_id)
135
 
        idx = weave.lookup(ie.text_version)
136
 
        content = weave.get_text(idx)
137
 
        if len(content) != ie.text_size:
138
 
            raise BzrCheckError('mismatched size on revision %s of file %s: '
139
 
                                '%d vs %d bytes'
140
 
                                % (self._revision_id, file_id, len(content),
141
 
                                   ie.text_size))
142
 
        return content
143
 
 
144
 
    def get_file(self, file_id):
145
 
        return StringIO(self.get_file_text(file_id))
 
311
        f = self._store[ie.text_id]
 
312
        mutter("  get fileid{%s} from %r" % (file_id, self))
 
313
        fs = filesize(f)
 
314
        if ie.text_size is None:
 
315
            note("warning: no text size recorded on %r" % ie)
 
316
        self._check_retrieved(ie, f)
 
317
        return f
146
318
 
147
319
    def get_file_size(self, file_id):
148
320
        return self._inventory[file_id].text_size
149
321
 
150
322
    def get_file_sha1(self, file_id):
151
323
        ie = self._inventory[file_id]
152
 
        if ie.kind == "file":
153
 
            return ie.text_sha1
 
324
        return ie.text_sha1
154
325
 
155
326
    def has_filename(self, filename):
156
327
        return bool(self.inventory.path2id(filename))
172
343
        if False:  # just to make it a generator
173
344
            yield None
174
345
    
175
 
    def __contains__(self, file_id):
176
 
        return file_id in self._inventory
177
 
 
178
 
    def get_file_sha1(self, file_id):
179
 
        assert self._inventory[file_id].kind == "root_directory"
180
 
        return None
181
 
 
182
 
 
183
346
 
184
347
 
185
348
######################################################################
237
400
 
238
401
    
239
402
 
240
 
def find_renames(old_inv, new_inv):
241
 
    for file_id in old_inv:
242
 
        if file_id not in new_inv:
243
 
            continue
244
 
        old_name = old_inv.id2path(file_id)
245
 
        new_name = new_inv.id2path(file_id)
246
 
        if old_name != new_name:
247
 
            yield (old_name, new_name)
248
 
            
249
 
 
250
 
 
251
 
######################################################################
252
 
# export
253
 
 
254
 
def dir_exporter(tree, dest, root):
255
 
    """Export this tree to a new directory.
256
 
 
257
 
    `dest` should not exist, and will be created holding the
258
 
    contents of this tree.
259
 
 
260
 
    TODO: To handle subdirectories we need to create the
261
 
           directories first.
262
 
 
263
 
    :note: If the export fails, the destination directory will be
264
 
           left in a half-assed state.
265
 
    """
266
 
    import os
267
 
    os.mkdir(dest)
268
 
    mutter('export version %r' % tree)
269
 
    inv = tree.inventory
270
 
    for dp, ie in inv.iter_entries():
271
 
        kind = ie.kind
272
 
        fullpath = appendpath(dest, dp)
273
 
        if kind == 'directory':
274
 
            os.mkdir(fullpath)
275
 
        elif kind == 'file':
276
 
            pumpfile(tree.get_file(ie.file_id), file(fullpath, 'wb'))
277
 
        else:
278
 
            raise BzrError("don't know how to export {%s} of kind %r" % (ie.file_id, kind))
279
 
        mutter("  export {%s} kind %s to %s" % (ie.file_id, kind, fullpath))
280
 
exporters['dir'] = dir_exporter
281
 
 
282
 
try:
283
 
    import tarfile
284
 
except ImportError:
285
 
    pass
286
 
else:
287
 
    def get_root_name(dest):
288
 
        """Get just the root name for a tarball.
289
 
 
290
 
        >>> get_root_name('mytar.tar')
291
 
        'mytar'
292
 
        >>> get_root_name('mytar.tar.bz2')
293
 
        'mytar'
294
 
        >>> get_root_name('tar.tar.tar.tgz')
295
 
        'tar.tar.tar'
296
 
        >>> get_root_name('bzr-0.0.5.tar.gz')
297
 
        'bzr-0.0.5'
298
 
        >>> get_root_name('a/long/path/mytar.tgz')
299
 
        'mytar'
300
 
        >>> get_root_name('../parent/../dir/other.tbz2')
301
 
        'other'
302
 
        """
303
 
        endings = ['.tar', '.tar.gz', '.tgz', '.tar.bz2', '.tbz2']
304
 
        dest = os.path.basename(dest)
305
 
        for end in endings:
306
 
            if dest.endswith(end):
307
 
                return dest[:-len(end)]
308
 
 
309
 
    def tar_exporter(tree, dest, root, compression=None):
310
 
        """Export this tree to a new tar file.
311
 
 
312
 
        `dest` will be created holding the contents of this tree; if it
313
 
        already exists, it will be clobbered, like with "tar -c".
314
 
        """
315
 
        from time import time
316
 
        now = time()
317
 
        compression = str(compression or '')
318
 
        if root is None:
319
 
            root = get_root_name(dest)
320
 
        try:
321
 
            ball = tarfile.open(dest, 'w:' + compression)
322
 
        except tarfile.CompressionError, e:
323
 
            raise BzrError(str(e))
324
 
        mutter('export version %r' % tree)
325
 
        inv = tree.inventory
326
 
        for dp, ie in inv.iter_entries():
327
 
            mutter("  export {%s} kind %s to %s" % (ie.file_id, ie.kind, dest))
328
 
            item = tarfile.TarInfo(os.path.join(root, dp))
329
 
            # TODO: would be cool to actually set it to the timestamp of the
330
 
            # revision it was last changed
331
 
            item.mtime = now
332
 
            if ie.kind == 'directory':
333
 
                item.type = tarfile.DIRTYPE
334
 
                fileobj = None
335
 
                item.name += '/'
336
 
                item.size = 0
337
 
                item.mode = 0755
338
 
            elif ie.kind == 'file':
339
 
                item.type = tarfile.REGTYPE
340
 
                fileobj = tree.get_file(ie.file_id)
341
 
                item.size = _find_file_size(fileobj)
342
 
                item.mode = 0644
343
 
            else:
344
 
                raise BzrError("don't know how to export {%s} of kind %r" %
345
 
                        (ie.file_id, ie.kind))
346
 
 
347
 
            ball.addfile(item, fileobj)
348
 
        ball.close()
349
 
    exporters['tar'] = tar_exporter
350
 
 
351
 
    def tgz_exporter(tree, dest, root):
352
 
        tar_exporter(tree, dest, root, compression='gz')
353
 
    exporters['tgz'] = tgz_exporter
354
 
 
355
 
    def tbz_exporter(tree, dest, root):
356
 
        tar_exporter(tree, dest, root, compression='bz2')
357
 
    exporters['tbz2'] = tbz_exporter
358
 
 
359
 
 
360
 
def _find_file_size(fileobj):
361
 
    offset = fileobj.tell()
362
 
    try:
363
 
        fileobj.seek(0, 2)
364
 
        size = fileobj.tell()
365
 
    except TypeError:
366
 
        # gzip doesn't accept second argument to seek()
367
 
        fileobj.seek(0)
368
 
        size = 0
369
 
        while True:
370
 
            nread = len(fileobj.read())
371
 
            if nread == 0:
372
 
                break
373
 
            size += nread
374
 
    fileobj.seek(offset)
375
 
    return size