← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/revisiontree.py

  • Committer: John Arbash Meinel
  • Date: 2008-08-18 22:34:21 UTC
  • mto: (3606.5.6 1.6)
  • mto: This revision was merged to the branch mainline in revision 3641.
  • Revision ID: john@arbash-meinel.com-20080818223421-todjny24vj4faj4t
Add tests for the fetching behavior.

The proper parameter passed is 'unordered' add an assert for it, and
fix callers that were passing 'unsorted' instead.
Add tests that we make the right get_record_stream call based
on the value of _fetch_uses_deltas.
Fix the fetch request for signatures.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/revisiontree.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2007 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
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
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""RevisionTree - a Tree implementation backed by repository data for a revision."""
18
18
 
20
20
 
21
21
from bzrlib import (
22
22
    errors,
 
23
    osutils,
23
24
    revision,
24
 
    tree,
 
25
    symbol_versioning,
25
26
    )
26
 
 
27
 
 
28
 
class RevisionTree(tree.Tree):
 
27
from bzrlib.tree import Tree
 
28
 
 
29
 
 
30
class RevisionTree(Tree):
29
31
    """Tree viewing a previous revision.
30
32
 
31
33
    File text can be retrieved from the text store.
32
34
    """
33
35
 
34
36
    def __init__(self, branch, inv, revision_id):
35
 
        # for compatability the 'branch' parameter has not been renamed to
 
37
        # for compatability the 'branch' parameter has not been renamed to 
36
38
        # repository at this point. However, we should change RevisionTree's
37
 
        # construction to always be via Repository and not via direct
 
39
        # construction to always be via Repository and not via direct 
38
40
        # construction - this will mean that we can change the constructor
39
41
        # with much less chance of breaking client code.
40
42
        self._repository = branch
43
45
        self._rules_searcher = None
44
46
 
45
47
    def supports_tree_reference(self):
46
 
        return getattr(self._repository._format, "supports_tree_reference",
47
 
            False)
 
48
        return True
48
49
 
49
50
    def get_parent_ids(self):
50
51
        """See Tree.get_parent_ids.
57
58
            parent_ids = self._repository.get_revision(
58
59
                self._revision_id).parent_ids
59
60
        return parent_ids
60
 
 
 
61
        
61
62
    def get_revision_id(self):
62
63
        """Return the revision id associated with this tree."""
63
64
        return self._revision_id
64
65
 
65
 
    def get_file_text(self, file_id, path=None):
66
 
        _, content = list(self.iter_files_bytes([(file_id, None)]))[0]
67
 
        return ''.join(content)
 
66
    def get_file_lines(self, file_id):
 
67
        return osutils.split_lines(self.get_file_text(file_id))
 
68
 
 
69
    def get_file_text(self, file_id):
 
70
        return list(self.iter_files_bytes([(file_id, None)]))[0][1]
68
71
 
69
72
    def get_file(self, file_id, path=None):
70
73
        return StringIO(self.get_file_text(file_id))
85
88
                      default_revision=revision.CURRENT_REVISION):
86
89
        """See Tree.annotate_iter"""
87
90
        text_key = (file_id, self.inventory[file_id].revision)
88
 
        annotator = self._repository.texts.get_annotator()
89
 
        annotations = annotator.annotate_flat(text_key)
 
91
        annotations = self._repository.texts.annotate(text_key)
90
92
        return [(key[-1], line) for key, line in annotations]
91
93
 
92
94
    def get_file_size(self, file_id):
101
103
 
102
104
    def get_file_mtime(self, file_id, path=None):
103
105
        ie = self._inventory[file_id]
104
 
        try:
105
 
            revision = self._repository.get_revision(ie.revision)
106
 
        except errors.NoSuchRevision:
107
 
            raise errors.FileTimestampUnavailable(self.id2path(file_id))
 
106
        revision = self._repository.get_revision(ie.revision)
108
107
        return revision.timestamp
109
108
 
110
109
    def is_executable(self, file_id, path=None):
116
115
    def has_filename(self, filename):
117
116
        return bool(self.inventory.path2id(filename))
118
117
 
119
 
    def list_files(self, include_root=False, from_dir=None, recursive=True):
 
118
    def list_files(self, include_root=False):
120
119
        # The only files returned by this are those from the version
121
 
        inv = self.inventory
122
 
        if from_dir is None:
123
 
            from_dir_id = None
124
 
        else:
125
 
            from_dir_id = inv.path2id(from_dir)
126
 
            if from_dir_id is None:
127
 
                # Directory not versioned
128
 
                return
129
 
        entries = inv.iter_entries(from_dir=from_dir_id, recursive=recursive)
130
 
        if inv.root is not None and not include_root and from_dir is None:
 
