/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

Fix formatting, remove catch-all for exceptions when opening local repositories.

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 sets import Set
21
 
import os.path, os, fnmatch
22
 
 
23
 
from inventory import Inventory
24
 
from trace import mutter, note
25
 
from osutils import pumpfile, compare_files, filesize, quotefn, sha_file, \
26
 
     joinpath, splitpath, appendpath, isdir, isfile, file_kind, fingerprint_file
27
 
from errors import bailout
28
 
import branch
29
 
from stat import S_ISREG, S_ISDIR, ST_MODE, ST_SIZE
30
 
 
31
 
import bzrlib
32
 
 
33
 
class Tree:
34
 
    """Abstract file tree.
35
 
 
36
 
    There are several subclasses:
37
 
    
38
 
    * `WorkingTree` exists as files on disk editable by the user.
39
 
 
40
 
    * `RevisionTree` is a tree as recorded at some point in the past.
41
 
 
42
 
    * `EmptyTree`
43
 
 
44
 
    Trees contain an `Inventory` object, and also know how to retrieve
45
 
    file texts mentioned in the inventory, either from a working
46
 
    directory or from a store.
47
 
 
48
 
    It is possible for trees to contain files that are not described
49
 
    in their inventory or vice versa; for this use `filenames()`.
50
 
 
51
 
    Trees can be compared, etc, regardless of whether they are working
52
 
    trees or versioned trees.
53
 
    """
54
 
    
55
 
    def has_filename(self, filename):
56
 
        """True if the tree has given filename."""
57
 
        raise NotImplementedError()
58
 
 
59
 
    def has_id(self, file_id):
60
 
        return self.inventory.has_id(file_id)
61
 
 
62
 
    def id_set(self):
63
 
        """Return set of all ids in this tree."""
64
 
        return self.inventory.id_set()
65
 
 
66
 
    def id2path(self, file_id):
67
 
        return self.inventory.id2path(file_id)
68
 
 
69
 
    def _get_inventory(self):
70
 
        return self._inventory
71
 
 
72
 
    inventory = property(_get_inventory,
73
 
                         doc="Inventory of this Tree")
74
 
 
75
 
    def _check_retrieved(self, ie, f):
76
 
        fp = fingerprint_file(f)
77
 
        f.seek(0)
78
 
        
79
 
        if ie.text_size is not None:
80
 
            if ie.text_size != fp['size']:
81
 
                bailout("mismatched size for file %r in %r" % (ie.file_id, self._store),
82
 
                        ["inventory expects %d bytes" % ie.text_size,
83
 
                         "file is actually %d bytes" % fp['size'],
84
 
                         "store is probably damaged/corrupt"])
85
 
 
86
 
        if ie.text_sha1 != fp['sha1']:
87
 
            bailout("wrong SHA-1 for file %r in %r" % (ie.file_id, self._store),
88
 
                    ["inventory expects %s" % ie.text_sha1,
89
 
                     "file is actually %s" % fp['sha1'],
90
 
                     "store is probably damaged/corrupt"])
91
 
 
92
 
 
93
 
    def export(self, dest):
94
 
        """Export this tree to a new directory.
95
 
 
96
 
        `dest` should not exist, and will be created holding the
97
 
        contents of this tree.
98
 
 
99
 
        :todo: To handle subdirectories we need to create the
100
 
               directories first.
101
 
 
102
 
        :note: If the export fails, the destination directory will be
103
 
               left in a half-assed state.
104
 
        """
105
 
        os.mkdir(dest)
106
 
        mutter('export version %r' % self)
107
 
        inv = self.inventory
108
 
        for dp, ie in inv.iter_entries():
109
 
            kind = ie.kind
110
 
            fullpath = appendpath(dest, dp)
111
 
            if kind == 'directory':
112
 
                os.mkdir(fullpath)
113
 
            elif kind == 'file':
114
 
                pumpfile(self.get_file(ie.file_id), file(fullpath, 'wb'))
