/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: Jan Balster
  • Date: 2006-08-15 12:39:42 UTC
  • mfrom: (1923 +trunk)
  • mto: This revision was merged to the branch mainline in revision 1928.
  • Revision ID: jan@merlinux.de-20060815123942-22c388c6e9a8ac91
merge bzr.dev 1923

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
19
19
 
20
20
import os
21
21
from cStringIO import StringIO
 
22
from warnings import warn
22
23
 
23
24
import bzrlib
 
25
from bzrlib import delta
 
26
from bzrlib.decorators import needs_read_lock
24
27
from bzrlib.errors import BzrError, BzrCheckError
 
28
from bzrlib import errors
25
29
from bzrlib.inventory import Inventory
 
30
from bzrlib.inter import InterObject
26
31
from bzrlib.osutils import fingerprint_file
27
32
import bzrlib.revision
28
33
from bzrlib.trace import mutter, note
29
34
 
 
35
 
30
36
class Tree(object):
31
37
    """Abstract file tree.
32
38
 
36
42
 
37
43
    * `RevisionTree` is a tree as recorded at some point in the past.
38
44
 
39
 
    * `EmptyTree`
40
 
 
41
45
    Trees contain an `Inventory` object, and also know how to retrieve
42
46
    file texts mentioned in the inventory, either from a working
43
47
    directory or from a store.
49
53
    trees or versioned trees.
50
54
    """
51
55
    
 
56
    def changes_from(self, other, want_unchanged=False, specific_files=None,
 
57
        extra_trees=None, require_versioned=False):
 
58
        """Return a TreeDelta of the changes from other to this tree.
 
59
 
 
60
        :param other: A tree to compare with.
 
61
        :param specific_files: An optional list of file paths to restrict the
 
62
            comparison to. When mapping filenames to ids, all matches in all
 
63
            trees (including optional extra_trees) are used, and all children of
 
64
            matched directories are included.
 
65
        :param want_unchanged: An optional boolean requesting the inclusion of
 
66
            unchanged entries in the result.
 
67
        :param extra_trees: An optional list of additional trees to use when
 
68
            mapping the contents of specific_files (paths) to file_ids.
 
69
        :param require_versioned: An optional boolean (defaults to False). When
 
70
            supplied and True all the 'specific_files' must be versioned, or
 
71
            a PathsNotVersionedError will be thrown.
 
72
 
 
73
        The comparison will be performed by an InterTree object looked up on 
 
74
        self and other.
 
75
        """
 
76
        # Martin observes that Tree.changes_from returns a TreeDelta and this
 
77
        # may confuse people, because the class name of the returned object is
 
78
        # a synonym of the object referenced in the method name.
 
79
        return InterTree.get(other, self).compare(
 
80
            want_unchanged=want_unchanged,
 
81
            specific_files=specific_files,
 
82
            extra_trees=extra_trees,
 
83
            require_versioned=require_versioned,
 
84
            )
 
85
    
52
86
    def conflicts(self):
53
87
        """Get a list of the conflicts in the tree.
54
88
 
72
106
    def has_id(self, file_id):
73
107
        return self.inventory.has_id(file_id)
74
108
 
 
109
    __contains__ = has_id
 
110
 
75
111
    def has_or_had_id(self, file_id):
76
112
        if file_id == self.inventory.root.file_id:
77
113
            return True
78
114
        return self.inventory.has_id(file_id)
79
115
 
80
 
    __contains__ = has_id
81
 
 
82
116
    def __iter__(self):
83
117
        return iter(self.inventory)
84
118
 
85
119
    def id2path(self, file_id):
86
120
        return self.inventory.id2path(file_id)
87
121
 
 
122
    def iter_entries_by_dir(self):
 
123
        """Walk the tree in 'by_dir' order.
 
124
 
 
125
        This will yield each entry in the tree as a (path, entry) tuple. The
 
126
        order that they are yielded is: the contents of a directory are 
 
127
        preceeded by the parent of a directory, and all the contents of a 
 
128
        directory are grouped together.
 
129
        """
 
130
        return self.inventory.iter_entries_by_dir()
 
131
 
88
132
    def kind(self, file_id):
89
133
        raise NotImplementedError("subclasses must implement kind")
90
134
 
145
189
        # are not versioned.
146
190
        pred = self.inventory.has_filename
147
191
        return set((p for p in paths if not pred(p)))
148
 
        
149
 
        
150
 
class RevisionTree(Tree):
151
 
    """Tree viewing a previous revision.
152
 
 
153
 
    File text can be retrieved from the text store.
154
 
 
155
 
    TODO: Some kind of `__repr__` method, but a good one
156
 
           probably means knowing the branch and revision number,
157
 
           or at least passing a description to the constructor.