120
        entries = self.inventory.iter_entries()
 
121
        # skip the root for compatability with the current apis.
 
122
        if self.inventory.root is not None and not include_root:
131
123
            # skip the root for compatability with the current apis.
132
124
            entries.next()
133
125
        for path, entry in entries:
135
127
 
136
128
    def get_symlink_target(self, file_id):
137
129
        ie = self._inventory[file_id]
138
 
        # Inventories store symlink targets in unicode
139
 
        return ie.symlink_target
 
130
        return ie.symlink_target;
140
131
 
141
132
    def get_reference_revision(self, file_id, path=None):
142
133
        return self.inventory[file_id].reference_revision
174
165
        return set(self._repository.get_ancestry(self._revision_id,
175
166
                                                 topo_sorted=False))
176
167
 
177
 
    def is_locked(self):
178
 
        return self._repository.is_locked()
179
 
 
180
168
    def lock_read(self):
181
169
        self._repository.lock_read()
182
 
        return self
183
170
 
184
171
    def __repr__(self):
185
172
        return '<%s instance at %x, rev_id=%r>' % (
223
210
            self._rules_searcher = super(RevisionTree,
224
211
                self)._get_rules_searcher(default_searcher)
225
212
        return self._rules_searcher
226
 
 
227
 
 
228
 
class InterCHKRevisionTree(tree.InterTree):
229
 
    """Fast path optimiser for RevisionTrees with CHK inventories."""
230
 
 
231
 
    @staticmethod
232
 
    def is_compatible(source, target):
233
 
        if (isinstance(source, RevisionTree)
234
 
            and isinstance(target, RevisionTree)):
235
 
            try:
236
 
                # Only CHK inventories have id_to_entry attribute
237
 
                source.inventory.id_to_entry
238
 
                target.inventory.id_to_entry
239
 
                return True
240
 
            except AttributeError:
241
 
                pass
242
 
        return False
243
 
 
244
 
    def iter_changes(self, include_unchanged=False,
245
 
                     specific_files=None, pb=None, extra_trees=[],
246
 
                     require_versioned=True, want_unversioned=False):
247
 
        lookup_trees = [self.source]
248
 
        if extra_trees:
249
 
             lookup_trees.extend(extra_trees)
250
 
        # The ids of items we need to examine to insure delta consistency.
251
 
        precise_file_ids = set()
252
 
        discarded_changes = {}
253
 
        if specific_files == []:
254
 
            specific_file_ids = []
255
 
        else:
256
 
            specific_file_ids = self.target.paths2ids(specific_files,
257
 
                lookup_trees, require_versioned=require_versioned)
258
 
        # FIXME: It should be possible to delegate include_unchanged handling
259
 
        # to CHKInventory.iter_changes and do a better job there -- vila
260
 
        # 20090304
261
 
        changed_file_ids = set()
262
 
        for result in self.target.inventory.iter_changes(self.source.inventory):
263
 
            if specific_file_ids is not None:
264
 
                file_id = result[0]
265
 
                if file_id not in specific_file_ids:
266
 
                    # A change from the whole tree that we don't want to show yet.
267
 
                    # We may find that we need to show it for delta consistency, so
268
 
                    # stash it.
269
 
                    discarded_changes[result[0]] = result
270
 
                    continue
271
 
                new_parent_id = result[4][1]
272
 
                precise_file_ids.add(new_parent_id)
273
 
            yield result
274
 
            changed_file_ids.add(result[0])
275
 
        if specific_file_ids is not None:
276
 
            for result in self._handle_precise_ids(precise_file_ids,
277
 
                changed_file_ids, discarded_changes=discarded_changes):
278
 
                yield result
279
 
        if include_unchanged:
280
 
            # CHKMap avoid being O(tree), so we go to O(tree) only if
281
 
            # required to.
282
 
            # Now walk the whole inventory, excluding the already yielded
283
 
            # file ids
284
 
            changed_file_ids = set(changed_file_ids)
285
 
            for relpath, entry in self.target.inventory.iter_entries():
286
 
                if (specific_file_ids is not None
287
 
                    and not entry.file_id in specific_file_ids):
288
 
                    continue
289
 
                if not entry.file_id in changed_file_ids:
290
 
                    yield (entry.file_id,
291
 
                           (relpath, relpath), # Not renamed
292
 
                           False, # Not modified
293
 
                           (True, True), # Still  versioned
294
 
                           (entry.parent_id, entry.parent_id),
295
 
                           (entry.name, entry.name),
296
 
                           (entry.kind, entry.kind),
297
 
                           (entry.executable, entry.executable))
298
 
 
299
 
 
300
 
tree.InterTree.register_optimiser(InterCHKRevisionTree)