/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

Merge bzr.dev.

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