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

- stub for revision properties

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005-2010 Canonical Ltd
2
 
#
 
1
# (C) 2005 Canonical
 
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
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
17
 
# TODO: Some kind of command-line display of revision properties:
18
 
# perhaps show them in log -v and allow them as options to the commit command.
19
 
 
20
 
 
21
 
from bzrlib.lazy_import import lazy_import
22
 
lazy_import(globals(), """
23
 
from bzrlib import deprecated_graph
24
 
from bzrlib import bugtracker
25
 
""")
26
 
from bzrlib import (
27
 
    errors,
28
 
    symbol_versioning,
29
 
    )
30
 
from bzrlib.osutils import contains_whitespace
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
 
 
18
import bzrlib.errors
 
19
from bzrlib.graph import node_distances, select_farthest, all_descendants
31
20
 
32
21
NULL_REVISION="null:"
33
 
CURRENT_REVISION="current:"
34
 
 
35
22
 
36
23
class Revision(object):
37
24
    """Single revision on a branch.
44
31
 
45
32
    parent_ids
46
33
        List of parent revision_ids
47
 
 
48
 
    properties
49
 
        Dictionary of revision properties.  These are attached to the
50
 
        revision as extra metadata.  The name must be a single
51
 
        word; the value can be an arbitrary string.
52
34
    """
53
 
 
 
35
    
54
36
    def __init__(self, revision_id, properties=None, **args):
55
37
        self.revision_id = revision_id
56
 
        if properties is None:
57
 
            self.properties = {}
58
 
        else:
59
 
            self.properties = properties
60
 
            self._check_properties()
61
 
        self.committer = None
 
38
        self.properties = properties or {}
 
39
        self.__dict__.update(args)
62
40
        self.parent_ids = []
63
41
        self.parent_sha1s = []
64
 
        """Not used anymore - legacy from for 4."""
65
 
        self.__dict__.update(args)
66
42
 
67
43
    def __repr__(self):
68
44
        return "<Revision id %s>" % self.revision_id
70
46
    def __eq__(self, other):
71
47
        if not isinstance(other, Revision):
72
48
            return False
 
49
        # FIXME: rbc 20050930 parent_ids are not being compared
73
50
        return (
74
51
                self.inventory_sha1 == other.inventory_sha1
75
52
                and self.revision_id == other.revision_id
77
54
                and self.message == other.message
78
55
                and self.timezone == other.timezone
79
56
                and self.committer == other.committer
80
 
                and self.properties == other.properties
81
 
                and self.parent_ids == other.parent_ids)
 
57
                and self.properties == other.properties)
82
58
 
83
59
    def __ne__(self, other):
84
60
        return not self.__eq__(other)
85
61
 
86
 
    def _check_properties(self):
87
 
        """Verify that all revision properties are OK."""
88
 
        for name, value in self.properties.iteritems():
89
 
            if not isinstance(name, basestring) or contains_whitespace(name):
90
 
                raise ValueError("invalid property name %r" % name)
91
 
            if not isinstance(value, basestring):
92
 
                raise ValueError("invalid property value %r for %r" %
93
 
                                 (value, name))
94
 
 
95
 
    def get_history(self, repository):
96
 
        """Return the canonical line-of-history for this revision.
97
 
 
98
 
        If ghosts are present this may differ in result from a ghost-free
99
 
        repository.
100
 
        """
101
 
        current_revision = self
102
 
        reversed_result = []
103
 
        while current_revision is not None:
104
 
            reversed_result.append(current_revision.revision_id)
105
 
            if not len (current_revision.parent_ids):
106
 
                reversed_result.append(None)
107
 
                current_revision = None
108
 
            else:
109
 
                next_revision_id = current_revision.parent_ids[0]
110
 
                current_revision = repository.get_revision(next_revision_id)
111
 
        reversed_result.reverse()
112
 
        return reversed_result
113
 
 
114
 
    def get_summary(self):
115
 
        """Get the first line of the log message for this revision.
116
 
 
117
 
        Return an empty string if message is None.
118
 
        """
119
 
        if self.message:
120
 
            return self.message.lstrip().split('\n', 1)[0]
121
 
        else:
122
 
            return ''
