/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: Canonical.com Patch Queue Manager
  • Date: 2006-11-16 18:33:33 UTC
  • mfrom: (2138.1.1 robuster.external.diff)
  • Revision ID: pqm@pqm.ubuntu.com-20061116183333-5f56523d7b44e564
(Dmitry Vasiliev) Robuster external diff output handling.

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.trace import mutter, note
 
24
from bzrlib import (
 
25
    delta,
 
26
    symbol_versioning,
 
27
    )
 
28
from bzrlib.decorators import needs_read_lock
25
29
from bzrlib.errors import BzrError, BzrCheckError
 
30
from bzrlib import errors
26
31
from bzrlib.inventory import Inventory
27
 
from bzrlib.osutils import appendpath, fingerprint_file
 
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
 
28
37
 
29
38
class Tree(object):
30
39
    """Abstract file tree.
35
44
 
36
45
    * `RevisionTree` is a tree as recorded at some point in the past.
37
46
 
38
 
    * `EmptyTree`
39
 
 
40
47
    Trees contain an `Inventory` object, and also know how to retrieve
41
48
    file texts mentioned in the inventory, either from a working
42
49
    directory or from a store.
48
55
    trees or versioned trees.
49
56
    """
50
57
    
 
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
    
51
105
    def has_filename(self, filename):
52
106
        """True if the tree has given filename."""
53
107
        raise NotImplementedError()
55
109
    def has_id(self, file_id):
56
110
        return self.inventory.has_id(file_id)
57
111
 
 
112
    __contains__ = has_id
 
113
 
58
114
    def has_or_had_id(self, file_id):
59
115
        if file_id == self.inventory.root.file_id:
60
116
            return True
61
117
        return self.inventory.has_id(file_id)
62
118
 
63
 
    __contains__ = has_id
64
 
 
65
119
    def __iter__(self):
66
120
        return iter(self.inventory)
67
121
 
68
122
    def id2path(self, file_id):
69
123
        return self.inventory.id2path(file_id)
70
124
 
 
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
 
71
147
    def kind(self, file_id):
72
148
        raise NotImplementedError("subclasses must implement kind")
73
149
 
74
150
    def _get_inventory(self):
75
151
        return self._inventory
76
152
    
 
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
    
77
157
    def get_file_by_path(self, path):
78
158
        return self.get_file(self._inventory.path2id(path))
79
159
 
86
166
        fp = fingerprint_file(f)
87
167
        f.seek(0)
88
168
        
89
 
        if ie.text_size != None:
 
169
        if ie.text_size is not None:
90
170
            if ie.text_size != fp['size']:
91
171
                raise BzrError("mismatched size for file %r in %r" % (ie.file_id, self._store),
92
172
                        ["inventory expects %d bytes" % ie.text_size,
99
179
                     "file is actually %s" % fp['sha1'],
100
180
                     "store is probably damaged/corrupt"])
101
181
 
 
182
    def path2id(self, path):
 
183
        """Return the id for path in this tree."""
 
184
        return self._inventory.path2id(path)
102
185
 
103
186
    def print_file(self, file_id):
104
187
        """Print file with id `file_id` to stdout."""
108
191
    def lock_read(self):
109
192
        pass
110
193
 
 
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
 
111
201
    def unlock(self):
112
202
        pass
113
203
 
121
211
        # are not versioned.
122
212
        pred = self.inventory.has_filename
123
213
        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()
191
214
 
192
215
 
193
216
class EmptyTree(Tree):
 
217
 
194
218
    def __init__(self):
195
 
        self._inventory = Inventory()
 
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 []
196
226
 
197
227
    def get_symlink_target(self, file_id):
198
228
        return None
201
231
        return False
202
232
 
203
233
    def kind(self, file_id):
204
 
        assert self._inventory[file_id].kind == "root_directory"
205
 
        return "root_directory"
 
234
        assert self._inventory[file_id].kind == "directory"
 
235
        return "directory"
206
236
 
207
 
    def list_files(self):
 
237
    def list_files(self, include_root=False):
208
238
        return iter([])
209
239
    
210
240
    def __contains__(self, file_id):
211
 
        return file_id in self._inventory
 
241
        return (file_id in self._inventory)
212
242
 
213
 
    def get_file_sha1(self, file_id):
214
 
        assert self._inventory[file_id].kind == "root_directory"
 
243
    def get_file_sha1(self, file_id, path=None):
215
244
        return None
216
245
 
217
246
 
280
309
            yield (old_name, new_name)
281
310
            
282
311
 
 
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
 
283
442