← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/revisionspec.py

  • Committer: Lalo Martins
  • Date: 2005-09-08 00:40:15 UTC
  • mto: (1185.1.22)
  • mto: This revision was merged to the branch mainline in revision 1390.
  • Revision ID: lalo@exoweb.net-20050908004014-bb63b3378ac8ff58
turned get_revision_info into a RevisionSpec class

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/revisionspec.py
17
17
 
18
18
import datetime
19
19
import re
20
 
from bzrlib.errors import BzrError, NoSuchRevision, NoCommits
21
 
 
22
 
_marker = []
23
 
 
24
 
class RevisionInfo(object):
25
 
    """The results of applying a revision specification to a branch.
26
 
 
 
20
from bzrlib.errors import BzrError, NoSuchRevision
 
21
 
 
22
# Map some sort of prefix into a namespace
 
23
# stuff like "revno:10", "revid:", etc.
 
24
# This should match a prefix with a function which accepts it
 
25
REVISION_NAMESPACES = {}
 
26
 
 
27
class RevisionSpec(object):
 
28
    """Equivalent to the old get_revision_info().
27
29
    An instance has two useful attributes: revno, and rev_id.
28
30
 
29
31
    They can also be accessed as spec[0] and spec[1] respectively,
31
33
    revno, rev_id = RevisionSpec(branch, spec)
32
34
    although this is probably going to be deprecated later.
33
35
 
34
 
    This class exists mostly to be the return value of a RevisionSpec,
35
 
    so that you can access the member you're interested in (number or id)
36
 
    or treat the result as a tuple.
 
36
    Revision specs are an UI element, and they have been moved out
 
37
    of the branch class to leave "back-end" classes unaware of such
 
38
    details.  Code that gets a revno or rev_id from other code should
 
39
    not be using revision specs - revnos and revision ids are the
 
40
    accepted ways to refer to revisions internally.
37
41
    """
 
42
    def __init__(self, branch, spec):
 
43
        """Parse a revision specifier.
38
44
 
39
 
    def __init__(self, branch, revno, rev_id=_marker):
 
45
        spec can be an integer, in which case it is assumed to be revno
 
46
        (though this will translate negative values into positive ones)
 
47
        spec can also be a string, in which case it is parsed for something
 
48
        like 'date:' or 'revid:' etc.
 
49
        """
40
50
        self.branch = branch
41
 
        self.revno = revno
42
 
        if rev_id is _marker:
43
 
            # allow caller to be lazy
44
 
            if self.revno is None:
45
 
                self.rev_id = None
46
 
            else:
47
 
                self.rev_id = branch.get_rev_id(self.revno)
 
51
 
 
52
        if spec is None:
 
53
            self.revno = 0
 
54
            self.rev_id = None
 
55
            return
 
56
        self.revno = None
 
57
        try:# Convert to int if possible
 
58
            spec = int(spec)
 
59
        except ValueError:
 
60
            pass
 
61
        revs = branch.revision_history()
 
62
        if isinstance(spec, int):
 
63
            if spec < 0:
 
64
                self.revno = len(revs) + spec + 1
 
65
            else:
 
66
                self.revno = spec
 
67
            self.rev_id = branch.get_rev_id(self.revno, revs)
 
68
        elif isinstance(spec, basestring):
 
69
            for prefix, func in REVISION_NAMESPACES.iteritems():
 
70
                if spec.startswith(prefix):
 
71
                    result = func(branch, revs, spec)
 
72
                    if len(result) > 1:
 
73
                        self.revno, self.rev_id = result
 
74
                    else:
 
75
                        self.revno = result[0]
 
76
                        self.rev_id = branch.get_rev_id(self.revno, revs)
 
77
                    break
 
78
            else:
 
79
                raise BzrError('No namespace registered for string: %r' %
 
80
                               spec)
48
81
        else:
49
 
            self.rev_id = rev_id
 
82
            raise TypeError('Unhandled revision type %s' % spec)
50
83
 
51
 
    def __nonzero__(self):
52
 
        # first the easy ones...
53
 
        if self.rev_id is None:
54
 
            return False
55
 
        if self.revno is not None:
56
 
            return True
57
 
        # TODO: otherwise, it should depend on how I was built -
58
 
        # if it's in_history(branch), then check revision_history(),
59
 
        # if it's in_store(branch), do the check below
60
 
        return self.branch.revision_store.has_id(self.rev_id)
 
84
        if self.revno is None or self.rev_id is None:
 
85
            raise NoSuchRevision(branch, spec)
61
86
 
62
87
    def __len__(self):
63
88
        return 2
75
100
            return False
76
101
        if type(other) is type(self) and self.branch is not other.branch:
77
102
            return False
 
103
        print 'comparing', tuple(self), tuple(other)
78
104
        return tuple(self) == tuple(other)
79
105
 
80
106
    def __repr__(self):
81
 
        return '<bzrlib.revisionspec.RevisionInfo object %s, %s for %r>' % (
 
107
        return '<bzrlib.revisionspec.RevisionSpec object %s, %s for %r>' % (
82
108
            self.revno, self.rev_id, self.branch)
83
109
 
84
 
# classes in this list should have a "prefix" attribute, against which
85
 
# string specs are matched
86
 
SPEC_TYPES = []
87
 
 
88
 
class RevisionSpec(object):
89
 
    """A parsed revision specification.