123
 
 
124
 
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((1, 13, 0)))
125
 
    def get_apparent_author(self):
126
 
        """Return the apparent author of this revision.
127
 
 
128
 
        This method is deprecated in favour of get_apparent_authors.
129
 
 
130
 
        If the revision properties contain any author names,
131
 
        return the first. Otherwise return the committer name.
132
 
        """
133
 
        authors = self.get_apparent_authors()
134
 
        if authors:
135
 
            return authors[0]
136
 
        else:
137
 
            return None
138
 
 
139
 
    def get_apparent_authors(self):
140
 
        """Return the apparent authors of this revision.
141
 
 
142
 
        If the revision properties contain the names of the authors,
143
 
        return them. Otherwise return the committer name.
144
 
 
145
 
        The return value will be a list containing at least one element.
146
 
        """
147
 
        authors = self.properties.get('authors', None)
148
 
        if authors is None:
149
 
            author = self.properties.get('author', self.committer)
150
 
            if author is None:
151
 
                return []
152
 
            return [author]
153
 
        else:
154
 
            return authors.split("\n")
155
 
 
156
 
    def iter_bugs(self):
157
 
        """Iterate over the bugs associated with this revision."""
158
 
        bug_property = self.properties.get('bugs', None)
159
 
        if bug_property is None:
160
 
            return
161
 
        for line in bug_property.splitlines():
162
 
            try:
163
 
                url, status = line.split(None, 2)
164
 
            except ValueError:
165
 
                raise errors.InvalidLineInBugsProperty(line)
166
 
            if status not in bugtracker.ALLOWED_BUG_STATUSES:
167
 
                raise errors.InvalidBugStatus(status)
168
 
            yield url, status
 
62
 
 
63
def is_ancestor(revision_id, candidate_id, branch):
 
64
    """Return true if candidate_id is an ancestor of revision_id.
 
65
 
 
66
    A false negative will be returned if any intermediate descendent of
 
67
    candidate_id is not present in any of the revision_sources.
 
68
    
 
69
    revisions_source is an object supporting a get_revision operation that
 
70
    behaves like Branch's.
 
71
    """
 
72
    return candidate_id in branch.get_ancestry(revision_id)
169
73
 
170
74
 
171
75
def iter_ancestors(revision_id, revision_source, only_present=False):
178
82
                yield ancestor, distance
179
83
            try:
180
84
                revision = revision_source.get_revision(ancestor)
181
 
            except errors.NoSuchRevision, e:
 
85
            except bzrlib.errors.NoSuchRevision, e:
182
86
                if e.revision == revision_id:
183
 
                    raise
 
87
                    raise 
184
88
                else:
185
89
                    continue
186
90
            if only_present:
194
98
    """Return the ancestors of a revision present in a branch.
195
99
 
196
100
    It's possible that a branch won't have the complete ancestry of
197
 
    one of its revisions.
 
101
    one of its revisions.  
198
102
 
199
103
    """
200
104
    found_ancestors = {}
201
105
    anc_iter = enumerate(iter_ancestors(revision_id, revision_source,
202
106
                         only_present=True))
203
107
    for anc_order, (anc_id, anc_distance) in anc_iter:
204
 
        if anc_id not in found_ancestors:
 
108
        if not found_ancestors.has_key(anc_id):
205
109
            found_ancestors[anc_id] = (anc_order, anc_distance)
206
110
    return found_ancestors
207
 
 
 
111
    
208
112
 
209
113
def __get_closest(intersection):
210
114
    intersection.sort()
211
 
    matches = []
 
115
    matches = [] 
212
116
    for entry in intersection:
213
117
        if entry[0] == intersection[0][0]:
214
118
            matches.append(entry[2])
215
119
    return matches
216
120
 
217
121
 
218
 
def is_reserved_id(revision_id):
219
 
    """Determine whether a revision id is reserved
220
 
 
221
 
    :return: True if the revision is reserved, False otherwise
 
122
def old_common_ancestor(revision_a, revision_b, revision_source):
 
123
    """Find the ancestor common to both revisions that is closest to both.
