/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: Robert Collins
  • Date: 2006-07-24 11:26:40 UTC
  • mto: (1852.9.1 Tree.compare().)
  • mto: This revision was merged to the branch mainline in revision 1892.
  • Revision ID: robertc@robertcollins.net-20060724112640-be0b51262ce4a2b6
Implement an InterTreeTestProvider and a trivial test_compare test case.

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
import os
 
21
from cStringIO import StringIO
 
22
from warnings import warn
 
23
 
 
24
import bzrlib
 
25
from bzrlib.errors import BzrError, BzrCheckError
 
26
from bzrlib import errors
 
27
from bzrlib.inventory import Inventory
 
28
from bzrlib.inter import InterObject
 
29
from bzrlib.osutils import fingerprint_file
 
30
import bzrlib.revision
 
31
from bzrlib.trace import mutter, note
 
32
 
 
33
 
 
34
class Tree(object):
 
35
    """Abstract file tree.
 
36
 
 
37
    There are several subclasses:
 
38
    
 
39
    * `WorkingTree` exists as files on disk editable by the user.
 
40
 
 
41
    * `RevisionTree` is a tree as recorded at some point in the past.
 
42
 
 
43
    Trees contain an `Inventory` object, and also know how to retrieve
 
44
    file texts mentioned in the inventory, either from a working
 
45
    directory or from a store.
 
46
 
 
47
    It is possible for trees to contain files that are not described
 
48
    in their inventory or vice versa; for this use `filenames()`.
 
49
 
 
50
    Trees can be compared, etc, regardless of whether they are working
 
51
    trees or versioned trees.
 
52
    """
 
53
    
 
54
    def conflicts(self):
 
55
        """Get a list of the conflicts in the tree.
 
56
 
 
57
        Each conflict is an instance of bzrlib.conflicts.Conflict.
 
58
        """
 
59
        return []
 
60
 
 
61
    def get_parent_ids(self):
 
62
        """Get the parent ids for this tree. 
 
63
 
 
64
        :return: a list of parent ids. [] is returned to indicate
 
65
        a tree with no parents.
 
66
        :raises: BzrError if the parents are not known.
 
67
        """
 
68
        raise NotImplementedError(self.get_parent_ids)
 
69
    
 
70
    def has_filename(self, filename):
 
71
        """True if the tree has given filename."""
 
72
        raise NotImplementedError()
 
73
 
 
74
    def has_id(self, file_id):
 
75
        return self.inventory.has_id(file_id)
 
76
 
 
77
    def has_or_had_id(self, file_id):
 
78
        if file_id == self.inventory.root.file_id:
 
79
            return True
 
80
        return self.inventory.has_id(file_id)
 
81
 
 
82
    __contains__ = has_id
 
83
 
 
84
    def __iter__(self):
 
85
        return iter(self.inventory)
 
86
 
 
87
    def id2path(self, file_id):
 
88
        return self.inventory.id2path(file_id)
 
89
 
 
90
    def kind(self, file_id):
 
91
        raise NotImplementedError("subclasses must implement kind")
 
92
 
 
93
    def _get_inventory(self):
 
94
        return self._inventory
 
95
    
 
96
    def get_file_by_path(self, path):
 
97
        return self.get_file(self._inventory.path2id(path))
 
98
 
 
99
    inventory = property(_get_inventory,
 
100
                         doc="Inventory of this Tree")
 
101
 
 
102
    def _check_retrieved(self, ie, f):
 
103
        if not __debug__:
 
104
            return  
 
105
        fp = fingerprint_file(f)
 
106
        f.seek(0)
 
107
        
 
108
        if ie.text_size != None:
 
109
            if ie.text_size != fp['size']:
 
110
                raise BzrError("mismatched size for file %r in %r" % (ie.file_id, self._store),
 
111
                        ["inventory expects %d bytes" % ie.text_size,
 
112
                         "file is actually %d bytes" % fp['size'],
 
113
                         "store is probably damaged/corrupt"])
 
114
 
 
115
        if ie.text_sha1 != fp['sha1']:
 
116
            raise BzrError("wrong SHA-1 for file %r in %r" % (ie.file_id, self._store),
 
117
                    ["inventory expects %s" % ie.text_sha1,
 
118
                     "file is actually %s" % fp['sha1'],
 
119
                     "store is probably damaged/corrupt"])
 