90
 
 
91
 
    A revision specification can be an integer, in which case it is
92
 
    assumed to be a revno (though this will translate negative values
93
 
    into positive ones); or it can be a string, in which case it is
94
 
    parsed for something like 'date:' or 'revid:' etc.
95
 
 
96
 
    Revision specs are an UI element, and they have been moved out
97
 
    of the branch class to leave "back-end" classes unaware of such
98
 
    details.  Code that gets a revno or rev_id from other code should
99
 
    not be using revision specs - revnos and revision ids are the
100
 
    accepted ways to refer to revisions internally.
101
 
 
102
 
    (Equivalent to the old Branch method get_revision_info())
103
 
    """
104
 
 
105
 
    prefix = None
106
 
 
107
 
    def __new__(cls, spec, foo=_marker):
108
 
        """Parse a revision specifier.
109
 
        """
110
 
        if spec is None:
111
 
            return object.__new__(RevisionSpec, spec)
112
 
 
113
 
        try:
114
 
            spec = int(spec)
115
 
        except ValueError:
116
 
            pass
117
 
 
118
 
        if isinstance(spec, int):
119
 
            return object.__new__(RevisionSpec_int, spec)
120
 
        elif isinstance(spec, basestring):
121
 
            for spectype in SPEC_TYPES:
122
 
                if spec.startswith(spectype.prefix):
123
 
                    return object.__new__(spectype, spec)
124
 
            else:
125
 
                raise BzrError('No namespace registered for string: %r' %
126
 
                               spec)
127
 
        else:
128
 
            raise TypeError('Unhandled revision type %s' % spec)
129
 
 
130
 
    def __init__(self, spec):
131
 
        if self.prefix and spec.startswith(self.prefix):
132
 
            spec = spec[len(self.prefix):]
133
 
        self.spec = spec
134
 
 
135
 
    def _match_on(self, branch, revs):
136
 
        return RevisionInfo(branch, 0, None)
137
 
 
138
 
    def _match_on_and_check(self, branch, revs):
139
 
        info = self._match_on(branch, revs)
140
 
        if info:
141
 
            return info
142
 
        elif info == (0, None):
143
 
            # special case - the empty tree
144
 
            return info
145
 
        elif self.prefix:
146
 
            raise NoSuchRevision(branch, self.prefix + str(self.spec))
147
 
        else:
148
 
            raise NoSuchRevision(branch, str(self.spec))
149
 
 
150
 
    def in_history(self, branch):
151
 
        revs = branch.revision_history()
152
 
        return self._match_on_and_check(branch, revs)
153
 
 
154
 
        # FIXME: in_history is somewhat broken,
155
 
        # it will return non-history revisions in many
156
 
        # circumstances. The expected facility is that
157
 
        # in_history only returns revision-history revs,
158
 
        # in_store returns any rev. RBC 20051010
159
 
    # aliases for now, when we fix the core logic, then they
160
 
    # will do what you expect.
161
 
    in_store = in_history
162
 
    in_branch = in_store
163
 
        
164
 
    def __repr__(self):
165
 
        # this is mostly for helping with testing
166
 
        return '<%s %s%s>' % (self.__class__.__name__,
167
 
                              self.prefix or '',
168
 
                              self.spec)
169
 
 
170
110
 
171
111
# private API
172
112
 
173
 
class RevisionSpec_int(RevisionSpec):
174
 
    """Spec is a number.  Special case."""
175
 
    def __init__(self, spec):
176
 
        self.spec = int(spec)
177
 
 
178
 
    def _match_on(self, branch, revs):
179
 
        if self.spec < 0:
180
 
            revno = len(revs) + self.spec + 1
181
 
        else:
182
 
            revno = self.spec
183
 
        rev_id = branch.get_rev_id(revno, revs)
184
 
        return RevisionInfo(branch, revno, rev_id)
185
 
 
186
 
 
187
 
class RevisionSpec_revno(RevisionSpec):
188
 
    prefix = 'revno:'
189
 
 
190
 
    def _match_on(self, branch, revs):
191
 
        """Lookup a revision by revision number"""
192
 
        try:
193
 
            return RevisionInfo(branch, int(self.spec))
194
 
        except ValueError:
195
 
            return RevisionInfo(branch, None)
196
 
 
197
 
SPEC_TYPES.append(RevisionSpec_revno)
198
 
 
199
 
 
200
 
class RevisionSpec_revid(RevisionSpec):
201
 
    prefix = 'revid:'
202
 
 
203
 
    def _match_on(self, branch, revs):
204
 
        try:
205
 
            return RevisionInfo(branch, revs.index(self.spec) + 1, self.spec)
206
 
        except ValueError:
207
 
            return RevisionInfo(branch, None)
208
 
 
209
 
SPEC_TYPES.append(RevisionSpec_revid)
210
 
 
211
 
 
212
 
class RevisionSpec_last(RevisionSpec):
213
 
 
214
 
    prefix = 'last:'
215
 
 
216
 
    def _match_on(self, branch, revs):
217
 
        try:
218
 
            offset = int(self.spec)
219
 
        except ValueError:
220
 
            return RevisionInfo(branch, None)
221
 
        else:
222
 
            if offset <= 0:
223
 
                raise BzrError('You must supply a positive value for --revision last:XXX')
224
 
            return RevisionInfo(branch, len(revs) - offset + 1)
225
 
 
226
 
SPEC_TYPES.append(RevisionSpec_last)
227
 
 
228
 
 
229
 
class RevisionSpec_before(RevisionSpec):
230
 
 
231
 
    prefix = 'before:'
232
 
    
233
 
    def _match_on(self, branch, revs):
234
 
        r = RevisionSpec(self.spec)._match_on(branch, revs)
235
 
        if (r.revno is None) or (r.revno == 0):
236
 
            return r
237
 
        return RevisionInfo(branch, r.revno - 1)
238
 
 
239
 
SPEC_TYPES.append(RevisionSpec_before)
240
 
 
241
 
 
242
 
class RevisionSpec_tag(RevisionSpec):
243
 
    prefix = 'tag:'
244
 
 
245
 
    def _match_on(self, branch, revs):
246
 
        raise BzrError('tag: namespace registered, but not implemented.')
247
 
 
248
 
SPEC_TYPES.append(RevisionSpec_tag)
249
 
 
250
 
 
251
 
class RevisionSpec_date(RevisionSpec):
252
 
    prefix = 'date:'
253
 
    _date_re = re.compile(
254
 
            r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
255
 
            r'(,|T)?\s*'
256
 
            r'(?P<time>(?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d))?)?'
257
 
        )
258
 
 
259
 
    def _match_on(self, branch, revs):
260
 
        """