115
 
            else:
116
 
                bailout("don't know how to export {%s} of kind %r", fid, kind)
117
 
            mutter("  export {%s} kind %s to %s" % (ie.file_id, kind, fullpath))
118
 
 
119
 
 
120
 
 
121
 
class WorkingTree(Tree):
122
 
    """Working copy tree.
123
 
 
124
 
    The inventory is held in the `Branch` working-inventory, and the
125
 
    files are in a directory on disk.
126
 
 
127
 
    It is possible for a `WorkingTree` to have a filename which is
128
 
    not listed in the Inventory and vice versa.
129
 
    """
130
 
    def __init__(self, basedir, inv):
131
 
        self._inventory = inv
132
 
        self.basedir = basedir
133
 
        self.path2id = inv.path2id
134
 
 
135
 
    def __repr__(self):
136
 
        return "<%s of %s>" % (self.__class__.__name__,
137
 
                               self.basedir)
138
 
 
139
 
    def abspath(self, filename):
140
 
        return os.path.join(self.basedir, filename)
141
 
 
142
 
    def has_filename(self, filename):
143
 
        return os.path.exists(self.abspath(filename))
144
 
 
145
 
    def get_file(self, file_id):
146
 
        return self.get_file_byname(self.id2path(file_id))
147
 
 
148
 
    def get_file_byname(self, filename):
149
 
        return file(self.abspath(filename), 'rb')
150
 
 
151
 
    def _get_store_filename(self, file_id):
152
 
        return self.abspath(self.id2path(file_id))
153
 
 
154
 
    def has_id(self, file_id):
155
 
        # files that have been deleted are excluded
156
 
        if not self.inventory.has_id(file_id):
157
 
            return False
158
 
        return os.access(self.abspath(self.inventory.id2path(file_id)), os.F_OK)
159
 
 
160
 
    def get_file_size(self, file_id):
161
 
        return os.stat(self._get_store_filename(file_id))[ST_SIZE]
162
 
 
163
 
    def get_file_sha1(self, file_id):
164
 
        f = self.get_file(file_id)
165
 
        return sha_file(f)
166
 
 
167
 
 
168
 
    def file_class(self, filename):
169
 
        if self.path2id(filename):
170
 
            return 'V'
171
 
        elif self.is_ignored(filename):
172
 
            return 'I'
173
 
        else:
174
 
            return '?'
175
 
 
176
 
 
177
 
    def list_files(self):
178
 
        """Recursively list all files as (path, class, kind, id).
179
 
 
180
 
        Lists, but does not descend into unversioned directories.
181
 
 
182
 
        This does not include files that have been deleted in this
183
 
        tree.
184
 
 
185
 
        Skips the control directory.
186
 
        """
187
 
        inv = self.inventory
188
 
 
189
 
        def descend(from_dir, from_dir_id, dp):
190
 
            ls = os.listdir(dp)
191
 
            ls.sort()
192
 
            for f in ls:
193
 
                ## TODO: If we find a subdirectory with its own .bzr
194
 
                ## directory, then that is a separate tree and we
195
 
                ## should exclude it.
196
 
                if bzrlib.BZRDIR == f:
197
 
                    continue
198
 
 
199
 
                # path within tree
200
 
                fp = appendpath(from_dir, f)
201
 
 
202
 
                # absolute path
203
 
                fap = appendpath(dp, f)
204
 
                
205
 
                f_ie = inv.get_child(from_dir_id, f)
206
 
                if f_ie:
207
 
                    c = 'V'
208
 
                elif self.is_ignored(fp):
209
 
                    c = 'I'
210
 
                else:
211
 
                    c = '?'
212
 
 
213
 
                fk = file_kind(fap)
214
 
 
215
 
                if f_ie:
216
 
                    if f_ie.kind != fk:
217
 
                        bailout("file %r entered as kind %r id %r, now of kind %r"
218
 
                                % (fap, f_ie.kind, f_ie.file_id, fk))
