~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/revision.py

  • Committer: Martin Pool
  • Date: 2005-05-26 02:13:57 UTC
  • Revision ID: mbp@sourcefrog.net-20050526021357-9a56decdca0c174f
- All top-level classes inherit from object
  (Python new-style classes)

Show diffs side-by-side

added added

removed removed

Lines of Context:
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
 
18
 
import bzrlib.errors
19
 
 
20
 
 
21
 
class RevisionReference(object):
22
 
    """
23
 
    Reference to a stored revision.
24
 
 
25
 
    Includes the revision_id and revision_sha1.
26
 
    """
27
 
    revision_id = None
28
 
    revision_sha1 = None
29
 
    def __init__(self, revision_id, revision_sha1=None):
30
 
        if revision_id == None \
31
 
           or isinstance(revision_id, basestring):
32
 
            self.revision_id = revision_id
33
 
        else:
34
 
            raise ValueError('bad revision_id %r' % revision_id)
35
 
 
36
 
        if revision_sha1 != None:
37
 
            if isinstance(revision_sha1, basestring) \
38
 
               and len(revision_sha1) == 40:
39
 
                self.revision_sha1 = revision_sha1
40
 
            else:
41
 
                raise ValueError('bad revision_sha1 %r' % revision_sha1)
42
 
                
43
 
 
44
 
 
45
 
class Revision(object):
 
18
 
 
19
 
 
20
from xml import XMLMixin
 
21
 
 
22
try:
 
23
    from cElementTree import Element, ElementTree, SubElement
 
24
except ImportError:
 
25
    from elementtree.ElementTree import Element, ElementTree, SubElement
 
26
 
 
27
from errors import BzrError
 
28
 
 
29
 
 
30
class Revision(XMLMixin):
46
31
    """Single revision on a branch.
47
32
 
48
33
    Revisions may know their revision_hash, but only once they've been
49
34
    written out.  This is not stored because you cannot write the hash
50
35
    into the file it describes.
51
36
 
52
 
    After bzr 0.0.5 revisions are allowed to have multiple parents.
53
 
 
54
 
    parents
55
 
        List of parent revisions, each is a RevisionReference.
 
37
    TODO: Perhaps make predecessor be a child element, not an attribute?
56
38
    """
57
 
    inventory_id = None
58
 
    inventory_sha1 = None
59
 
    revision_id = None
60
 
    timestamp = None
61
 
    message = None
62
 
    timezone = None
63
 
    committer = None
64
 
    
65
39
    def __init__(self, **args):
 
40
        self.inventory_id = None
 
41
        self.revision_id = None
 
42
        self.timestamp = None
 
43
        self.message = None
 
44
        self.timezone = None
 
45
        self.committer = None
 
46
        self.precursor = None
66
47
        self.__dict__.update(args)
67
 
        self.parents = []
68
48
 
69
49
 
70
50
    def __repr__(self):
72
52
 
73
53
        
74
54
    def to_element(self):
75
 
        from bzrlib.xml import Element, SubElement
76
 
        
77
55
        root = Element('revision',
78
56
                       committer = self.committer,
79
57
                       timestamp = '%.9f' % self.timestamp,
80
58
                       revision_id = self.revision_id,
81
59
                       inventory_id = self.inventory_id,
82
 
                       inventory_sha1 = self.inventory_sha1,
83
 
                       )
84
 
        if self.timezone:
85
 
            root.set('timezone', str(self.timezone))
 
60
                       timezone = str(self.timezone))
 
61
        if self.precursor:
 
62
            root.set('precursor', self.precursor)
86
63
        root.text = '\n'
87
64
        
88
65
        msg = SubElement(root, 'message')
89
66
        msg.text = self.message
90
67
        msg.tail = '\n'
91
68
 
92
 
        if self.parents:
93
 
            pelts = SubElement(root, 'parents')
94
 
            pelts.tail = pelts.text = '\n'
95
 
            for rr in self.parents:
96
 
                assert isinstance(rr, RevisionReference)
97
 
                p = SubElement(pelts, 'revision_ref')
98
 
                p.tail = '\n'
99
 
                assert rr.revision_id
100
 
                p.set('revision_id', rr.revision_id)
101
 
                if rr.revision_sha1:
102
 
                    p.set('revision_sha1', rr.revision_sha1)
103
 
 
104
69
        return root
105
70
 
106
71
 
107
72
    def from_element(cls, elt):
108
 
        return unpack_revision(elt)
 
73
        # <changeset> is deprecated...
 
74
        if elt.tag not in ('revision', 'changeset'):
 
75
            raise BzrError("unexpected tag in revision file: %r" % elt)
 