261
 
        Spec for date revisions:
262
 
          date:value
263
 
          value can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
264
 
          matches the first entry after a given date (either at midnight or
265
 
          at a specified time).
266
 
 
267
 
          So the proper way of saying 'give me all entries for today' is:
268
 
              -r date:today..date:tomorrow
269
 
        """
270
 
        today = datetime.datetime.fromordinal(datetime.date.today().toordinal())
271
 
        if self.spec.lower() == 'yesterday':
272
 
            dt = today - datetime.timedelta(days=1)
273
 
        elif self.spec.lower() == 'today':
274
 
            dt = today
275
 
        elif self.spec.lower() == 'tomorrow':
276
 
            dt = today + datetime.timedelta(days=1)
277
 
        else:
278
 
            m = self._date_re.match(self.spec)
279
 
            if not m or (not m.group('date') and not m.group('time')):
280
 
                raise BzrError('Invalid revision date %r' % self.spec)
281
 
 
282
 
            if m.group('date'):
283
 
                year, month, day = int(m.group('year')), int(m.group('month')), int(m.group('day'))
284
 
            else:
285
 
                year, month, day = today.year, today.month, today.day
286
 
            if m.group('time'):
287
 
                hour = int(m.group('hour'))
288
 
                minute = int(m.group('minute'))
289
 
                if m.group('second'):
290
 
                    second = int(m.group('second'))
291
 
                else:
292
 
                    second = 0
293
 
            else:
294
 
                hour, minute, second = 0,0,0
295
 
 
296
 
            dt = datetime.datetime(year=year, month=month, day=day,
297
 
                    hour=hour, minute=minute, second=second)
298
 
        first = dt
 
113
def _namespace_revno(branch, revs, spec):
 
114
    """Lookup a revision by revision number"""
 
115
    assert spec.startswith('revno:')
 
116
    try:
 
117
        return (int(spec[len('revno:'):]),)
 
118
    except ValueError:
 
119
        return (None,)
 
120
REVISION_NAMESPACES['revno:'] = _namespace_revno
 
121
 
 
122
 
 
123
def _namespace_revid(branch, revs, spec):
 
124
    assert spec.startswith('revid:')
 
125
    rev_id = spec[len('revid:'):]
 
126
    try:
 
127
        return revs.index(rev_id) + 1, rev_id
 
128
    except ValueError:
 
129
        return (None,)
 
130
REVISION_NAMESPACES['revid:'] = _namespace_revid
 
131
 
 
132
 
 
133
def _namespace_last(branch, revs, spec):
 
134
    assert spec.startswith('last:')
 
135
    try:
 
136
        offset = int(spec[5:])
 
137
    except ValueError:
 
138
        return (None,)
 
139
    else:
 
140
        if offset <= 0:
 
141
            raise BzrError('You must supply a positive value for --revision last:XXX')
 
142
        return (len(revs) - offset + 1,)
 
143
REVISION_NAMESPACES['last:'] = _namespace_last
 
144
 
 
145
 
 
146
def _namespace_tag(branch, revs, spec):
 
147
    assert spec.startswith('tag:')
 
148
    raise BzrError('tag: namespace registered, but not implemented.')
 
149
REVISION_NAMESPACES['tag:'] = _namespace_tag
 
150
 
 
151
 
 
152
_date_re = re.compile(
 
153
        r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
 
154
        r'(,|T)?\s*'
 
155
        r'(?P<time>(?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d))?)?'
 
156
    )
 
157
 
 
158
def _namespace_date(branch, revs, spec):
 
159
    """
 
