~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tree.py

Optimize common case where unique_lcs returns a set of lines all in a row

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
1
# Copyright (C) 2005 Canonical Ltd
2
 
#
 
2
 
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
#
 
7
 
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
#
 
12
 
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
21
21
from cStringIO import StringIO
22
22
 
23
23
import bzrlib
24
 
from bzrlib import (
25
 
    delta,
26
 
    symbol_versioning,
27
 
    )
28
 
from bzrlib.decorators import needs_read_lock
 
24
from bzrlib.trace import mutter, note
29
25
from bzrlib.errors import BzrError, BzrCheckError
30
 
from bzrlib import errors
31
26
from bzrlib.inventory import Inventory
32
 
from bzrlib.inter import InterObject
33
 
from bzrlib.osutils import fingerprint_file
34
 
import bzrlib.revision
35
 
from bzrlib.trace import mutter, note
36
 
 
 
27
from bzrlib.osutils import appendpath, fingerprint_file
37
28
 
38
29
class Tree(object):
39
30
    """Abstract file tree.
44
35
 
45
36
    * `RevisionTree` is a tree as recorded at some point in the past.
46
37
 
 
38
    * `EmptyTree`
 
39
 
47
40
    Trees contain an `Inventory` object, and also know how to retrieve
48
41
    file texts mentioned in the inventory, either from a working
49
42
    directory or from a store.
55
48
    trees or versioned trees.
56
49
    """
57
50
    
58
 
    def changes_from(self, other, want_unchanged=False, specific_files=None,
59
 
        extra_trees=None, require_versioned=False, include_root=False):
60
 
        """Return a TreeDelta of the changes from other to this tree.
61
 
 
62
 
        :param other: A tree to compare with.
63
 
        :param specific_files: An optional list of file paths to restrict the
64
 
            comparison to. When mapping filenames to ids, all matches in all
65
 
            trees (including optional extra_trees) are used, and all children of
66
 
            matched directories are included.
67
 
        :param want_unchanged: An optional boolean requesting the inclusion of
68
 
            unchanged entries in the result.
69
 
        :param extra_trees: An optional list of additional trees to use when
70
 
            mapping the contents of specific_files (paths) to file_ids.
71
 
        :param require_versioned: An optional boolean (defaults to False). When
72
 
            supplied and True all the 'specific_files' must be versioned, or
73
 
            a PathsNotVersionedError will be thrown.
74
 
 
75
 
        The comparison will be performed by an InterTree object looked up on 
76
 
        self and other.
77
 
        """
78
 
        # Martin observes that Tree.changes_from returns a TreeDelta and this
79
 
        # may confuse people, because the class name of the returned object is
80
 
        # a synonym of the object referenced in the method name.
81
 
        return InterTree.get(other, self).compare(
82
 
            want_unchanged=want_unchanged,
83
 
            specific_files=specific_files,
84
 
            extra_trees=extra_trees,
85
 
            require_versioned=require_versioned,
86
 
            include_root=include_root
87
 
            )
88
 
    
89
 
    def conflicts(self):
90
 
        """Get a list of the conflicts in the tree.
91
 
 
92
 
        Each conflict is an instance of bzrlib.conflicts.Conflict.
93
 
        """
94
 
        return []
95
 
 
96
 
    def get_parent_ids(self):
97
 
        """Get the parent ids for this tree. 
98
 
 
99
 
        :return: a list of parent ids. [] is returned to indicate
100
 
        a tree with no parents.
101
 
        :raises: BzrError if the parents are not known.
102
 
        """
103
 
        raise NotImplementedError(self.get_parent_ids)
104
 
    
105
51
    def has_filename(self, filename):
106
52
        """True if the tree has given filename."""
107
53
        raise NotImplementedError()
109
55
    def has_id(self, file_id):
110
56
        return self.inventory.has_id(file_id)
111
57
 
112
 
    __contains__ = has_id
113
 
 
114
58
    def has_or_had_id(self, file_id):
115
59
        if file_id == self.inventory.root.file_id:
116
60
            return True
117
61
        return self.inventory.has_id(file_id)
118
62
 
 
63
    __contains__ = has_id
 
64
 
119
65
    def __iter__(self):