222
124
    """
223
 
    return isinstance(revision_id, basestring) and revision_id.endswith(':')
224
 
 
225
 
 
226
 
def check_not_reserved_id(revision_id):
227
 
    """Raise ReservedId if the supplied revision_id is reserved"""
228
 
    if is_reserved_id(revision_id):
229
 
        raise errors.ReservedId(revision_id)
230
 
 
231
 
 
232
 
def ensure_null(revision_id):
233
 
    """Ensure only NULL_REVISION is used to represent the null revision"""
234
 
    if revision_id is None:
235
 
        symbol_versioning.warn('NULL_REVISION should be used for the null'
236
 
            ' revision instead of None, as of bzr 0.91.',
237
 
            DeprecationWarning, stacklevel=2)
238
 
        return NULL_REVISION
 
125
    from bzrlib.trace import mutter
 
126
    a_ancestors = find_present_ancestors(revision_a, revision_source)
 
127
    b_ancestors = find_present_ancestors(revision_b, revision_source)
 
128
    a_intersection = []
 
129
    b_intersection = []
 
130
    # a_order is used as a tie-breaker when two equally-good bases are found
 
131
    for revision, (a_order, a_distance) in a_ancestors.iteritems():
 
132
        if b_ancestors.has_key(revision):
 
133
            a_intersection.append((a_distance, a_order, revision))
 
134
            b_intersection.append((b_ancestors[revision][1], a_order, revision))
 
135
    mutter("a intersection: %r" % a_intersection)
 
136
    mutter("b intersection: %r" % b_intersection)
 
137
 
 
138
    a_closest = __get_closest(a_intersection)
 
139
    if len(a_closest) == 0:
 
140
        return None
 
141
    b_closest = __get_closest(b_intersection)
 
142
    assert len(b_closest) != 0
 
143
    mutter ("a_closest %r" % a_closest)
 
144
    mutter ("b_closest %r" % b_closest)
 
145
    if a_closest[0] in b_closest:
 
146
        return a_closest[0]
 
147
    elif b_closest[0] in a_closest:
 
148
        return b_closest[0]
239
149
    else:
240
 
        return revision_id
241
 
 
242
 
 
243
 
def is_null(revision_id):
244
 
    if revision_id is None:
245
 
        symbol_versioning.warn('NULL_REVISION should be used for the null'
246
 
            ' revision instead of None, as of bzr 0.90.',
247
 
            DeprecationWarning, stacklevel=2)
248
 
    return revision_id in (None, NULL_REVISION)
 
150
        raise bzrlib.errors.AmbiguousBase((a_closest[0], b_closest[0]))
 
151
    return a_closest[0]
 
152
 
 
153
def revision_graph(revision, revision_source):
 
154
    """Produce a graph of the ancestry of the specified revision.
 
155
    Return root, ancestors map, descendants map
 
156
 
 
157
    TODO: Produce graphs with the NULL revision as root, so that we can find
 
158
    a common even when trees are not branches don't represent a single line
 
159
    of descent.
 
160
    """
 
161
    ancestors = {}
 
162
    descendants = {}
 
163
    lines = [revision]
 
164
    root = None
 
165
    descendants[revision] = {}
 
166
    while len(lines) > 0:
 
167
        new_lines = set()
 
168
        for line in lines:
 
169
            if line == NULL_REVISION:
 
170
                parents = []
 
171
                root = NULL_REVISION
 
172
            else:
 
173
                try:
 
174
                    rev = revision_source.get_revision(line)
 
175
                    parents = list(rev.parent_ids)
 
176
                    if len(parents) == 0:
 
177
                        parents = [NULL_REVISION]
 
178
                except bzrlib.errors.NoSuchRevision:
 
179
                    if line == revision:
 
180
                        raise
 
181
                    parents = None
 
182
            if parents is not None:
 
183
                for parent in parents:
 
184
                    if parent not in ancestors:
 
185
                        new_lines.add(parent)
 
186
                    if parent not in descendants:
 
187
                        descendants[parent] = {}
 
188
                    descendants[parent][line] = 1
 
189
            if parents is not None:
 
190
                ancestors[line] = set(parents)
 
191
        lines = new_lines
 
192
    assert root not in descendants[root]
 
193
    assert root not in ancestors[root]
 
194
    return root, ancestors, descendants
 
195
 
 
196
 
 
197
def combined_graph(revision_a, revision_b, revision_source):
 
198
    """Produce a combined ancestry graph.
 