158
 
    """
159
 
    
160
 
    def __init__(self, branch, inv, revision_id):
161
 
        # for compatability the 'branch' parameter has not been renamed to 
162
 
        # repository at this point. However, we should change RevisionTree's
163
 
        # construction to always be via Repository and not via direct 
164
 
        # construction - this will mean that we can change the constructor
165
 
        # with much less chance of breaking client code.
166
 
        self._repository = branch
167
 
        self._weave_store = branch.weave_store
168
 
        self._inventory = inv
169
 
        self._revision_id = revision_id
170
 
 
171
 
    def get_parent_ids(self):
172
 
        """See Tree.get_parent_ids.
173
 
 
174
 
        A RevisionTree's parents match the revision graph.
175
 
        """
176
 
        parent_ids = self._repository.get_revision(self._revision_id).parent_ids
177
 
        return parent_ids
178
 
        
179
 
    def get_revision_id(self):
180
 
        """Return the revision id associated with this tree."""
181
 
        return self._revision_id
182
 
 
183
 
    def get_weave(self, file_id):
184
 
        return self._weave_store.get_weave(file_id,
185
 
                self._repository.get_transaction())
186
 
 
187
 
    def get_file_lines(self, file_id):
188
 
        ie = self._inventory[file_id]
189
 
        weave = self.get_weave(file_id)
190
 
        return weave.get_lines(ie.revision)
191
 
 
192
 
    def get_file_text(self, file_id):
193
 
        return ''.join(self.get_file_lines(file_id))
194
 
 
195
 
    def get_file(self, file_id):
196
 
        return StringIO(self.get_file_text(file_id))
197
 
 
198
 
    def get_file_size(self, file_id):
199
 
        return self._inventory[file_id].text_size
200
 
 
201
 
    def get_file_sha1(self, file_id, path=None):
202
 
        ie = self._inventory[file_id]
203
 
        if ie.kind == "file":
204
 
            return ie.text_sha1
205
 
        return None
206
 
 
207
 
    def get_file_mtime(self, file_id, path=None):
208
 
        ie = self._inventory[file_id]
209
 
        revision = self._repository.get_revision(ie.revision)
210
 
        return revision.timestamp
211
 
 
212
 
    def is_executable(self, file_id, path=None):
213
 
        ie = self._inventory[file_id]
214
 
        if ie.kind != "file":
215
 
            return None 
216
 
        return self._inventory[file_id].executable
217
 
 
218
 
    def has_filename(self, filename):
219
 
        return bool(self.inventory.path2id(filename))
220
 
 
221
 
    def list_files(self):
222
 
        # The only files returned by this are those from the version
223
 
        for path, entry in self.inventory.iter_entries():
224
 
            yield path, 'V', entry.kind, entry.file_id, entry
225
 
 
226
 
    def get_symlink_target(self, file_id):
227
 
        ie = self._inventory[file_id]
228
 
        return ie.symlink_target;
229
 
 
230
 
    def kind(self, file_id):
231
 
        return self._inventory[file_id].kind
232
 
 
233
 
    def lock_read(self):
234
 
        self._repository.lock_read()
235
 
 
236
 
    def unlock(self):
237
 
        self._repository.unlock()
238
 
 
 
192
 
 
193
 
 
194
# for compatibility
 
195
from bzrlib.revisiontree import RevisionTree
 
196
 
239
197
 
240
198
class EmptyTree(Tree):
241
199
 
242
200
    def __init__(self):
243
201
        self._inventory = Inventory()
 
202
        warn('EmptyTree is deprecated as of bzr 0.9 please use '
 
203
            'repository.revision_tree instead.',
 
204
            DeprecationWarning, stacklevel=2)
244
205
 
245
206
    def get_parent_ids(self):
246
 
        """See Tree.get_parent_ids.
247
 
 
248
 
        An EmptyTree always has NULL_REVISION as the only parent.
249
 
        """
250
207
        return []
251
208
 
252
209
    def get_symlink_target(self, file_id):
256
213
        return False
257
214
 
258
215
    def kind(self, file_id):
259
 
        assert self._inventory[file_id].kind == "root_directory"
260
 
        return "root_directory"
 
216
        assert self._inventory[file_id].kind == "directory"
 
217
        return "directory"
261
218
 
262
219
    def list_files(self):
263
220
        return iter([])
266
223
        return file_id in self._inventory
267
224
 
268
225
    def get_file_sha1(self, file_id, path=None):
269
 
        assert self._inventory[file_id].kind == "root_directory"
270
226
        return None
271
227
 
272
228
 
335
291
            yield (old_name, new_name)
336
292
            
337
293
 
338
 
 
 
294
def find_ids_across_trees(filenames, trees, require_versioned=True):
 
295
    """Find the ids corresponding to specified filenames.
 
