← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/revisiontree.py

  • Committer: Rory Yorke
  • Date: 2010-10-20 14:38:53 UTC
  • mto: This revision was merged to the branch mainline in revision 5519.
  • Revision ID: rory.yorke@gmail.com-20101020143853-9kfd2ldcjfroh8jw
Show missing files in bzr status (bug 134168).

"bzr status" will now show missing files, that is, those added with "bzr
add" and then removed by non bzr means (e.g., rm).

Blackbox tests were added for this case, and tests were also added to
test_delta, since the implementation change is in bzrlib.delta.

Might also affect bug 189709.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/revisiontree.py
31
31
    File text can be retrieved from the text store.
32
32
    """
33
33
 
34
 
    def __init__(self, repository, revision_id):
35
 
        self._repository = repository
 
34
    def __init__(self, branch, inv, revision_id):
 
35
        # for compatability the 'branch' parameter has not been renamed to
 
36
        # repository at this point. However, we should change RevisionTree's
 
37
        # construction to always be via Repository and not via direct
 
38
        # construction - this will mean that we can change the constructor
 
39
        # with much less chance of breaking client code.
 
40
        self._repository = branch
 
41
        self._inventory = inv
36
42
        self._revision_id = revision_id
37
43
        self._rules_searcher = None
38
44
 
56
62
        """Return the revision id associated with this tree."""
57
63
        return self._revision_id
58
64
 
59
 
    def get_file_revision(self, file_id, path=None):
60
 
        """Return the revision id in which a file was last changed."""
61
 
        raise NotImplementedError(self.get_file_revision)
62
 
 
63
65
    def get_file_text(self, file_id, path=None):
64
66
        _, content = list(self.iter_files_bytes([(file_id, None)]))[0]
65
67
        return ''.join(content)
67
69
    def get_file(self, file_id, path=None):
68
70
        return StringIO(self.get_file_text(file_id))
69
71
 
70
 
    def is_locked(self):
71
 
        return self._repository.is_locked()
72
 
 
73
 
    def lock_read(self):
74
 
        self._repository.lock_read()
75
 
        return self
76
 
 
77
 
    def __repr__(self):
78
 
        return '<%s instance at %x, rev_id=%r>' % (
79
 
            self.__class__.__name__, id(self), self._revision_id)
80
 
 
81
 
    def unlock(self):
82
 
        self._repository.unlock()
83
 
 
84
 
    def _get_rules_searcher(self, default_searcher):
85
 
        """See Tree._get_rules_searcher."""
86
 
        if self._rules_searcher is None:
87
 
            self._rules_searcher = super(RevisionTree,
88
 
                self)._get_rules_searcher(default_searcher)
89
 
        return self._rules_searcher
90
 
 
91
 
 
92
 
class InventoryRevisionTree(RevisionTree,tree.InventoryTree):
93
 
 
94
 
    def __init__(self, repository, inv, revision_id):
95
 
        RevisionTree.__init__(self, repository, revision_id)
96
 
        self._inventory = inv
97
 
 
98
 
    def get_file_mtime(self, file_id, path=None):
99
 
        ie = self._inventory[file_id]
 
72
    def iter_files_bytes(self, desired_files):
 
73
        """See Tree.iter_files_bytes.
 
74
 
 
75
        This version is implemented on top of Repository.extract_files_bytes"""
 
76
        repo_desired_files = [(f, self.inventory[f].revision, i)
 
77
                              for f, i in desired_files]
100
78
        try:
101
 
            revision = self._repository.get_revision(ie.revision)
102
 
        except errors.NoSuchRevision:
103
 
            raise errors.FileTimestampUnavailable(self.id2path(file_id))
104
 
        return revision.timestamp
 
79
            for result in self._repository.iter_files_bytes(repo_desired_files):
 
80
                yield result
 
81
        except errors.RevisionNotPresent, e:
 
82
            raise errors.NoSuchFile(e.revision_id)
 
83
 
 
84
    def annotate_iter(self, file_id,
 
85
                      default_revision=revision.CURRENT_REVISION):
 
86
        """See Tree.annotate_iter"""
 
87
        text_key = (file_id, self.inventory[file_id].revision)
 
88
        annotator = self._repository.texts.get_annotator()
 
89
        annotations = annotator.annotate_flat(text_key)
 
90
        return [(key[-1], line) for key, line in annotations]
105
91
 
106
92
    def get_file_size(self, file_id):
 
93
        """See Tree.get_file_size"""
107
94
        return self._inventory[file_id].text_size
108
95
 
109
96
    def get_file_sha1(self, file_id, path=None, stat_value=None):
112
99
            return ie.text_sha1
113
100
        return None
114
101
 
115
 
    def get_file_revision(self, file_id, path=None):
 
102
    def get_file_mtime(self, file_id, path=None):
116
103
        ie = self._inventory[file_id]
117
 
        return ie.revision
 
104
        try:
 
105
            revision = self._repository.get_revision(ie.revision)
 
106
        except errors.NoSuchRevision:
 
107
            raise errors.FileTimestampUnavailable(self.id2path(file_id))
 
108
        return revision.timestamp
118
109
 
119
110
    def is_executable(self, file_id, path=None):
120
111
        ie = self._inventory[file_id]
121
112
        if ie.kind != "file":
122
 
            return False
 
113
            return None
123
114
        return ie.executable
124
115
 
125
116
    def has_filename(self, filename):
183
174
        return set(self._repository.get_ancestry(self._revision_id,
184
175
                                                 topo_sorted=False))
185
176
 
 
177
    def is_locked(self):
 
178
        return self._repository.is_locked()
 
179
 
 
180
    def lock_read(self):
 
181
        self._repository.lock_read()
 
182
        return self
 
183
 
 
184
    def __repr__(self):
 
185
        return '<%s instance at %x, rev_id=%r>' % (
 
186
            self.__class__.__name__, id(self), self._revision_id)
 
187
 
 
188
    def unlock(self):
 
189
        self._repository.unlock()
 
190
 
186
191
    def walkdirs(self, prefix=""):
187
192
        _directory = 'directory'
188
193
        inv = self.inventory
212
217
                if dir[2] == _directory:
213
218
                    pending.append(dir)
214
219
 
215
 
    def iter_files_bytes(self, desired_files):
216
 
        """See Tree.iter_files_bytes.
217
 
 
218
 
        This version is implemented on top of Repository.extract_files_bytes"""
219
 
        repo_desired_files = [(f, self.get_file_revision(f), i)
220
 
                              for f, i in desired_files]
221
 
        try:
222
 
            for result in self._repository.iter_files_bytes(repo_desired_files):
223
 
                yield result
224
 
        except errors.RevisionNotPresent, e:
225
 
            raise errors.NoSuchFile(e.revision_id)
226
 
 
227
 
    def annotate_iter(self, file_id,
228
 
                      default_revision=revision.CURRENT_REVISION):
229
 
        """See Tree.annotate_iter"""
230
 
        text_key = (file_id, self.get_file_revision(file_id))
231
 
        annotator = self._repository.texts.get_annotator()
232
 
        annotations = annotator.annotate_flat(text_key)
233
 
        return [(key[-1], line) for key, line in annotations]
 
220
    def _get_rules_searcher(self, default_searcher):
 
221
        """See Tree._get_rules_searcher."""
 
222
        if self._rules_searcher is None:
 
223
            self._rules_searcher = super(RevisionTree,
 
224
                self)._get_rules_searcher(default_searcher)
 
225
        return self._rules_searcher
234
226
 
235
227
 
236
228
class InterCHKRevisionTree(tree.InterTree):