199
    Return graph root, ancestors map, descendants map, set of common nodes"""
 
200
    root, ancestors, descendants = revision_graph(revision_a, revision_source)
 
201
    root_b, ancestors_b, descendants_b = revision_graph(revision_b, 
 
202
                                                        revision_source)
 
203
    if root != root_b:
 
204
        raise bzrlib.errors.NoCommonRoot(revision_a, revision_b)
 
205
    common = set()
 
206
    for node, node_anc in ancestors_b.iteritems():
 
207
        if node in ancestors:
 
208
            common.add(node)
 
209
        else:
 
210
            ancestors[node] = set()
 
211
        ancestors[node].update(node_anc)
 
212
    for node, node_dec in descendants_b.iteritems():
 
213
        if node not in descendants:
 
214
            descendants[node] = {}
 
215
        descendants[node].update(node_dec)
 
216
    return root, ancestors, descendants, common
 
217
 
 
218
 
 
219
def common_ancestor(revision_a, revision_b, revision_source):
 
220
    try:
 
221
        root, ancestors, descendants, common = \
 
222
            combined_graph(revision_a, revision_b, revision_source)
 
223
    except bzrlib.errors.NoCommonRoot:
 
224
        raise bzrlib.errors.NoCommonAncestor(revision_a, revision_b)
 
225
        
 
226
    distances = node_distances (descendants, ancestors, root)
 
227
    farthest = select_farthest(distances, common)
 
228
    if farthest is None or farthest == NULL_REVISION:
 
229
        raise bzrlib.errors.NoCommonAncestor(revision_a, revision_b)
 
230
    return farthest
 
231
 
 
232
 
 
233
class MultipleRevisionSources(object):
 
234
    """Proxy that looks in multiple branches for revisions."""
 
235
    def __init__(self, *args):
 
236
        object.__init__(self)
 
237
        assert len(args) != 0
 
238
        self._revision_sources = args
 
239
 
 
240
    def get_revision(self, revision_id):
 
241
        for source in self._revision_sources:
 
242
            try:
 
243
                return source.get_revision(revision_id)
 
244
            except bzrlib.errors.NoSuchRevision, e:
 
245
                pass
 
246
        raise e
 
247
 
 
248
def get_intervening_revisions(ancestor_id, rev_id, rev_source, 
 
249
                              revision_history=None):
 
250
    """Find the longest line of descent from maybe_ancestor to revision.
 
251
    Revision history is followed where possible.
 
252
 
 
253
    If ancestor_id == rev_id, list will be empty.
 
254
    Otherwise, rev_id will be the last entry.  ancestor_id will never appear.
 
255
    If ancestor_id is not an ancestor, NotAncestor will be thrown
 
256
    """
 
257
    root, ancestors, descendants = revision_graph(rev_id, rev_source)
 
258
    if len(descendants) == 0:
 
259
        raise NoSuchRevision(rev_source, rev_id)
 
260
    if ancestor_id not in descendants:
 
261
        rev_source.get_revision(ancestor_id)
 
262
        raise bzrlib.errors.NotAncestor(rev_id, ancestor_id)
 
263
    root_descendants = all_descendants(descendants, ancestor_id)
 
264
    root_descendants.add(ancestor_id)
 
265
    if rev_id not in root_descendants:
 
266
        raise bzrlib.errors.NotAncestor(rev_id, ancestor_id)
 
267
    distances = node_distances(descendants, ancestors, ancestor_id,
 
268
                               root_descendants=root_descendants)
 
269
 
 
270
    def best_ancestor(rev_id):
 
271
        best = None
 
272
        for anc_id in ancestors[rev_id]:
 
273
            try:
 
274
                distance = distances[anc_id]
 
275
            except KeyError:
 
276
                continue
 
277
            if revision_history is not None and anc_id in revision_history:
 
278
                return anc_id
 
279
            elif best is None or distance > best[1]:
 
280
                best = (anc_id, distance)
 
281
        return best[0]
 
282
 
 
283
    next = rev_id
 
284
    path = []
 
285
    while next != ancestor_id:
 
286
        path.append(next)
 
287
        next = best_ancestor(next)
 
288
    path.reverse()
 
289
    return path