296
    
 
297
    All matches in all trees will be used, and all children of matched
 
298
    directories will be used.
 
299
 
 
300
    :param filenames: The filenames to find file_ids for
 
301
    :param trees: The trees to find file_ids within
 
302
    :param require_versioned: if true, all specified filenames must occur in
 
303
    at least one tree.
 
304
    :return: a set of file ids for the specified filenames and their children.
 
305
    """
 
306
    if not filenames:
 
307
        return None
 
308
    specified_ids = _find_filename_ids_across_trees(filenames, trees, 
 
309
                                                    require_versioned)
 
310
    return _find_children_across_trees(specified_ids, trees)
 
311
 
 
312
 
 
313
def _find_filename_ids_across_trees(filenames, trees, require_versioned):
 
314
    """Find the ids corresponding to specified filenames.
 
315
    
 
316
    All matches in all trees 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
 
323
    """
 
324
    not_versioned = []
 
325
    interesting_ids = set()
 
326
    for tree_path in filenames:
 
327
        not_found = True
 
328
        for tree in trees:
 
329
            file_id = tree.inventory.path2id(tree_path)
 
330
            if file_id is not None:
 
331
                interesting_ids.add(file_id)
 
332
                not_found = False
 
333
        if not_found:
 
334
            not_versioned.append(tree_path)
 
335
    if len(not_versioned) > 0 and require_versioned:
 
336
        raise errors.PathsNotVersionedError(not_versioned)
 
337
    return interesting_ids
 
338
 
 
339
 
 
340
def _find_children_across_trees(specified_ids, trees):
 
341
    """Return a set including specified ids and their children
 
342
    
 
343
    All matches in all trees will be used.
 
344
 
 
345
    :param trees: The trees to find file_ids within
 
346
    :return: a set containing all specified ids and their children 
 
347
    """
 
348
    interesting_ids = set(specified_ids)
 
349
    pending = interesting_ids
 
350
    # now handle children of interesting ids
 
351
    # we loop so that we handle all children of each id in both trees
 
352
    while len(pending) > 0:
 
353
        new_pending = set()
 
354
        for file_id in pending:
 
355
            for tree in trees:
 
356
                if file_id not in tree:
 
357
                    continue
 
358
                entry = tree.inventory[file_id]
 
359
                for child in getattr(entry, 'children', {}).itervalues():
 
360
                    if child.file_id not in interesting_ids:
 
361
                        new_pending.add(child.file_id)
 
362
        interesting_ids.update(new_pending)
 
363
        pending = new_pending
 
364
    return interesting_ids
 
365
 
 
366
 
 
367
class InterTree(InterObject):
 
368
    """This class represents operations taking place between two Trees.
 
369
 
 
370
    Its instances have methods like 'compare' and contain references to the
 
371
    source and target trees these operations are to be carried out on.
 
372
 
 
373
    clients of bzrlib should not need to use InterTree directly, rather they
 
374
    should use the convenience methods on Tree such as 'Tree.compare()' which
 
375
    will pass through to InterTree as appropriate.
 
376
    """
 
377
 
 
378
    _optimisers = set()
 
379
 
 
380
    @needs_read_lock
 
381
    def compare(self, want_unchanged=False, specific_files=None,
 
382
        extra_trees=None, require_versioned=False):
 
383
        """Return the changes from source to target.
 
384
 
 
385
        :return: A TreeDelta.
 
386
        :param specific_files: An optional list of file paths to restrict the
 
387
            comparison to. When mapping filenames to ids, all matches in all
 
388
            trees (including optional extra_trees) are used, and all children of
 
389
            matched directories are included.
 
390
        :param want_unchanged: An optional boolean requesting the inclusion of
 
391
            unchanged entries in the result.
 
392
        :param extra_trees: An optional list of additional trees to use when
 
393
            mapping the contents of specific_files (paths) to file_ids.
 
394
        :param require_versioned: An optional boolean (defaults to False). When
 
395
            supplied and True all the 'specific_files' must be versioned, or
 
396
            a PathsNotVersionedError will be thrown.
 
397
        """
 
398
        # NB: show_status depends on being able to pass in non-versioned files and
 
399
        # report them as unknown
 
400
        trees = (self.source, self.target)
 
401
        if extra_trees is not None:
 
402
            trees = trees + tuple(extra_trees)
 
403
        specific_file_ids = find_ids_across_trees(specific_files,
 
404
            trees, require_versioned=require_versioned)
 
405
        if specific_files and not specific_file_ids:
 
406
            # All files are unversioned, so just return an empty delta
 
407
            # _compare_trees would think we want a complete delta
 
408
            return delta.TreeDelta()
 
409
        return delta._compare_trees(self.source, self.target, want_unchanged,
 
410
            specific_file_ids)