120
 
 
121
 
 
122
    def print_file(self, file_id):
 
123
        """Print file with id `file_id` to stdout."""
 
124
        import sys
 
125
        sys.stdout.write(self.get_file_text(file_id))
 
126
 
 
127
    def lock_read(self):
 
128
        pass
 
129
 
 
130
    def unknowns(self):
 
131
        """What files are present in this tree and unknown.
 
132
        
 
133
        :return: an iterator over the unknown files.
 
134
        """
 
135
        return iter([])
 
136
 
 
137
    def unlock(self):
 
138
        pass
 
139
 
 
140
    def filter_unversioned_files(self, paths):
 
141
        """Filter out paths that are not versioned.
 
142
 
 
143
        :return: set of paths.
 
144
        """
 
145
        # NB: we specifically *don't* call self.has_filename, because for
 
146
        # WorkingTrees that can indicate files that exist on disk but that 
 
147
        # are not versioned.
 
148
        pred = self.inventory.has_filename
 
149
        return set((p for p in paths if not pred(p)))
 
150
 
 
151
 
 
152
# for compatibility
 
153
from bzrlib.revisiontree import RevisionTree
 
154
 
 
155
 
 
156
class EmptyTree(Tree):
 
157
 
 
158
    def __init__(self):
 
159
        self._inventory = Inventory()
 
160
        warn('EmptyTree is deprecated as of bzr 0.9 please use '
 
161
            'repository.revision_tree instead.',
 
162
            DeprecationWarning, stacklevel=2)
 
163
 
 
164
    def get_parent_ids(self):
 
165
        return []
 
166
 
 
167
    def get_symlink_target(self, file_id):
 
168
        return None
 
169
 
 
170
    def has_filename(self, filename):
 
171
        return False
 
172
 
 
173
    def kind(self, file_id):
 
174
        assert self._inventory[file_id].kind == "root_directory"
 
175
        return "root_directory"
 
176
 
 
177
    def list_files(self):
 
178
        return iter([])
 
179
    
 
180
    def __contains__(self, file_id):
 
181
        return file_id in self._inventory
 
182
 
 
183
    def get_file_sha1(self, file_id, path=None):
 
184
        assert self._inventory[file_id].kind == "root_directory"
 
185
        return None
 
186
 
 
187
 
 
188
######################################################################
 
189
# diff
 
190
 
 
191
# TODO: Merge these two functions into a single one that can operate
 
192
# on either a whole tree or a set of files.
 
193
 
 
194
# TODO: Return the diff in order by filename, not by category or in
 
195
# random order.  Can probably be done by lock-stepping through the
 
196
# filenames from both trees.
 
197
 
 
198
 
 
199
def file_status(filename, old_tree, new_tree):
 
200
    """Return single-letter status, old and new names for a file.
 
201
 
 
202
    The complexity here is in deciding how to represent renames;
 
203
    many complex cases are possible.
 
204
    """
 
205
    old_inv = old_tree.inventory
 
206
    new_inv = new_tree.inventory
 
207
    new_id = new_inv.path2id(filename)
 
208
    old_id = old_inv.path2id(filename)
 
209
 
 
210
    if not new_id and not old_id:
 
211
        # easy: doesn't exist in either; not versioned at all
 
212
        if new_tree.is_ignored(filename):
 
213
            return 'I', None, None
 
214
        else:
 
215
            return '?', None, None
 
216
    elif new_id:
 
217
        # There is now a file of this name, great.
 
218
        pass
 
219
    else:
 
220
        # There is no longer a file of this name, but we can describe
 
221
        # what happened to the file that used to have
 
222
        # this name.  There are two possibilities: either it was
 
223
        # deleted entirely, or renamed.
 
224
        assert old_id
 
225
        if new_inv.has_id(old_id):
 
226
            return 'X', old_inv.id2path(old_id), new_inv.id2path(old_id)
 
227
        else:
 
228
            return 'D', old_inv.id2path(old_id), None
 
229
 
 
230
    # if the file_id is new in this revision, it is added
 
231
    if new_id and not old_inv.has_id(new_id):
 
232
        return 'A'
 
233
 
 
234
    # if there used to be a file of this name, but that ID has now
 
235
    # disappeared, it is deleted
 
236
    if old_id and not new_inv.has_id(old_id):
 