120
66
        return iter(self.inventory)
121
67
 
122
68
    def id2path(self, file_id):
123
69
        return self.inventory.id2path(file_id)
124
70
 
125
 
    def is_control_filename(self, filename):
126
 
        """True if filename is the name of a control file in this tree.
127
 
        
128
 
        :param filename: A filename within the tree. This is a relative path
129
 
        from the root of this tree.
130
 
 
131
 
        This is true IF and ONLY IF the filename is part of the meta data
132
 
        that bzr controls in this tree. I.E. a random .bzr directory placed
133
 
        on disk will not be a control file for this tree.
134
 
        """
135
 
        return self.bzrdir.is_control_filename(filename)
136
 
 
137
 
    def iter_entries_by_dir(self):
138
 
        """Walk the tree in 'by_dir' order.
139
 
 
140
 
        This will yield each entry in the tree as a (path, entry) tuple. The
141
 
        order that they are yielded is: the contents of a directory are 
142
 
        preceeded by the parent of a directory, and all the contents of a 
143
 
        directory are grouped together.
144
 
        """
145
 
        return self.inventory.iter_entries_by_dir()
146
 
 
147
71
    def kind(self, file_id):
148
72
        raise NotImplementedError("subclasses must implement kind")
149
73
 
150
74
    def _get_inventory(self):
151
75
        return self._inventory
152
76
    
153
 
    def get_file(self, file_id):
154
 
        """Return a file object for the file file_id in the tree."""
155
 
        raise NotImplementedError(self.get_file)
156
 
    
157
77
    def get_file_by_path(self, path):
158
78
        return self.get_file(self._inventory.path2id(path))
159
79
 
166
86
        fp = fingerprint_file(f)
167
87
        f.seek(0)
168
88
        
169
 
        if ie.text_size is not None:
 
89
        if ie.text_size != None:
170
90
            if ie.text_size != fp['size']:
171
91
                raise BzrError("mismatched size for file %r in %r" % (ie.file_id, self._store),
172
92
                        ["inventory expects %d bytes" % ie.text_size,
179
99
                     "file is actually %s" % fp['sha1'],
180
100
                     "store is probably damaged/corrupt"])
181
101
 
182
 
    def path2id(self, path):
183
 
        """Return the id for path in this tree."""
184
 
        return self._inventory.path2id(path)
185
102
 
186
103
    def print_file(self, file_id):
187
104
        """Print file with id `file_id` to stdout."""
191
108
    def lock_read(self):
192
109
        pass
193
110
 
194
 
    def unknowns(self):
195
 
        """What files are present in this tree and unknown.
196
 
        
197
 
        :return: an iterator over the unknown files.
198
 
        """
199
 
        return iter([])
200
 
 
201
111
    def unlock(self):
202
112
        pass
203
113
 
211
121
        # are not versioned.
212
122
        pred = self.inventory.has_filename
213
123
        return set((p for p in paths if not pred(p)))
 
124
        
 
125
        
 
126
class RevisionTree(Tree):
 
127
    """Tree viewing a previous revision.
 
128
 
 
129
    File text can be retrieved from the text store.
 
130
 
 
131
    TODO: Some kind of `__repr__` method, but a good one
 
132
           probably means knowing the branch and revision number,
 
133
           or at least passing a description to the constructor.
 
134
    """
 
135
    
 
136
    def __init__(self, branch, inv, revision_id):
 
137
        self._branch = branch
 
138
        self._weave_store = branch.weave_store
 
139
        self._inventory = inv
 
140
        self._revision_id = revision_id
 
141
 
 
142
    def get_weave(self, file_id):
 
143
        return self._weave_store.get_weave(file_id,
 
144
                self._branch.get_transaction())
 
145
 
 
146
    def get_file_lines(self, file_id):
 
147
        ie = self._inventory[file_id]
 
148
        weave = self.get_weave(file_id)
 
149
        return weave.get_lines(ie.revision)
 
150
 
 
151
    def get_file_text(self, file_id):
 
152
        return ''.join(self.get_file_lines(file_id))
 
153
 
 
154
    def get_file(self, file_id):
 
155
        return StringIO(self.get_file_text(file_id))
 