160
    Spec for date revisions:
 
161
      date:value
 
162
      value can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
 
163
      it can also start with a '+/-/='. '+' says match the first
 
164
      entry after the given date. '-' is match the first entry before the date
 
165
      '=' is match the first entry after, but still on the given date.
 
166
    
 
167
      +2005-05-12 says find the first matching entry after May 12th, 2005 at 0:00
 
168
      -2005-05-12 says find the first matching entry before May 12th, 2005 at 0:00
 
169
      =2005-05-12 says find the first match after May 12th, 2005 at 0:00 but before
 
170
          May 13th, 2005 at 0:00
 
171
    
 
172
      So the proper way of saying 'give me all entries for today' is:
 
173
          -r {date:+today}:{date:-tomorrow}
 
174
      The default is '=' when not supplied
 
175
    """
 
176
    assert spec.startswith('date:')
 
177
    val = spec[5:]
 
178
    match_style = '='
 
179
    if val[:1] in ('+', '-', '='):
 
180
        match_style = val[:1]
 
181
        val = val[1:]
 
182
 
 
183
    # XXX: this should probably be using datetime.date instead
 
184
    today = datetime.datetime.today().replace(hour=0, minute=0, second=0,
 
185
                                              microsecond=0)
 
186
    if val.lower() == 'yesterday':
 
187
        dt = today - datetime.timedelta(days=1)
 
188
    elif val.lower() == 'today':
 
189
        dt = today
 
190
    elif val.lower() == 'tomorrow':
 
191
        dt = today + datetime.timedelta(days=1)
 
192
    else:
 
193
        m = _date_re.match(val)
 
194
        if not m or (not m.group('date') and not m.group('time')):
 
195
            raise BzrError('Invalid revision date %r' % spec)
 
196
 
 
197
        if m.group('date'):
 
198
            year, month, day = int(m.group('year')), int(m.group('month')), int(m.group('day'))
 
199
        else:
 
200
            year, month, day = today.year, today.month, today.day
 
201
        if m.group('time'):
 
202
            hour = int(m.group('hour'))
 
203
            minute = int(m.group('minute'))
 
204
            if m.group('second'):
 
205
                second = int(m.group('second'))
 
206
            else:
 
207
                second = 0
 
208
        else:
 
209
            hour, minute, second = 0,0,0
 
210
 
 
211
        dt = datetime.datetime(year=year, month=month, day=day,
 
212
                hour=hour, minute=minute, second=second)
 
213
    first = dt
 
214
    last = None
 
215
    reversed = False
 
216
    if match_style == '-':
 
217
        reversed = True
 
218
    elif match_style == '=':
 
219
        last = dt + datetime.timedelta(days=1)
 
220
 
 
221
    if reversed:
 
222
        for i in range(len(revs)-1, -1, -1):
 
223
            r = branch.get_revision(revs[i])
 
224
            # TODO: Handle timezone.
 
225
            dt = datetime.datetime.fromtimestamp(r.timestamp)
 
226
            if first >= dt and (last is None or dt >= last):
 
227
                return (i+1,)
 
228
    else:
299
229
        for i in range(len(revs)):
300
230
            r = branch.get_revision(revs[i])
301
231
            # TODO: Handle timezone.
302
232
            dt = datetime.datetime.fromtimestamp(r.timestamp)
303
 
            if first <= dt:
304
 
                return RevisionInfo(branch, i+1)
305
 
        return RevisionInfo(branch, None)
306
 
 
307
 
SPEC_TYPES.append(RevisionSpec_date)
308
 
 
309
 
 
310
 
class RevisionSpec_ancestor(RevisionSpec):
311
 
    prefix = 'ancestor:'
312
 
 
313
 
    def _match_on(self, branch, revs):
314
 
        from branch import Branch
315
 
        from revision import common_ancestor, MultipleRevisionSources
316
 
        other_branch = Branch.open_containing(self.spec)[0]
317
 
        revision_a = branch.last_revision()
318
 
        revision_b = other_branch.last_revision()
319
 
        for r, b in ((revision_a, branch), (revision_b, other_branch)):
320
 
            if r is None:
321
 
                raise NoCommits(b)
322
 
        revision_source = MultipleRevisionSources(branch, other_branch)
323
 
        rev_id = common_ancestor(revision_a, revision_b, revision_source)
324
 
        try:
325
 
            revno = branch.revision_id_to_revno(rev_id)
326
 
        except NoSuchRevision:
327
 
            revno = None
328
 
        return RevisionInfo(branch, revno, rev_id)
329
 
        
330
 
SPEC_TYPES.append(RevisionSpec_ancestor)
331
 
 
332
 
class RevisionSpec_branch(RevisionSpec):
333
 
    """A branch: revision specifier.
334
 
 
335
 
    This takes the path to a branch and returns its tip revision id.
336
 
    """
337
 
    prefix = 'branch:'
338
 
 
339
 
    def _match_on(self, branch, revs):
340
 
        from branch import Branch
341
 
        from fetch import greedy_fetch
342
 
        other_branch = Branch.open_containing(self.spec)[0]
343
 
        revision_b = other_branch.last_revision()
344
 
        if revision_b is None:
345
 
            raise NoCommits(other_branch)
346
 
        # pull in the remote revisions so we can diff
347
 
        greedy_fetch(branch, other_branch, revision=revision_b)
348
 
        try:
349
 
            revno = branch.revision_id_to_revno(revision_b)
350
 
        except NoSuchRevision:
351
 
            revno = None
352
 
        return RevisionInfo(branch, revno, revision_b)
353
 
        
354
 
SPEC_TYPES.append(RevisionSpec_branch)
 
233
            if first <= dt and (last is None or dt <= last):
 
234
                return (i+1,)
 
235
REVISION_NAMESPACES['date:'] = _namespace_date