219
 
 
220
 
                yield fp, c, fk, (f_ie and f_ie.file_id)
221
 
 
222
 
                if fk != 'directory':
223
 
                    continue
224
 
 
225
 
                if c != 'V':
226
 
                    # don't descend unversioned directories
227
 
                    continue
228
 
                
229
 
                for ff in descend(fp, f_ie.file_id, fap):
230
 
                    yield ff
231
 
 
232
 
        for f in descend('', None, self.basedir):
233
 
            yield f
234
 
            
235
 
 
236
 
 
237
 
    def unknowns(self):
238
 
        for subp in self.extras():
239
 
            if not self.is_ignored(subp):
240
 
                yield subp
241
 
 
242
 
 
243
 
    def extras(self):
244
 
        """Yield all unknown files in this WorkingTree.
245
 
 
246
 
        If there are any unknown directories then only the directory is
247
 
        returned, not all its children.  But if there are unknown files
248
 
        under a versioned subdirectory, they are returned.
249
 
 
250
 
        Currently returned depth-first, sorted by name within directories.
251
 
        """
252
 
        ## TODO: Work from given directory downwards
253
 
        
254
 
        for path, dir_entry in self.inventory.directories():
255
 
            mutter("search for unknowns in %r" % path)
256
 
            dirabs = self.abspath(path)
257
 
            if not isdir(dirabs):
258
 
                # e.g. directory deleted
259
 
                continue
260
 
 
261
 
            fl = []
262
 
            for subf in os.listdir(dirabs):
263
 
                if (subf != '.bzr'
264
 
                    and (subf not in dir_entry.children)):
265
 
                    fl.append(subf)
266
 
            
267
 
            fl.sort()
268
 
            for subf in fl:
269
 
                subp = appendpath(path, subf)
270
 
                yield subp
271
 
                
272
 
 
273
 
    def ignored_files(self):
274
 
        """Yield list of PATH, IGNORE_PATTERN"""
275
 
        for subp in self.extras():
276
 
            pat = self.is_ignored(subp)
277
 
            if pat != None:
278
 
                yield subp, pat
279
 
 
280
 
 
281
 
    def get_ignore_list(self):
282
 
        """Return list of ignore patterns.
283
 
 
284
 
        Cached in the Tree object after the first call.
285
 
        """
286
 
        if hasattr(self, '_ignorelist'):
287
 
            return self._ignorelist
288
 
 
289
 
        l = bzrlib.DEFAULT_IGNORE[:]
290
 
        if self.has_filename(bzrlib.IGNORE_FILENAME):
291
 
            f = self.get_file_byname(bzrlib.IGNORE_FILENAME)
292
 
            l.extend([line.rstrip("\n\r") for line in f.readlines()])
293
 
        self._ignorelist = l
294
 
        return l
295
 
 
296
 
 
297
 
    def is_ignored(self, filename):
298
 
        """Check whether the filename matches an ignore pattern.
299
 
 
300
 
        Patterns containing '/' need to match the whole path; others
301
 
        match against only the last component.
302
 
 
303
 
        If the file is ignored, returns the pattern which caused it to
304
 
        be ignored, otherwise None.  So this can simply be used as a
305
 
        boolean if desired."""
306
 
 
307
 
        ## TODO: Use '**' to match directories, and other extended globbing stuff from cvs/rsync.
308
 
        
309
 
        for pat in self.get_ignore_list():
310
 
            if '/' in pat:
311
 
                # as a special case, you can put ./ at the start of a pattern;
312
 
                # this is good to match in the top-level only;
313
 
                if pat[:2] == './':
314
 
                    newpat = pat[2:]
315
 
                else:
316
 
                    newpat = pat
317
 
                if fnmatch.fnmatchcase(filename, newpat):
318
 
                    return pat
319
 
            else:
320
 
                if fnmatch.fnmatchcase(splitpath(filename)[-1], pat):
321
 
                    return pat
322
 
        return None