76
 
 
77
        cs = cls(committer = elt.get('committer'),
 
78
                 timestamp = float(elt.get('timestamp')),
 
79
                 precursor = elt.get('precursor'),
 
80
                 revision_id = elt.get('revision_id'),
 
81
                 inventory_id = elt.get('inventory_id'))
 
82
 
 
83
        v = elt.get('timezone')
 
84
        cs.timezone = v and int(v)
 
85
 
 
86
        cs.message = elt.findtext('message') # text of <message>
 
87
        return cs
109
88
 
110
89
    from_element = classmethod(from_element)
111
90
 
112
 
 
113
 
 
114
 
def unpack_revision(elt):
115
 
    """Convert XML element into Revision object."""
116
 
    # <changeset> is deprecated...
117
 
    if elt.tag not in ('revision', 'changeset'):
118
 
        raise bzrlib.errors.BzrError("unexpected tag in revision file: %r" % elt)
119
 
 
120
 
    rev = Revision(committer = elt.get('committer'),
121
 
                   timestamp = float(elt.get('timestamp')),
122
 
                   revision_id = elt.get('revision_id'),
123
 
                   inventory_id = elt.get('inventory_id'),
124
 
                   inventory_sha1 = elt.get('inventory_sha1')
125
 
                   )
126
 
 
127
 
    precursor = elt.get('precursor')
128
 
    precursor_sha1 = elt.get('precursor_sha1')
129
 
 
130
 
    pelts = elt.find('parents')
131
 
 
132
 
    if pelts:
133
 
        for p in pelts:
134
 
            assert p.tag == 'revision_ref', \
135
 
                   "bad parent node tag %r" % p.tag
136
 
            rev_ref = RevisionReference(p.get('revision_id'),
137
 
                                        p.get('revision_sha1'))
138
 
            rev.parents.append(rev_ref)
139
 
 
140
 
        if precursor:
141
 
            # must be consistent
142
 
            prec_parent = rev.parents[0].revision_id
143
 
            assert prec_parent == precursor
144
 
    elif precursor:
145
 
        # revisions written prior to 0.0.5 have a single precursor
146
 
        # give as an attribute
147
 
        rev_ref = RevisionReference(precursor, precursor_sha1)
148
 
        rev.parents.append(rev_ref)
149
 
 
150
 
    v = elt.get('timezone')
151
 
    rev.timezone = v and int(v)
152
 
 
153
 
    rev.message = elt.findtext('message') # text of <message>
154
 
    return rev
155
 
 
156
 
 
157
 
 
158
 
REVISION_ID_RE = None
159
 
 
160
 
def validate_revision_id(rid):
161
 
    """Check rid is syntactically valid for a revision id."""
162
 
    global REVISION_ID_RE
163
 
    if not REVISION_ID_RE:
164
 
        import re
165
 
        REVISION_ID_RE = re.compile('[\w.-]+@[\w.-]+--?\d+--?[0-9a-f]+\Z')
166
 
 
167
 
    if not REVISION_ID_RE.match(rid):
168
 
        raise ValueError("malformed revision-id %r" % rid)
169
 
 
170
 
def is_ancestor(revision_id, candidate_id, revision_source):
171
 
    """Return true if candidate_id is an ancestor of revision_id.
172
 
    A false negative will be returned if any intermediate descendent of
173
 
    candidate_id is not present in any of the revision_sources.
174
 
    
175
 
    revisions_source is an object supporting a get_revision operation that
176
 
    behaves like Branch's.
177
 
    """
178
 
 
179
 
    ancestors = (revision_id,)
180
 
    while len(ancestors) > 0:
181
 
        new_ancestors = []
182
 
        for ancestor in ancestors:
183
 
            if ancestor == candidate_id:
184
 
                return True
185
 
            try:
186
 
                revision = revision_source.get_revision(ancestor)
187
 
            except bzrlib.errors.NoSuchRevision, e:
188
 
                if e.revision == revision_id:
189
 
                    raise 
190
 
                else:
191
 
                    continue
192
 
            new_ancestors.extend([p.revision_id for p in revision.parents])
193
 
        ancestors = new_ancestors
194
 
 
195
 
 
196
 
class MultipleRevisionSources(object):
197
 
    def __init__(self, *args):
198
 
        object.__init__(self)
199
 
        assert len(args) != 0
200
 
        self._revision_sources = args
201
 
 
202
 
    def get_revision(self, revision_id):
203
 
        for source in self._revision_sources:
204
 
            try:
205
 
                return source.get_revision(revision_id)
206
 
            except bzrlib.errors.NoSuchRevision, e:
207
 
                pass
208
 
        raise e