156
 
 
157
    def get_file_size(self, file_id):
 
158
        return self._inventory[file_id].text_size
 
159
 
 
160
    def get_file_sha1(self, file_id):
 
161
        ie = self._inventory[file_id]
 
162
        if ie.kind == "file":
 
163
            return ie.text_sha1
 
164
 
 
165
    def is_executable(self, file_id):
 
166
        ie = self._inventory[file_id]
 
167
        if ie.kind != "file":
 
168
            return None 
 
169
        return self._inventory[file_id].executable
 
170
 
 
171
    def has_filename(self, filename):
 
172
        return bool(self.inventory.path2id(filename))
 
173
 
 
174
    def list_files(self):
 
175
        # The only files returned by this are those from the version
 
176
        for path, entry in self.inventory.iter_entries():
 
177
            yield path, 'V', entry.kind, entry.file_id, entry
 
178
 
 
179
    def get_symlink_target(self, file_id):
 
180
        ie = self._inventory[file_id]
 
181
        return ie.symlink_target;
 
182
 
 
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()
214
191
 
215
192
 
216
193
class EmptyTree(Tree):
217
 
 
218
194
    def __init__(self):
219
 
        self._inventory = Inventory(root_id=None)
220
 
        symbol_versioning.warn('EmptyTree is deprecated as of bzr 0.9 please'
221
 
                               ' use repository.revision_tree instead.',
222
 
                               DeprecationWarning, stacklevel=2)
223
 
 
224
 
    def get_parent_ids(self):
225
 
        return []
 
195
        self._inventory = Inventory()
226
196
 
227
197
    def get_symlink_target(self, file_id):
228
198
        return None
231
201
        return False
232
202
 
233
203
    def kind(self, file_id):
234
 
        assert self._inventory[file_id].kind == "directory"
235
 
        return "directory"
 
204
        assert self._inventory[file_id].kind == "root_directory"
 
205
        return "root_directory"
236
206
 
237
 
    def list_files(self, include_root=False):
 
207
    def list_files(self):
238
208
        return iter([])
239
209
    
240
210
    def __contains__(self, file_id):
241
 
        return (file_id in self._inventory)
 
211
        return file_id in self._inventory
242
212
 
243
 
    def get_file_sha1(self, file_id, path=None):
 
213
    def get_file_sha1(self, file_id):
 
214
        assert self._inventory[file_id].kind == "root_directory"
244
215
        return None
245
216
 
246
217
 
309
280
            yield (old_name, new_name)
310
281
            
311
282
 
312
 
def find_ids_across_trees(filenames, trees, require_versioned=True):
313
 
    """Find the ids corresponding to specified filenames.
314
 
    
315
 
    All matches in all trees will be used, and all children of matched
316
 
    directories will be used.
317
 
 
318
 
    :param filenames: The filenames to find file_ids for
319
 
    :param trees: The trees to find file_ids within
320
 
    :param require_versioned: if true, all specified filenames must occur in
321
 
    at least one tree.
322
 
    :return: a set of file ids for the specified filenames and their children.
323
 
    """
324
 
    if not filenames:
325
 
        return None
326
 
    specified_ids = _find_filename_ids_across_trees(filenames, trees, 
327
 
                                                    require_versioned)
328
 
    return _find_children_across_trees(specified_ids, trees)
329
 
 
330
 
 
331
 
def _find_filename_ids_across_trees(filenames, trees, require_versioned):
332
 
    """Find the ids corresponding to specified filenames.
333
 
    
334
 
    All matches in all trees will be used.
335
 
 
336
 
    :param filenames: The filenames to find file_ids for
337
 
    :param trees: The trees to find file_ids within
338
 
    :param require_versioned: if true, all specified filenames must occur in
339
 
    at least one tree.
340
 
    :return: a set of file ids for the specified filenames
341
 
    """
342
 
    not_versioned = []
343
 
    interesting_ids = set()
344
 
    for tree_path in filenames:
345
 
        not_found = True
346
 
        for tree in trees:
347
 
            file_id = tree.inventory.path2id(tree_path)
348
 
            if file_id is not None:
349
 
                interesting_ids.add(file_id)
350
 
                not_found = False
351
 
        if not_found:
