1
# Copyright (C) 2005, 2006, 2007 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
34
class RevisionInfo(object):
35
"""The results of applying a revision specification to a branch."""
37
help_txt = """The results of applying a revision specification to a branch.
39
An instance has two useful attributes: revno, and rev_id.
41
They can also be accessed as spec[0] and spec[1] respectively,
42
so that you can write code like:
43
revno, rev_id = RevisionSpec(branch, spec)
44
although this is probably going to be deprecated later.
46
This class exists mostly to be the return value of a RevisionSpec,
47
so that you can access the member you're interested in (number or id)
48
or treat the result as a tuple.
51
def __init__(self, branch, revno, rev_id=_marker):
55
# allow caller to be lazy
56
if self.revno is None:
59
self.rev_id = branch.get_rev_id(self.revno)
63
def __nonzero__(self):
64
# first the easy ones...
65
if self.rev_id is None:
67
if self.revno is not None:
69
# TODO: otherwise, it should depend on how I was built -
70
# if it's in_history(branch), then check revision_history(),
71
# if it's in_store(branch), do the check below
72
return self.branch.repository.has_revision(self.rev_id)
77
def __getitem__(self, index):
78
if index == 0: return self.revno
79
if index == 1: return self.rev_id
80
raise IndexError(index)
83
return self.branch.repository.get_revision(self.rev_id)
85
def __eq__(self, other):
86
if type(other) not in (tuple, list, type(self)):
88
if type(other) is type(self) and self.branch is not other.branch:
90
return tuple(self) == tuple(other)
93
return '<bzrlib.revisionspec.RevisionInfo object %s, %s for %r>' % (
94
self.revno, self.rev_id, self.branch)
97
def from_revision_id(branch, revision_id, revs):
98
"""Construct a RevisionInfo given just the id.
100
Use this if you don't know or care what the revno is.
103
revno = revs.index(revision_id) + 1
106
return RevisionInfo(branch, revno, revision_id)
109
# classes in this list should have a "prefix" attribute, against which
110
# string specs are matched
115
class RevisionSpec(object):
116
"""A parsed revision specification."""
118
help_txt = """A parsed revision specification.
120
A revision specification can be an integer, in which case it is
121
assumed to be a revno (though this will translate negative values
122
into positive ones); or it can be a string, in which case it is
123
parsed for something like 'date:' or 'revid:' etc.
125
Revision specs are an UI element, and they have been moved out
126
of the branch class to leave "back-end" classes unaware of such
127
details. Code that gets a revno or rev_id from other code should
128
not be using revision specs - revnos and revision ids are the
129
accepted ways to refer to revisions internally.
131
(Equivalent to the old Branch method get_revision_info())
136
def __new__(cls, spec, _internal=False):
138
return object.__new__(cls, spec, _internal=_internal)
140
symbol_versioning.warn('Creating a RevisionSpec directly has'
141
' been deprecated in version 0.11. Use'
142
' RevisionSpec.from_string()'
144
DeprecationWarning, stacklevel=2)
145
return RevisionSpec.from_string(spec)
148
def from_string(spec):
149
"""Parse a revision spec string into a RevisionSpec object.
151
:param spec: A string specified by the user
152
:return: A RevisionSpec object that understands how to parse the
155
if not isinstance(spec, (type(None), basestring)):
156
raise TypeError('error')
159
return RevisionSpec(None, _internal=True)
161
assert isinstance(spec, basestring), \
162
"You should only supply strings not %s" % (type(spec),)
164
for spectype in SPEC_TYPES:
165
if spec.startswith(spectype.prefix):
166
trace.mutter('Returning RevisionSpec %s for %s',
167
spectype.__name__, spec)
168
return spectype(spec, _internal=True)
170
# RevisionSpec_revno is special cased, because it is the only
171
# one that directly handles plain integers
172
# TODO: This should not be special cased rather it should be
173
# a method invocation on spectype.canparse()
175
if _revno_regex is None:
176
_revno_regex = re.compile(r'^(?:(\d+(\.\d+)*)|-\d+)(:.*)?$')
177
if _revno_regex.match(spec) is not None:
178
return RevisionSpec_revno(spec, _internal=True)
180
raise errors.NoSuchRevisionSpec(spec)
182
def __init__(self, spec, _internal=False):
183
"""Create a RevisionSpec referring to the Null revision.
185
:param spec: The original spec supplied by the user
186
:param _internal: Used to ensure that RevisionSpec is not being
187
called directly. Only from RevisionSpec.from_string()
190
# XXX: Update this after 0.10 is released
191
symbol_versioning.warn('Creating a RevisionSpec directly has'
192
' been deprecated in version 0.11. Use'
193
' RevisionSpec.from_string()'
195
DeprecationWarning, stacklevel=2)
196
self.user_spec = spec
197
if self.prefix and spec.startswith(self.prefix):
198
spec = spec[len(self.prefix):]
201
def _match_on(self, branch, revs):
202
trace.mutter('Returning RevisionSpec._match_on: None')
203
return RevisionInfo(branch, 0, None)
205
def _match_on_and_check(self, branch, revs):
206
info = self._match_on(branch, revs)
209
elif info == (0, None):
210
# special case - the empty tree
213
raise errors.InvalidRevisionSpec(self.user_spec, branch)
215
raise errors.InvalidRevisionSpec(self.spec, branch)
217
def in_history(self, branch):
219
revs = branch.revision_history()
221
# this should never trigger.
222
# TODO: make it a deprecated code path. RBC 20060928
224
return self._match_on_and_check(branch, revs)
226
# FIXME: in_history is somewhat broken,
227
# it will return non-history revisions in many
228
# circumstances. The expected facility is that
229
# in_history only returns revision-history revs,
230
# in_store returns any rev. RBC 20051010
231
# aliases for now, when we fix the core logic, then they
232
# will do what you expect.
233
in_store = in_history
237
# this is mostly for helping with testing
238
return '<%s %s>' % (self.__class__.__name__,
241
def needs_branch(self):
242
"""Whether this revision spec needs a branch.
244
Set this to False the branch argument of _match_on is not used.
248
def get_branch(self):
249
"""When the revision specifier contains a branch location, return it.
251
Otherwise, return None.
258
class RevisionSpec_revno(RevisionSpec):
259
"""Selects a revision using a number."""
261
help_txt = """Selects a revision using a number.
263
Use an integer to specify a revision in the history of the branch.
264
Optionally a branch can be specified. The 'revno:' prefix is optional.
265
A negative number will count from the end of the branch (-1 is the
266
last revision, -2 the previous one). If the negative number is larger
267
than the branch's history, the first revision is returned.
269
revno:1 -> return the first revision
270
revno:3:/path/to/branch -> return the 3rd revision of
271
the branch '/path/to/branch'
272
revno:-1 -> The last revision in a branch.
273
-2:http://other/branch -> The second to last revision in the
275
-1000000 -> Most likely the first revision, unless
276
your history is very long.
280
def _match_on(self, branch, revs):
281
"""Lookup a revision by revision number"""
282
loc = self.spec.find(':')
284
revno_spec = self.spec
287
revno_spec = self.spec[:loc]
288
branch_spec = self.spec[loc+1:]
292
raise errors.InvalidRevisionSpec(self.user_spec,
293
branch, 'cannot have an empty revno and no branch')
297
revno = int(revno_spec)
300
# dotted decimal. This arguably should not be here
301
# but the from_string method is a little primitive
302
# right now - RBC 20060928
304
match_revno = tuple((int(number) for number in revno_spec.split('.')))
305
except ValueError, e:
306
raise errors.InvalidRevisionSpec(self.user_spec, branch, e)
311
# the user has override the branch to look in.
312
# we need to refresh the revision_history map and
314
from bzrlib.branch import Branch
315
branch = Branch.open(branch_spec)
316
# Need to use a new revision history
317
# because we are using a specific branch
318
revs = branch.revision_history()
323
last_rev = branch.last_revision()
324
merge_sorted_revisions = tsort.merge_sort(
325
branch.repository.get_revision_graph(last_rev),
329
return item[3] == match_revno
330
revisions = filter(match, merge_sorted_revisions)
333
if len(revisions) != 1:
334
return RevisionInfo(branch, None, None)
336
# there is no traditional 'revno' for dotted-decimal revnos.
337
# so for API compatability we return None.
338
return RevisionInfo(branch, None, revisions[0][1])
341
# if get_rev_id supported negative revnos, there would not be a
342
# need for this special case.
343
if (-revno) >= len(revs):
346
revno = len(revs) + revno + 1
348
revision_id = branch.get_rev_id(revno, revs)
349
except errors.NoSuchRevision:
350
raise errors.InvalidRevisionSpec(self.user_spec, branch)
351
return RevisionInfo(branch, revno, revision_id)
353
def needs_branch(self):
354
return self.spec.find(':') == -1
356
def get_branch(self):
357
if self.spec.find(':') == -1:
360
return self.spec[self.spec.find(':')+1:]
363
RevisionSpec_int = RevisionSpec_revno
365
SPEC_TYPES.append(RevisionSpec_revno)
368
class RevisionSpec_revid(RevisionSpec):
369
"""Selects a revision using the revision id."""
371
help_txt = """Selects a revision using the revision id.
373
Supply a specific revision id, that can be used to specify any
374
revision id in the ancestry of the branch.
375
Including merges, and pending merges.
377
revid:aaaa@bbbb-123456789 -> Select revision 'aaaa@bbbb-123456789'
381
def _match_on(self, branch, revs):
382
return RevisionInfo.from_revision_id(branch, self.spec, revs)
384
SPEC_TYPES.append(RevisionSpec_revid)
387
class RevisionSpec_last(RevisionSpec):
388
"""Selects the nth revision from the end."""
390
help_txt = """Selects the nth revision from the end.
392
Supply a positive number to get the nth revision from the end.
393
This is the same as supplying negative numbers to the 'revno:' spec.
395
last:1 -> return the last revision
396
last:3 -> return the revision 2 before the end.
401
def _match_on(self, branch, revs):
404
raise errors.NoCommits(branch)
405
return RevisionInfo(branch, len(revs), revs[-1])
408
offset = int(self.spec)
409
except ValueError, e:
410
raise errors.InvalidRevisionSpec(self.user_spec, branch, e)
413
raise errors.InvalidRevisionSpec(self.user_spec, branch,
414
'you must supply a positive value')
415
revno = len(revs) - offset + 1
417
revision_id = branch.get_rev_id(revno, revs)
418
except errors.NoSuchRevision:
419
raise errors.InvalidRevisionSpec(self.user_spec, branch)
420
return RevisionInfo(branch, revno, revision_id)
422
SPEC_TYPES.append(RevisionSpec_last)
425
class RevisionSpec_before(RevisionSpec):
426
"""Selects the parent of the revision specified."""
428
help_txt = """Selects the parent of the revision specified.
430
Supply any revision spec to return the parent of that revision.
431
It is an error to request the parent of the null revision (before:0).
432
This is mostly useful when inspecting revisions that are not in the
433
revision history of a branch.
436
before:1913 -> Return the parent of revno 1913 (revno 1912)
437
before:revid:aaaa@bbbb-1234567890 -> return the parent of revision
439
bzr diff -r before:revid:aaaa..revid:aaaa
440
-> Find the changes between revision 'aaaa' and its parent.
441
(what changes did 'aaaa' introduce)
446
def _match_on(self, branch, revs):
447
r = RevisionSpec.from_string(self.spec)._match_on(branch, revs)
449
raise errors.InvalidRevisionSpec(self.user_spec, branch,
450
'cannot go before the null: revision')
452
# We need to use the repository history here
453
rev = branch.repository.get_revision(r.rev_id)
454
if not rev.parent_ids:
458
revision_id = rev.parent_ids[0]
460
revno = revs.index(revision_id) + 1
466
revision_id = branch.get_rev_id(revno, revs)
467
except errors.NoSuchRevision:
468
raise errors.InvalidRevisionSpec(self.user_spec,
470
return RevisionInfo(branch, revno, revision_id)
472
SPEC_TYPES.append(RevisionSpec_before)
475
class RevisionSpec_tag(RevisionSpec):
476
"""Select a revision identified by tag name"""
478
help_txt = """Selects a revision identified by a tag name.
480
Tags are stored in the branch and created by the 'tag' command.
485
def _match_on(self, branch, revs):
486
# Can raise tags not supported, NoSuchTag, etc
487
return RevisionInfo.from_revision_id(branch,
488
branch.tags.lookup_tag(self.spec),
491
SPEC_TYPES.append(RevisionSpec_tag)
494
class _RevListToTimestamps(object):
495
"""This takes a list of revisions, and allows you to bisect by date"""
497
__slots__ = ['revs', 'branch']
499
def __init__(self, revs, branch):
503
def __getitem__(self, index):
504
"""Get the date of the index'd item"""
505
r = self.branch.repository.get_revision(self.revs[index])
506
# TODO: Handle timezone.
507
return datetime.datetime.fromtimestamp(r.timestamp)
510
return len(self.revs)
513
class RevisionSpec_date(RevisionSpec):
514
"""Selects a revision on the basis of a datestamp."""
516
help_txt = """Selects a revision on the basis of a datestamp.
518
Supply a datestamp to select the first revision that matches the date.
519
Date can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
520
Matches the first entry after a given date (either at midnight or
521
at a specified time).
523
One way to display all the changes since yesterday would be:
524
bzr log -r date:yesterday..-1
527
date:yesterday -> select the first revision since yesterday
528
date:2006-08-14,17:10:14 -> select the first revision after
529
August 14th, 2006 at 5:10pm.
532
_date_re = re.compile(
533
r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
535
r'(?P<time>(?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d))?)?'
538
def _match_on(self, branch, revs):
539
"""Spec for date revisions:
541
value can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
542
matches the first entry after a given date (either at midnight or
543
at a specified time).
545
# XXX: This doesn't actually work
546
# So the proper way of saying 'give me all entries for today' is:
547
# -r date:yesterday..date:today
548
today = datetime.datetime.fromordinal(datetime.date.today().toordinal())
549
if self.spec.lower() == 'yesterday':
550
dt = today - datetime.timedelta(days=1)
551
elif self.spec.lower() == 'today':
553
elif self.spec.lower() == 'tomorrow':
554
dt = today + datetime.timedelta(days=1)
556
m = self._date_re.match(self.spec)
557
if not m or (not m.group('date') and not m.group('time')):
558
raise errors.InvalidRevisionSpec(self.user_spec,
559
branch, 'invalid date')
563
year = int(m.group('year'))
564
month = int(m.group('month'))
565
day = int(m.group('day'))
572
hour = int(m.group('hour'))
573
minute = int(m.group('minute'))
574
if m.group('second'):
575
second = int(m.group('second'))
579
hour, minute, second = 0,0,0
581
raise errors.InvalidRevisionSpec(self.user_spec,
582
branch, 'invalid date')
584
dt = datetime.datetime(year=year, month=month, day=day,
585
hour=hour, minute=minute, second=second)
588
rev = bisect.bisect(_RevListToTimestamps(revs, branch), dt)
592
return RevisionInfo(branch, None)
594
return RevisionInfo(branch, rev + 1)
596
SPEC_TYPES.append(RevisionSpec_date)
599
class RevisionSpec_ancestor(RevisionSpec):
600
"""Selects a common ancestor with a second branch."""
602
help_txt = """Selects a common ancestor with a second branch.
604
Supply the path to a branch to select the common ancestor.
606
The common ancestor is the last revision that existed in both
607
branches. Usually this is the branch point, but it could also be
608
a revision that was merged.
610
This is frequently used with 'diff' to return all of the changes
611
that your branch introduces, while excluding the changes that you
612
have not merged from the remote branch.
615
ancestor:/path/to/branch
616
$ bzr diff -r ancestor:../../mainline/branch
620
def _match_on(self, branch, revs):
621
trace.mutter('matching ancestor: on: %s, %s', self.spec, branch)
622
return self._find_revision_info(branch, self.spec)
625
def _find_revision_info(branch, other_location):
626
from bzrlib.branch import Branch
628
other_branch = Branch.open(other_location)
629
revision_a = branch.last_revision()
630
revision_b = other_branch.last_revision()
631
for r, b in ((revision_a, branch), (revision_b, other_branch)):
632
if r in (None, revision.NULL_REVISION):
633
raise errors.NoCommits(b)
634
revision_source = revision.MultipleRevisionSources(
635
branch.repository, other_branch.repository)
636
rev_id = revision.common_ancestor(revision_a, revision_b,
639
revno = branch.revision_id_to_revno(rev_id)
640
except errors.NoSuchRevision:
642
return RevisionInfo(branch, revno, rev_id)
645
SPEC_TYPES.append(RevisionSpec_ancestor)
648
class RevisionSpec_branch(RevisionSpec):
649
"""Selects the last revision of a specified branch."""
651
help_txt = """Selects the last revision of a specified branch.
653
Supply the path to a branch to select its last revision.
656
branch:/path/to/branch
660
def _match_on(self, branch, revs):
661
from bzrlib.branch import Branch
662
other_branch = Branch.open(self.spec)
663
revision_b = other_branch.last_revision()
664
if revision_b in (None, revision.NULL_REVISION):
665
raise errors.NoCommits(other_branch)
666
# pull in the remote revisions so we can diff
667
branch.fetch(other_branch, revision_b)
669
revno = branch.revision_id_to_revno(revision_b)
670
except errors.NoSuchRevision:
672
return RevisionInfo(branch, revno, revision_b)
674
SPEC_TYPES.append(RevisionSpec_branch)
677
class RevisionSpec_submit(RevisionSpec_ancestor):
678
"""Selects a common ancestor with a submit branch."""
680
help_txt = """Selects a common ancestor with the submit branch.
682
Diffing against this shows all the changes that were made in this branch,
683
and is a good predictor of what merge will do. The submit branch is
684
used by the bundle and merge directive comands. If no submit branch
685
is specified, the parent branch is used instead.
687
The common ancestor is the last revision that existed in both
688
branches. Usually this is the branch point, but it could also be
689
a revision that was merged.
692
$ bzr diff -r submit:
697
def _match_on(self, branch, revs):
698
trace.mutter('matching ancestor: on: %s, %s', self.spec, branch)
699
submit_location = branch.get_submit_branch()
700
location_type = 'submit branch'
701
if submit_location is None:
702
submit_location = branch.get_parent()
703
location_type = 'parent branch'
704
if submit_location is None:
705
raise errors.NoSubmitBranch(branch)
706
trace.note('Using %s %s', location_type, submit_location)
707
return self._find_revision_info(branch, submit_location)
710
SPEC_TYPES.append(RevisionSpec_submit)
added
removed
bzrlib/revisionspec.py
