1
# Copyright (C) 2005 Canonical Ltd
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.
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.
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
33
class RevisionInfo(object):
34
"""The results of applying a revision specification to a branch.
36
An instance has two useful attributes: revno, and rev_id.
38
They can also be accessed as spec[0] and spec[1] respectively,
39
so that you can write code like:
40
revno, rev_id = RevisionSpec(branch, spec)
41
although this is probably going to be deprecated later.
43
This class exists mostly to be the return value of a RevisionSpec,
44
so that you can access the member you're interested in (number or id)
45
or treat the result as a tuple.
48
def __init__(self, branch, revno, rev_id=_marker):
52
# allow caller to be lazy
53
if self.revno is None:
56
self.rev_id = branch.get_rev_id(self.revno)
60
def __nonzero__(self):
61
# first the easy ones...
62
if self.rev_id is None:
64
if self.revno is not None:
66
# TODO: otherwise, it should depend on how I was built -
67
# if it's in_history(branch), then check revision_history(),
68
# if it's in_store(branch), do the check below
69
return self.branch.repository.has_revision(self.rev_id)
74
def __getitem__(self, index):
75
if index == 0: return self.revno
76
if index == 1: return self.rev_id
77
raise IndexError(index)
80
return self.branch.repository.get_revision(self.rev_id)
82
def __eq__(self, other):
83
if type(other) not in (tuple, list, type(self)):
85
if type(other) is type(self) and self.branch is not other.branch:
87
return tuple(self) == tuple(other)
90
return '<bzrlib.revisionspec.RevisionInfo object %s, %s for %r>' % (
91
self.revno, self.rev_id, self.branch)
94
# classes in this list should have a "prefix" attribute, against which
95
# string specs are matched
99
class RevisionSpec(object):
100
"""A parsed revision specification.
102
A revision specification can be an integer, in which case it is
103
assumed to be a revno (though this will translate negative values
104
into positive ones); or it can be a string, in which case it is
105
parsed for something like 'date:' or 'revid:' etc.
107
Revision specs are an UI element, and they have been moved out
108
of the branch class to leave "back-end" classes unaware of such
109
details. Code that gets a revno or rev_id from other code should
110
not be using revision specs - revnos and revision ids are the
111
accepted ways to refer to revisions internally.
113
(Equivalent to the old Branch method get_revision_info())
118
def __new__(cls, spec, _internal=False):
120
return object.__new__(cls, spec, _internal=_internal)
122
symbol_versioning.warn('Creating a RevisionSpec directly has'
123
' been deprecated in version 0.11. Use'
124
' bzrlib.revisionspec.get_revision_spec()'
126
DeprecationWarning, stacklevel=2)
127
return get_revision_spec(spec)
129
def __init__(self, spec, _internal=False):
130
"""Create a RevisionSpec referring to the Null revision.
132
:param spec: The original spec supplied by the user
133
:param _internal: Used to ensure that RevisionSpec is not being
134
called directly. Only from get_revision_spec()
137
# XXX: Update this after 0.10 is released
138
symbol_versioning.warn('Creating a RevisionSpec directly has'
139
' been deprecated in version 0.11. Use'
140
' bzrlib.revisionspec.get_revision_spec()'
142
DeprecationWarning, stacklevel=2)
143
self.user_spec = spec
144
if self.prefix and spec.startswith(self.prefix):
145
spec = spec[len(self.prefix):]
148
def _match_on(self, branch, revs):
149
trace.mutter('Returning RevisionSpec._match_on: None')
150
return RevisionInfo(branch, 0, None)
152
def _match_on_and_check(self, branch, revs):
153
info = self._match_on(branch, revs)
156
elif info == (0, None):
157
# special case - the empty tree
160
raise errors.InvalidRevisionSpec(self.user_spec, branch)
162
raise errors.InvalidRevisionSpec(self.spec, branch)
164
def in_history(self, branch):
166
revs = branch.revision_history()
169
return self._match_on_and_check(branch, revs)
171
# FIXME: in_history is somewhat broken,
172
# it will return non-history revisions in many
173
# circumstances. The expected facility is that
174
# in_history only returns revision-history revs,
175
# in_store returns any rev. RBC 20051010
176
# aliases for now, when we fix the core logic, then they
177
# will do what you expect.
178
in_store = in_history
182
# this is mostly for helping with testing
183
return '<%s %s%s>' % (self.__class__.__name__,
187
def needs_branch(self):
188
"""Whether this revision spec needs a branch.
190
Set this to False the branch argument of _match_on is not used.
197
def get_revision_spec(spec):
198
"""Parse a revision spec into a RevisionSpec object.
200
:param spec: A string specified by the user
201
:return: A RevisionSpec object that understands how to parse the
204
if not isinstance(spec, (type(None), basestring)):
205
raise TypeError('error')
208
return RevisionSpec(None, _internal=True)
210
assert isinstance(spec, basestring), \
211
"You should only supply strings not %s" % (type(spec),)
213
for spectype in SPEC_TYPES:
214
if spec.startswith(spectype.prefix):
215
trace.mutter('Returning RevisionSpec %s for %s',
216
spectype.__name__, spec)
217
return spectype(spec, _internal=True)
219
# RevisionSpec_revno is special cased, because it is the only
220
# one that directly handles plain integers
222
if _revno_regex is None:
223
_revno_regex = re.compile(r'-?\d+(:.*)?')
224
if _revno_regex.match(spec) is not None:
225
return RevisionSpec_revno(spec, _internal=True)
227
raise errors.NoSuchRevisionSpec(spec)
233
class RevisionSpec_revno(RevisionSpec):
236
def _match_on(self, branch, revs):
237
"""Lookup a revision by revision number"""
238
loc = self.spec.find(':')
240
revno_spec = self.spec
243
revno_spec = self.spec[:loc]
244
branch_spec = self.spec[loc+1:]
248
raise errors.InvalidRevisionSpec(self.user_spec,
249
branch, 'cannot have an empty revno and no branch')
253
revno = int(revno_spec)
254
except ValueError, e:
255
raise errors.InvalidRevisionSpec(self.user_spec,
259
from bzrlib.branch import Branch
260
branch = Branch.open(branch_spec)
261
# Need to use a new revision history
262
# because we are using a specific branch
263
revs = branch.revision_history()
266
if (-revno) >= len(revs):
269
revno = len(revs) + revno + 1
271
revision_id = branch.get_rev_id(revno, revs)
272
except errors.NoSuchRevision:
273
raise errors.InvalidRevisionSpec(self.user_spec, branch)
274
return RevisionInfo(branch, revno, revision_id)
276
def needs_branch(self):
277
return self.spec.find(':') == -1
280
RevisionSpec_int = RevisionSpec_revno
282
SPEC_TYPES.append(RevisionSpec_revno)
285
class RevisionSpec_revid(RevisionSpec):
288
def _match_on(self, branch, revs):
290
revno = revs.index(self.spec) + 1
293
return RevisionInfo(branch, revno, self.spec)
295
SPEC_TYPES.append(RevisionSpec_revid)
298
class RevisionSpec_last(RevisionSpec):
302
def _match_on(self, branch, revs):
305
raise errors.NoCommits(branch)
306
return RevisionInfo(branch, len(revs), revs[-1])
309
offset = int(self.spec)
310
except ValueError, e:
311
raise errors.InvalidRevisionSpec(self.user_spec, branch, e)
314
raise errors.InvalidRevisionSpec(self.user_spec, branch,
315
'you must supply a positive value')
316
revno = len(revs) - offset + 1
318
revision_id = branch.get_rev_id(revno, revs)
319
except errors.NoSuchRevision:
320
raise errors.InvalidRevisionSpec(self.user_spec, branch)
321
return RevisionInfo(branch, revno, revision_id)
323
SPEC_TYPES.append(RevisionSpec_last)
326
class RevisionSpec_before(RevisionSpec):
330
def _match_on(self, branch, revs):
331
r = get_revision_spec(self.spec)._match_on(branch, revs)
333
raise errors.InvalidRevisionSpec(self.user_spec, branch,
334
'cannot go before the null: revision')
336
# We need to use the repository history here
337
rev = branch.repository.get_revision(r.rev_id)
338
if not rev.parent_ids:
342
revision_id = rev.parent_ids[0]
344
revno = revs.index(revision_id) + 1
350
revision_id = branch.get_rev_id(revno, revs)
351
except errors.NoSuchRevision:
352
raise errors.InvalidRevisionSpec(self.user_spec,
354
return RevisionInfo(branch, revno, revision_id)
356
SPEC_TYPES.append(RevisionSpec_before)
359
class RevisionSpec_tag(RevisionSpec):
362
def _match_on(self, branch, revs):
363
raise errors.InvalidRevisionSpec(self.user_spec, branch,
364
'tag: namespace registered,'
365
' but not implemented')
367
SPEC_TYPES.append(RevisionSpec_tag)
370
class _RevListToTimestamps(object):
371
"""This takes a list of revisions, and allows you to bisect by date"""
373
__slots__ = ['revs', 'branch']
375
def __init__(self, revs, branch):
379
def __getitem__(self, index):
380
"""Get the date of the index'd item"""
381
r = self.branch.repository.get_revision(self.revs[index])
382
# TODO: Handle timezone.
383
return datetime.datetime.fromtimestamp(r.timestamp)
386
return len(self.revs)
389
class RevisionSpec_date(RevisionSpec):
391
_date_re = re.compile(
392
r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
394
r'(?P<time>(?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d))?)?'
397
def _match_on(self, branch, revs):
399
Spec for date revisions:
401
value can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
402
matches the first entry after a given date (either at midnight or
403
at a specified time).
405
So the proper way of saying 'give me all entries for today' is:
406
-r date:yesterday..date:today
408
today = datetime.datetime.fromordinal(datetime.date.today().toordinal())
409
if self.spec.lower() == 'yesterday':
410
dt = today - datetime.timedelta(days=1)
411
elif self.spec.lower() == 'today':
413
elif self.spec.lower() == 'tomorrow':
414
dt = today + datetime.timedelta(days=1)
416
m = self._date_re.match(self.spec)
417
if not m or (not m.group('date') and not m.group('time')):
418
raise errors.InvalidRevisionSpec(self.user_spec,
419
branch, 'invalid date')
423
year = int(m.group('year'))
424
month = int(m.group('month'))
425
day = int(m.group('day'))
432
hour = int(m.group('hour'))
433
minute = int(m.group('minute'))
434
if m.group('second'):
435
second = int(m.group('second'))
439
hour, minute, second = 0,0,0
441
raise errors.InvalidRevisionSpec(self.user_spec,
442
branch, 'invalid date')
444
dt = datetime.datetime(year=year, month=month, day=day,
445
hour=hour, minute=minute, second=second)
448
rev = bisect.bisect(_RevListToTimestamps(revs, branch), dt)
452
return RevisionInfo(branch, None)
454
return RevisionInfo(branch, rev + 1)
456
SPEC_TYPES.append(RevisionSpec_date)
459
class RevisionSpec_ancestor(RevisionSpec):
462
def _match_on(self, branch, revs):
463
from bzrlib.branch import Branch
465
trace.mutter('matching ancestor: on: %s, %s', self.spec, branch)
466
other_branch = Branch.open(self.spec)
467
revision_a = branch.last_revision()
468
revision_b = other_branch.last_revision()
469
for r, b in ((revision_a, branch), (revision_b, other_branch)):
470
if r in (None, revision.NULL_REVISION):
471
raise errors.NoCommits(b)
472
revision_source = revision.MultipleRevisionSources(
473
branch.repository, other_branch.repository)
474
rev_id = revision.common_ancestor(revision_a, revision_b,
477
revno = branch.revision_id_to_revno(rev_id)
478
except errors.NoSuchRevision:
480
return RevisionInfo(branch, revno, rev_id)
482
SPEC_TYPES.append(RevisionSpec_ancestor)
485
class RevisionSpec_branch(RevisionSpec):
486
"""A branch: revision specifier.
488
This takes the path to a branch and returns its tip revision id.
492
def _match_on(self, branch, revs):
493
from bzrlib.branch import Branch
494
other_branch = Branch.open(self.spec)
495
revision_b = other_branch.last_revision()
496
if revision_b in (None, revision.NULL_REVISION):
497
raise errors.NoCommits(other_branch)
498
# pull in the remote revisions so we can diff
499
branch.fetch(other_branch, revision_b)
501
revno = branch.revision_id_to_revno(revision_b)
502
except errors.NoSuchRevision:
504
return RevisionInfo(branch, revno, revision_b)
506
SPEC_TYPES.append(RevisionSpec_branch)
added
removed
bzrlib/revisionspec.py