352
 
            not_versioned.append(tree_path)
353
 
    if len(not_versioned) > 0 and require_versioned:
354
 
        raise errors.PathsNotVersionedError(not_versioned)
355
 
    return interesting_ids
356
 
 
357
 
 
358
 
def _find_children_across_trees(specified_ids, trees):
359
 
    """Return a set including specified ids and their children
360
 
    
361
 
    All matches in all trees will be used.
362
 
 
363
 
    :param trees: The trees to find file_ids within
364
 
    :return: a set containing all specified ids and their children 
365
 
    """
366
 
    interesting_ids = set(specified_ids)
367
 
    pending = interesting_ids
368
 
    # now handle children of interesting ids
369
 
    # we loop so that we handle all children of each id in both trees
370
 
    while len(pending) > 0:
371
 
        new_pending = set()
372
 
        for file_id in pending:
373
 
            for tree in trees:
374
 
                if file_id not in tree:
375
 
                    continue
376
 
                entry = tree.inventory[file_id]
377
 
                for child in getattr(entry, 'children', {}).itervalues():
378
 
                    if child.file_id not in interesting_ids:
379
 
                        new_pending.add(child.file_id)
380
 
        interesting_ids.update(new_pending)
381
 
        pending = new_pending
382
 
    return interesting_ids
383
 
 
384
 
 
385
 
class InterTree(InterObject):
386
 
    """This class represents operations taking place between two Trees.
387
 
 
388
 
    Its instances have methods like 'compare' and contain references to the
389
 
    source and target trees these operations are to be carried out on.
390
 
 
391
 
    clients of bzrlib should not need to use InterTree directly, rather they
392
 
    should use the convenience methods on Tree such as 'Tree.compare()' which
393
 
    will pass through to InterTree as appropriate.
394
 
    """
395
 
 
396
 
    _optimisers = []
397
 
 
398
 
    @needs_read_lock
399
 
    def compare(self, want_unchanged=False, specific_files=None,
400
 
        extra_trees=None, require_versioned=False, include_root=False):
401
 
        """Return the changes from source to target.
402
 
 
403
 
        :return: A TreeDelta.
404
 
        :param specific_files: An optional list of file paths to restrict the
405
 
            comparison to. When mapping filenames to ids, all matches in all
406
 
            trees (including optional extra_trees) are used, and all children of
407
 
            matched directories are included.
408
 
        :param want_unchanged: An optional boolean requesting the inclusion of
409
 
            unchanged entries in the result.
410
 
        :param extra_trees: An optional list of additional trees to use when
411
 
            mapping the contents of specific_files (paths) to file_ids.
412
 
        :param require_versioned: An optional boolean (defaults to False). When
413
 
            supplied and True all the 'specific_files' must be versioned, or
414
 
            a PathsNotVersionedError will be thrown.
415
 
        """
416
 
        # NB: show_status depends on being able to pass in non-versioned files and
417
 
        # report them as unknown
418
 
        trees = (self.source, self.target)
419
 
        if extra_trees is not None:
420
 
            trees = trees + tuple(extra_trees)
421
 
        specific_file_ids = find_ids_across_trees(specific_files,
422
 
            trees, require_versioned=require_versioned)
423
 
        if specific_files and not specific_file_ids:
424
 
            # All files are unversioned, so just return an empty delta
425
 
            # _compare_trees would think we want a complete delta
426
 
            return delta.TreeDelta()
427
 
        return delta._compare_trees(self.source, self.target, want_unchanged,
428
 
            specific_file_ids, include_root)
429
 
 
430
 
 
431
 
# This was deprecated before 0.12, but did not have an official warning
432
 
@symbol_versioning.deprecated_function(symbol_versioning.zero_twelve)
433
 
def RevisionTree(*args, **kwargs):
434
 
    """RevisionTree has moved to bzrlib.revisiontree.RevisionTree()
435
 
 
436
 
    Accessing it as bzrlib.tree.RevisionTree has been deprecated as of
437
 
    bzr 0.12.
438
 
    """
439
 
    from bzrlib.revisiontree import RevisionTree as _RevisionTree
440
 
    return _RevisionTree(*args, **kwargs)
441
 
 
442
283