/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/revisiontree.py

 * Hook up the new remote method ``RemoteBzrDir.find_repositoryV2`` so
   that it is now attempted first when lookup up repositories, leading to
   an extra round trip on older bzr smart servers but supporting the
   feature on newer servers. (Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/revisiontree.py
 
1
# Copyright (C) 2005, 2007 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
"""RevisionTree - a Tree implementation backed by repository data for a revision."""
 
18
 
 
19
from cStringIO import StringIO
 
20
 
 
21
from bzrlib import (
 
22
    osutils,
 
23
    revision,
 
24
    symbol_versioning,
 
25
    )
 
26
from bzrlib.tree import Tree
 
27
 
 
28
 
 
29
class RevisionTree(Tree):
 
30
    """Tree viewing a previous revision.
 
31
 
 
32
    File text can be retrieved from the text store.
 
33
    """
 
34
 
 
35
    def __init__(self, branch, inv, revision_id):
 
36
        # for compatability the 'branch' parameter has not been renamed to 
 
37
        # repository at this point. However, we should change RevisionTree's
 
38
        # construction to always be via Repository and not via direct 
 
39
        # construction - this will mean that we can change the constructor
 
40
        # with much less chance of breaking client code.
 
41
        self._repository = branch
 
42
        self._weave_store = branch.weave_store
 
43
        self._inventory = inv
 
44
        self._revision_id = revision_id
 
45
 
 
46
    def supports_tree_reference(self):
 
47
        return True
 
48
 
 
49
    def get_parent_ids(self):
 
50
        """See Tree.get_parent_ids.
 
51
 
 
52
        A RevisionTree's parents match the revision graph.
 
53
        """
 
54
        if self._revision_id in (None, revision.NULL_REVISION):
 
55
            parent_ids = []
 
56
        else:
 
57
            parent_ids = self._repository.get_revision(
 
58
                self._revision_id).parent_ids
 
59
        return parent_ids
 
60
        
 
61
    def get_revision_id(self):
 
62
        """Return the revision id associated with this tree."""
 
63
        return self._revision_id
 
64
 
 
65
    @symbol_versioning.deprecated_method(symbol_versioning.zero_ninety)
 
66
    def get_weave(self, file_id):
 
67
        return self._get_weave(file_id)
 
68
 
 
69
    def _get_weave(self, file_id):
 
70
        return self._weave_store.get_weave(file_id,
 
71
                self._repository.get_transaction())
 
72
 
 
73
    def get_file_lines(self, file_id):
 
74
        ie = self._inventory[file_id]
 
75
        weave = self._get_weave(file_id)
 
76
        return weave.get_lines(ie.revision)
 
77
 
 
78
    def get_file_text(self, file_id):
 
79
        return ''.join(self.get_file_lines(file_id))
 
80
 
 
81
    def get_file(self, file_id, path=None):
 
82
        return StringIO(self.get_file_text(file_id))
 
83
 
 
84
    def iter_files_bytes(self, desired_files):
 
85
        """See Tree.extract_files_bytes.
 
86
 
 
87
        This version is implemented on top of Repository.extract_files_bytes"""
 
88
        repo_desired_files = [(f, self.inventory[f].revision, i)
 
89
                              for f, i in desired_files]
 
90
        return self._repository.iter_files_bytes(repo_desired_files)
 
91
 
 
92
    def annotate_iter(self, file_id,
 
93
                      default_revision=revision.CURRENT_REVISION):
 
94
        """See Tree.annotate_iter"""
 
95
        w = self._get_weave(file_id)
 
96
        return w.annotate_iter(self.inventory[file_id].revision)
 
97
 
 
98
    def get_file_size(self, file_id):
 
99
        return self._inventory[file_id].text_size
 
100
 
 
101
    def get_file_sha1(self, file_id, path=None, stat_value=None):
 
102
        ie = self._inventory[file_id]
 
103
        if ie.kind == "file":
 
104
            return ie.text_sha1
 
105
        return None
 
106
 
 
107
    def get_file_mtime(self, file_id, path=None):
 
108
        ie = self._inventory[file_id]
 
109
        revision = self._repository.get_revision(ie.revision)
 
110
        return revision.timestamp
 
111
 
 
112
    def is_executable(self, file_id, path=None):
 
113
        ie = self._inventory[file_id]
 
114
        if ie.kind != "file":
 
115
            return None
 
116
        return ie.executable
 
117
 
 
118
    def has_filename(self, filename):
 
119
        return bool(self.inventory.path2id(filename))
 
120
 
 
121
    def list_files(self, include_root=False):
 
122
        # The only files returned by this are those from the version
 
123
        entries = self.inventory.iter_entries()
 
124
        # skip the root for compatability with the current apis.
 
125
        if self.inventory.root is not None and not include_root:
 
126
            # skip the root for compatability with the current apis.
 
127
            entries.next()
 
128
        for path, entry in entries:
 
129
            yield path, 'V', entry.kind, entry.file_id, entry
 
130
 
 
131
    def get_symlink_target(self, file_id):
 
132
        ie = self._inventory[file_id]
 
133
        return ie.symlink_target;
 
134
 
 
135
    def get_reference_revision(self, file_id, path=None):
 
136
        return self.inventory[file_id].reference_revision
 
137
 
 
138
    def get_root_id(self):
 
139
        if self.inventory.root:
 
140
            return self.inventory.root.file_id
 
141
 
 
142
    def kind(self, file_id):
 
143
        return self._inventory[file_id].kind
 
144
 
 
145
    def path_content_summary(self, path):
 
146
        """See Tree.path_content_summary."""
 
147
        id = self.inventory.path2id(path)
 
148
        if id is None:
 
149
            return ('missing', None, None, None)
 
150
        entry = self._inventory[id]
 
151
        kind = entry.kind
 
152
        if kind == 'file':
 
153
            return (kind, entry.text_size, entry.executable, entry.text_sha1)
 
154
        elif kind == 'symlink':
 
155
            return (kind, None, None, entry.symlink_target)
 
156
        else:
 
157
            return (kind, None, None, None)
 
158
 
 
159
    def _comparison_data(self, entry, path):
 
160
        if entry is None:
 
161
            return None, False, None
 
162
        return entry.kind, entry.executable, None
 
163
 
 
164
    def _file_size(self, entry, stat_value):
 
165
        assert entry.text_size is not None
 
166
        return entry.text_size
 
167
 
 
168
    def _get_ancestors(self, default_revision):
 
169
        return set(self._repository.get_ancestry(self._revision_id,
 
170
                                                 topo_sorted=False))
 
171
 
 
172
    def lock_read(self):
 
173
        self._repository.lock_read()
 
174
 
 
175
    def __repr__(self):
 
176
        return '<%s instance at %x, rev_id=%r>' % (
 
177
            self.__class__.__name__, id(self), self._revision_id)
 
178
 
 
179
    def unlock(self):
 
180
        self._repository.unlock()
 
181
 
 
182
    def walkdirs(self, prefix=""):
 
183
        _directory = 'directory'
 
184
        inv = self.inventory
 
185
        top_id = inv.path2id(prefix)
 
186
        if top_id is None:
 
187
            pending = []
 
188
        else:
 
189
            pending = [(prefix, '', _directory, None, top_id, None)]
 
190
        while pending:
 
191
            dirblock = []
 
192
            currentdir = pending.pop()
 
193
            # 0 - relpath, 1- basename, 2- kind, 3- stat, id, v-kind
 
194
            if currentdir[0]:
 
195
                relroot = currentdir[0] + '/'
 
196
            else:
 
197
                relroot = ""
 
198
            # FIXME: stash the node in pending
 
199
            entry = inv[currentdir[4]]
 
200
            for name, child in entry.sorted_children():
 
201
                toppath = relroot + name
 
202
                dirblock.append((toppath, name, child.kind, None,
 
203
                    child.file_id, child.kind
 
204
                    ))
 
205
            yield (currentdir[0], entry.file_id), dirblock
 
206
            # push the user specified dirs from dirblock
 
207
            for dir in reversed(dirblock):
 
208
                if dir[2] == _directory:
 
209
                    pending.append(dir)