323
 
        
324
 
 
325
 
        
326
 
        
327
 
 
328
 
class RevisionTree(Tree):
329
 
    """Tree viewing a previous revision.
330
 
 
331
 
    File text can be retrieved from the text store.
332
 
 
333
 
    :todo: Some kind of `__repr__` method, but a good one
334
 
           probably means knowing the branch and revision number,
335
 
           or at least passing a description to the constructor.
336
 
    """
337
 
    
338
 
    def __init__(self, store, inv):
339
 
        self._store = store
340
 
        self._inventory = inv
341
 
 
342
 
    def get_file(self, file_id):
343
 
        ie = self._inventory[file_id]
344
 
        f = self._store[ie.text_id]
345
 
        mutter("  get fileid{%s} from %r" % (file_id, self))
346
 
        self._check_retrieved(ie, f)
347
 
        return f
348
 
 
349
 
    def get_file_size(self, file_id):
350
 
        return self._inventory[file_id].text_size
351
 
 
352
 
    def get_file_sha1(self, file_id):
353
 
        ie = self._inventory[file_id]
354
 
        return ie.text_sha1
355
 
 
356
 
    def has_filename(self, filename):
357
 
        return bool(self.inventory.path2id(filename))
358
 
 
359
 
    def list_files(self):
360
 
        # The only files returned by this are those from the version
361
 
        for path, entry in self.inventory.iter_entries():
362
 
            yield path, 'V', entry.kind, entry.file_id
363
 
 
364
 
 
365
 
class EmptyTree(Tree):
366
 
    def __init__(self):
367
 
        self._inventory = Inventory()
368
 
 
369
 
    def has_filename(self, filename):
370
 
        return False
371
 
 
372
 
    def list_files(self):
373
 
        if False:  # just to make it a generator
374
 
            yield None
375
 
    
376
 
 
377
 
 
378
 
######################################################################
379
 
# diff
380
 
 
381
 
# TODO: Merge these two functions into a single one that can operate
382
 
# on either a whole tree or a set of files.
383
 
 
384
 
# TODO: Return the diff in order by filename, not by category or in
385
 
# random order.  Can probably be done by lock-stepping through the
386
 
# filenames from both trees.
387
 
 
388
 
 
389
 
def file_status(filename, old_tree, new_tree):
390
 
    """Return single-letter status, old and new names for a file.
391
 
 
392
 
    The complexity here is in deciding how to represent renames;
393
 
    many complex cases are possible.
394
 
    """
395
 
    old_inv = old_tree.inventory
396
 
    new_inv = new_tree.inventory
397
 
    new_id = new_inv.path2id(filename)
398
 
    old_id = old_inv.path2id(filename)
399
 
 
400
 
    if not new_id and not old_id:
401
 
        # easy: doesn't exist in either; not versioned at all
402
 
        if new_tree.is_ignored(filename):
403
 
            return 'I', None, None
404
 
        else:
405
 
            return '?', None, None
406
 
    elif new_id:
407
 
        # There is now a file of this name, great.
408
 
        pass
409
 
    else:
410
 
        # There is no longer a file of this name, but we can describe
411
 
        # what happened to the file that used to have
412
 
        # this name.  There are two possibilities: either it was
413
 
        # deleted entirely, or renamed.
414
 
        assert old_id
415
 
        if new_inv.has_id(old_id):
416
 
            return 'X', old_inv.id2path(old_id), new_inv.id2path(old_id)
417
 
        else:
418
 
            return 'D', old_inv.id2path(old_id), None
419
 
 
420
 
    # if the file_id is new in this revision, it is added
421
 
    if new_id and not old_inv.has_id(new_id):
422
 
        return 'A'
423
 
 
424
 
    # if there used to be a file of this name, but that ID has now
425
 
    # disappeared, it is deleted
426
 
    if old_id and not new_inv.has_id(old_id):
427
 
        return 'D'
428
 
 
429
 
    return 'wtf?'
430
 
 
431
 
    
432