237
        return 'D'
 
238
 
 
239
    return 'wtf?'
 
240
 
 
241
    
 
242
 
 
243
def find_renames(old_inv, new_inv):
 
244
    for file_id in old_inv:
 
245
        if file_id not in new_inv:
 
246
            continue
 
247
        old_name = old_inv.id2path(file_id)
 
248
        new_name = new_inv.id2path(file_id)
 
249
        if old_name != new_name:
 
250
            yield (old_name, new_name)
 
251
            
 
252
 
 
253
def find_ids_across_trees(filenames, trees, require_versioned=True):
 
254
    """Find the ids corresponding to specified filenames.
 
255
    
 
256
    All matches in all trees will be used, and all children of matched
 
257
    directories will be used.
 
258
 
 
259
    :param filenames: The filenames to find file_ids for
 
260
    :param trees: The trees to find file_ids within
 
261
    :param require_versioned: if true, all specified filenames must occur in
 
262
    at least one tree.
 
263
    :return: a set of file ids for the specified filenames and their children.
 
264
    """
 
265
    if not filenames:
 
266
        return None
 
267
    specified_ids = _find_filename_ids_across_trees(filenames, trees, 
 
268
                                                    require_versioned)
 
269
    return _find_children_across_trees(specified_ids, trees)
 
270
 
 
271
 
 
272
def _find_filename_ids_across_trees(filenames, trees, require_versioned):
 
273
    """Find the ids corresponding to specified filenames.
 
274
    
 
275
    All matches in all trees will be used.
 
276
 
 
277
    :param filenames: The filenames to find file_ids for
 
278
    :param trees: The trees to find file_ids within
 
279
    :param require_versioned: if true, all specified filenames must occur in
 
280
    at least one tree.
 
281
    :return: a set of file ids for the specified filenames
 
282
    """
 
283
    not_versioned = []
 
284
    interesting_ids = set()
 
285
    for tree_path in filenames:
 
286
        not_found = True
 
287
        for tree in trees:
 
288
            file_id = tree.inventory.path2id(tree_path)
 
289
            if file_id is not None:
 
290
                interesting_ids.add(file_id)
 
291
                not_found = False
 
292
        if not_found:
 
293
            not_versioned.append(tree_path)
 
294
    if len(not_versioned) > 0 and require_versioned:
 
295
        raise errors.PathsNotVersionedError(not_versioned)
 
296
    return interesting_ids
 
297
 
 
298
 
 
299
def _find_children_across_trees(specified_ids, trees):
 
300
    """Return a set including specified ids and their children
 
301
    
 
302
    All matches in all trees will be used.
 
303
 
 
304
    :param trees: The trees to find file_ids within
 
305
    :return: a set containing all specified ids and their children 
 
306
    """
 
307
    interesting_ids = set(specified_ids)
 
308
    pending = interesting_ids
 
309
    # now handle children of interesting ids
 
310
    # we loop so that we handle all children of each id in both trees
 
311
    while len(pending) > 0:
 
312
        new_pending = set()
 
313
        for file_id in pending:
 
314
            for tree in trees:
 
315
                if file_id not in tree:
 
316
                    continue
 
317
                entry = tree.inventory[file_id]
 
318
                for child in getattr(entry, 'children', {}).itervalues():
 
319
                    if child.file_id not in interesting_ids:
 
320
                        new_pending.add(child.file_id)
 
321
        interesting_ids.update(new_pending)
 
322
        pending = new_pending
 
323
    return interesting_ids
 
324
 
 
325
 
 
326
class InterTree(InterObject):
 
327
    """This class represents operations taking place between two Trees.
 
328
 
 
329
    Its instances have methods like 'compare' and contain references to the
 
330
    source and target trees these operations are to be carried out on.
 
331
 
 
332
    clients of bzrlib should not need to use InterTree directly, rather they
 
333
    should use the convenience methods on Tree such as 'Tree.compare()' which
 
334
    will pass through to InterTree as appropriate.
 
335
    """
 
336
 
 
337
    _optimisers = set()
 
338
 
 
339
    def compare(self):
 
340
        """Compare source and target.
 
341
 
 
342
        :return: A TreeDelta.
 
343
        """
 
344
        # imported later to avoid circular imports
 
345
        from bzrlib.delta import compare_trees
 
346
        return compare_trees(self.source, self.target)