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
35
class RevisionInfo(object):
36
"""The results of applying a revision specification to a branch."""
38
help_txt = """The results of applying a revision specification to a branch.
40
An instance has two useful attributes: revno, and rev_id.
42
They can also be accessed as spec[0] and spec[1] respectively,
43
so that you can write code like:
44
revno, rev_id = RevisionSpec(branch, spec)
45
although this is probably going to be deprecated later.
47
This class exists mostly to be the return value of a RevisionSpec,
48
so that you can access the member you're interested in (number or id)
49
or treat the result as a tuple.
52
def __init__(self, branch, revno, rev_id=_marker):
56
# allow caller to be lazy
57
if self.revno is None:
60
self.rev_id = branch.get_rev_id(self.revno)
64
def __nonzero__(self):
65
# first the easy ones...
66
if self.rev_id is None:
68
if self.revno is not None:
70
# TODO: otherwise, it should depend on how I was built -
71
# if it's in_history(branch), then check revision_history(),
72
# if it's in_store(branch), do the check below
73
return self.branch.repository.has_revision(self.rev_id)
78
def __getitem__(self, index):
79
if index == 0: return self.revno
80
if index == 1: return self.rev_id
81
raise IndexError(index)
84
return self.branch.repository.get_revision(self.rev_id)
86
def __eq__(self, other):
87
if type(other) not in (tuple, list, type(self)):
89
if type(other) is type(self) and self.branch is not other.branch:
91
return tuple(self) == tuple(other)
94
return '<bzrlib.revisionspec.RevisionInfo object %s, %s for %r>' % (
95
self.revno, self.rev_id, self.branch)
98
def from_revision_id(branch, revision_id, revs):
99
"""Construct a RevisionInfo given just the id.
101
Use this if you don't know or care what the revno is.
103
if revision_id == revision.NULL_REVISION:
104
return RevisionInfo(branch, 0, revision_id)
106
revno = revs.index(revision_id) + 1
109
return RevisionInfo(branch, revno, revision_id)
112
# classes in this list should have a "prefix" attribute, against which
113
# string specs are matched
118
class RevisionSpec(object):
119
"""A parsed revision specification."""
121
help_txt = """A parsed revision specification.
123
A revision specification can be an integer, in which case it is
124
assumed to be a revno (though this will translate negative values
125
into positive ones); or it can be a string, in which case it is
126
parsed for something like 'date:' or 'revid:' etc.
128
Revision specs are an UI element, and they have been moved out
129
of the branch class to leave "back-end" classes unaware of such
130
details. Code that gets a revno or rev_id from other code should
131
not be using revision specs - revnos and revision ids are the
132
accepted ways to refer to revisions internally.
134
(Equivalent to the old Branch method get_revision_info())
139
def __new__(cls, spec, _internal=False):
141
return object.__new__(cls, spec, _internal=_internal)
143
symbol_versioning.warn('Creating a RevisionSpec directly has'
144
' been deprecated in version 0.11. Use'
145
' RevisionSpec.from_string()'
147
DeprecationWarning, stacklevel=2)
148
return RevisionSpec.from_string(spec)
151
def from_string(spec):
152
"""Parse a revision spec string into a RevisionSpec object.
154
:param spec: A string specified by the user
155
:return: A RevisionSpec object that understands how to parse the
158
if not isinstance(spec, (type(None), basestring)):
159
raise TypeError('error')
162
return RevisionSpec(None, _internal=True)
164
assert isinstance(spec, basestring), \
165
"You should only supply strings not %s" % (type(spec),)
167
for spectype in SPEC_TYPES:
168
if spec.startswith(spectype.prefix):
169
trace.mutter('Returning RevisionSpec %s for %s',
170
spectype.__name__, spec)
171
return spectype(spec, _internal=True)
173
# RevisionSpec_revno is special cased, because it is the only
174
# one that directly handles plain integers
175
# TODO: This should not be special cased rather it should be
176
# a method invocation on spectype.canparse()
178
if _revno_regex is None:
179
_revno_regex = re.compile(r'^(?:(\d+(\.\d+)*)|-\d+)(:.*)?$')
180
if _revno_regex.match(spec) is not None:
181
return RevisionSpec_revno(spec, _internal=True)
183
raise errors.NoSuchRevisionSpec(spec)
185
def __init__(self, spec, _internal=False):
186
"""Create a RevisionSpec referring to the Null revision.
188
:param spec: The original spec supplied by the user
189
:param _internal: Used to ensure that RevisionSpec is not being
190
called directly. Only from RevisionSpec.from_string()
193
# XXX: Update this after 0.10 is released
194
symbol_versioning.warn('Creating a RevisionSpec directly has'
195
' been deprecated in version 0.11. Use'
196
' RevisionSpec.from_string()'
198
DeprecationWarning, stacklevel=2)
199
self.user_spec = spec
200
if self.prefix and spec.startswith(self.prefix):
201
spec = spec[len(self.prefix):]
204
def _match_on(self, branch, revs):
205
trace.mutter('Returning RevisionSpec._match_on: None')
206
return RevisionInfo(branch, None, None)
208
def _match_on_and_check(self, branch, revs):
209
info = self._match_on(branch, revs)
212
elif info == (None, None):
213
# special case - nothing supplied
216
raise errors.InvalidRevisionSpec(self.user_spec, branch)
218
raise errors.InvalidRevisionSpec(self.spec, branch)
220
def in_history(self, branch):
222
revs = branch.revision_history()
224
# this should never trigger.
225
# TODO: make it a deprecated code path. RBC 20060928
227
return self._match_on_and_check(branch, revs)
229
# FIXME: in_history is somewhat broken,
230
# it will return non-history revisions in many
231
# circumstances. The expected facility is that
232
# in_history only returns revision-history revs,
233
# in_store returns any rev. RBC 20051010
234
# aliases for now, when we fix the core logic, then they
235
# will do what you expect.
236
in_store = in_history
239
def as_revision_id(self, context_branch):
240
"""Return just the revision_id for this revisions spec.
242
Some revision specs require a context_branch to be able to determine
243
their value. Not all specs will make use of it.
245
return self._as_revision_id(context_branch)
247
def _as_revision_id(self, context_branch):
248
"""Implementation of as_revision_id()
250
Classes should override this function to provide appropriate
251
functionality. The default is to just call '.in_history().rev_id'
253
return self.in_history(context_branch).rev_id
256
# this is mostly for helping with testing
257
return '<%s %s>' % (self.__class__.__name__,
260
def needs_branch(self):
261
"""Whether this revision spec needs a branch.
263
Set this to False the branch argument of _match_on is not used.
267
def get_branch(self):
268
"""When the revision specifier contains a branch location, return it.
270
Otherwise, return None.
277
class RevisionSpec_revno(RevisionSpec):
278
"""Selects a revision using a number."""
280
help_txt = """Selects a revision using a number.
282
Use an integer to specify a revision in the history of the branch.
283
Optionally a branch can be specified. The 'revno:' prefix is optional.
284
A negative number will count from the end of the branch (-1 is the
285
last revision, -2 the previous one). If the negative number is larger
286
than the branch's history, the first revision is returned.
289
revno:1 -> return the first revision
290
revno:3:/path/to/branch -> return the 3rd revision of
291
the branch '/path/to/branch'
292
revno:-1 -> The last revision in a branch.
293
-2:http://other/branch -> The second to last revision in the
295
-1000000 -> Most likely the first revision, unless
296
your history is very long.
300
def _match_on(self, branch, revs):
301
"""Lookup a revision by revision number"""
302
branch, revno, revision_id = self._lookup(branch, revs)
303
return RevisionInfo(branch, revno, revision_id)
305
def _lookup(self, branch, revs_or_none):
306
loc = self.spec.find(':')
308
revno_spec = self.spec
311
revno_spec = self.spec[:loc]
312
branch_spec = self.spec[loc+1:]
316
raise errors.InvalidRevisionSpec(self.user_spec,
317
branch, 'cannot have an empty revno and no branch')
321
revno = int(revno_spec)
324
# dotted decimal. This arguably should not be here
325
# but the from_string method is a little primitive
326
# right now - RBC 20060928
328
match_revno = tuple((int(number) for number in revno_spec.split('.')))
329
except ValueError, e:
330
raise errors.InvalidRevisionSpec(self.user_spec, branch, e)
335
# the user has override the branch to look in.
336
# we need to refresh the revision_history map and
338
from bzrlib.branch import Branch
339
branch = Branch.open(branch_spec)
345
revision_id_to_revno = branch.get_revision_id_to_revno_map()
346
revisions = [revision_id for revision_id, revno
347
in revision_id_to_revno.iteritems()
348
if revno == match_revno]
351
if len(revisions) != 1:
352
return branch, None, None
354
# there is no traditional 'revno' for dotted-decimal revnos.
355
# so for API compatability we return None.
356
return branch, None, revisions[0]
358
last_revno, last_revision_id = branch.last_revision_info()
360
# if get_rev_id supported negative revnos, there would not be a
361
# need for this special case.
362
if (-revno) >= last_revno:
365
revno = last_revno + revno + 1
367
revision_id = branch.get_rev_id(revno, revs_or_none)
368
except errors.NoSuchRevision:
369
raise errors.InvalidRevisionSpec(self.user_spec, branch)
370
return branch, revno, revision_id
372
def _as_revision_id(self, context_branch):
373
# We would have the revno here, but we don't really care
374
branch, revno, revision_id = self._lookup(context_branch, None)
377
def needs_branch(self):
378
return self.spec.find(':') == -1
380
def get_branch(self):
381
if self.spec.find(':') == -1:
384
return self.spec[self.spec.find(':')+1:]
387
RevisionSpec_int = RevisionSpec_revno
389
SPEC_TYPES.append(RevisionSpec_revno)
392
class RevisionSpec_revid(RevisionSpec):
393
"""Selects a revision using the revision id."""
395
help_txt = """Selects a revision using the revision id.
397
Supply a specific revision id, that can be used to specify any
398
revision id in the ancestry of the branch.
399
Including merges, and pending merges.
402
revid:aaaa@bbbb-123456789 -> Select revision 'aaaa@bbbb-123456789'
407
def _match_on(self, branch, revs):
408
# self.spec comes straight from parsing the command line arguments,
409
# so we expect it to be a Unicode string. Switch it to the internal
411
revision_id = osutils.safe_revision_id(self.spec, warn=False)
412
return RevisionInfo.from_revision_id(branch, revision_id, revs)
414
def _as_revision_id(self, context_branch):
415
return osutils.safe_revision_id(self.spec, warn=False)
417
SPEC_TYPES.append(RevisionSpec_revid)
420
class RevisionSpec_last(RevisionSpec):
421
"""Selects the nth revision from the end."""
423
help_txt = """Selects the nth revision from the end.
425
Supply a positive number to get the nth revision from the end.
426
This is the same as supplying negative numbers to the 'revno:' spec.
429
last:1 -> return the last revision
430
last:3 -> return the revision 2 before the end.
435
def _match_on(self, branch, revs):
436
revno, revision_id = self._revno_and_revision_id(branch, revs)
437
return RevisionInfo(branch, revno, revision_id)
439
def _revno_and_revision_id(self, context_branch, revs_or_none):
440
last_revno, last_revision_id = context_branch.last_revision_info()
444
raise errors.NoCommits(context_branch)
445
return last_revno, last_revision_id
448
offset = int(self.spec)
449
except ValueError, e:
450
raise errors.InvalidRevisionSpec(self.user_spec, context_branch, e)
453
raise errors.InvalidRevisionSpec(self.user_spec, context_branch,
454
'you must supply a positive value')
456
revno = last_revno - offset + 1
458
revision_id = context_branch.get_rev_id(revno, revs_or_none)
459
except errors.NoSuchRevision:
460
raise errors.InvalidRevisionSpec(self.user_spec, context_branch)
461
return revno, revision_id
463
def _as_revision_id(self, context_branch):
464
# We compute the revno as part of the process, but we don't really care
466
revno, revision_id = self._revno_and_revision_id(context_branch, None)
469
SPEC_TYPES.append(RevisionSpec_last)
472
class RevisionSpec_before(RevisionSpec):
473
"""Selects the parent of the revision specified."""
475
help_txt = """Selects the parent of the revision specified.
477
Supply any revision spec to return the parent of that revision.
478
It is an error to request the parent of the null revision (before:0).
479
This is mostly useful when inspecting revisions that are not in the
480
revision history of a branch.
484
before:1913 -> Return the parent of revno 1913 (revno 1912)
485
before:revid:aaaa@bbbb-1234567890 -> return the parent of revision
487
bzr diff -r before:revid:aaaa..revid:aaaa
488
-> Find the changes between revision 'aaaa' and its parent.
489
(what changes did 'aaaa' introduce)
494
def _match_on(self, branch, revs):
495
r = RevisionSpec.from_string(self.spec)._match_on(branch, revs)
497
raise errors.InvalidRevisionSpec(self.user_spec, branch,
498
'cannot go before the null: revision')
500
# We need to use the repository history here
501
rev = branch.repository.get_revision(r.rev_id)
502
if not rev.parent_ids:
504
revision_id = revision.NULL_REVISION
506
revision_id = rev.parent_ids[0]
508
revno = revs.index(revision_id) + 1
514
revision_id = branch.get_rev_id(revno, revs)
515
except errors.NoSuchRevision:
516
raise errors.InvalidRevisionSpec(self.user_spec,
518
return RevisionInfo(branch, revno, revision_id)
520
def _as_revision_id(self, context_branch):
521
base_revspec = RevisionSpec.from_string(self.spec)
522
base_revision_id = base_revspec.as_revision_id(context_branch)
523
if base_revision_id == revision.NULL_REVISION:
524
raise errors.InvalidRevisionSpec(self.user_spec, branch,
525
'cannot go before the null: revision')
526
context_repo = context_branch.repository
527
context_repo.lock_read()
529
parent_map = context_repo.get_parent_map([base_revision_id])
531
context_repo.unlock()
532
if base_revision_id not in parent_map:
533
# Ghost, or unknown revision id
534
raise errors.InvalidRevisionSpec(self.user_spec, context_branch,
535
'cannot find the matching revision')
536
parents = parent_map[base_revision_id]
538
raise errors.InvalidRevisionSpec(self.user_spec, context_branch,
539
'No parents for revision.')
542
SPEC_TYPES.append(RevisionSpec_before)
545
class RevisionSpec_tag(RevisionSpec):
546
"""Select a revision identified by tag name"""
548
help_txt = """Selects a revision identified by a tag name.
550
Tags are stored in the branch and created by the 'tag' command.
555
def _match_on(self, branch, revs):
556
# Can raise tags not supported, NoSuchTag, etc
557
return RevisionInfo.from_revision_id(branch,
558
branch.tags.lookup_tag(self.spec),
561
def _as_revision_id(self, context_branch):
562
return context_branch.tags.lookup_tag(self.spec)
564
SPEC_TYPES.append(RevisionSpec_tag)
567
class _RevListToTimestamps(object):
568
"""This takes a list of revisions, and allows you to bisect by date"""
570
__slots__ = ['revs', 'branch']
572
def __init__(self, revs, branch):
576
def __getitem__(self, index):
577
"""Get the date of the index'd item"""
578
r = self.branch.repository.get_revision(self.revs[index])
579
# TODO: Handle timezone.
580
return datetime.datetime.fromtimestamp(r.timestamp)
583
return len(self.revs)
586
class RevisionSpec_date(RevisionSpec):
587
"""Selects a revision on the basis of a datestamp."""
589
help_txt = """Selects a revision on the basis of a datestamp.
591
Supply a datestamp to select the first revision that matches the date.
592
Date can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
593
Matches the first entry after a given date (either at midnight or
594
at a specified time).
596
One way to display all the changes since yesterday would be::
598
bzr log -r date:yesterday..-1
602
date:yesterday -> select the first revision since yesterday
603
date:2006-08-14,17:10:14 -> select the first revision after
604
August 14th, 2006 at 5:10pm.
607
_date_re = re.compile(
608
r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
610
r'(?P<time>(?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d))?)?'
613
def _match_on(self, branch, revs):
614
"""Spec for date revisions:
616
value can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
617
matches the first entry after a given date (either at midnight or
618
at a specified time).
620
# XXX: This doesn't actually work
621
# So the proper way of saying 'give me all entries for today' is:
622
# -r date:yesterday..date:today
623
today = datetime.datetime.fromordinal(datetime.date.today().toordinal())
624
if self.spec.lower() == 'yesterday':
625
dt = today - datetime.timedelta(days=1)
626
elif self.spec.lower() == 'today':
628
elif self.spec.lower() == 'tomorrow':
629
dt = today + datetime.timedelta(days=1)
631
m = self._date_re.match(self.spec)
632
if not m or (not m.group('date') and not m.group('time')):
633
raise errors.InvalidRevisionSpec(self.user_spec,
634
branch, 'invalid date')
638
year = int(m.group('year'))
639
month = int(m.group('month'))
640
day = int(m.group('day'))
647
hour = int(m.group('hour'))
648
minute = int(m.group('minute'))
649
if m.group('second'):
650
second = int(m.group('second'))
654
hour, minute, second = 0,0,0
656
raise errors.InvalidRevisionSpec(self.user_spec,
657
branch, 'invalid date')
659
dt = datetime.datetime(year=year, month=month, day=day,
660
hour=hour, minute=minute, second=second)
663
rev = bisect.bisect(_RevListToTimestamps(revs, branch), dt)
667
raise errors.InvalidRevisionSpec(self.user_spec, branch)
669
return RevisionInfo(branch, rev + 1)
671
SPEC_TYPES.append(RevisionSpec_date)
674
class RevisionSpec_ancestor(RevisionSpec):
675
"""Selects a common ancestor with a second branch."""
677
help_txt = """Selects a common ancestor with a second branch.
679
Supply the path to a branch to select the common ancestor.
681
The common ancestor is the last revision that existed in both
682
branches. Usually this is the branch point, but it could also be
683
a revision that was merged.
685
This is frequently used with 'diff' to return all of the changes
686
that your branch introduces, while excluding the changes that you
687
have not merged from the remote branch.
691
ancestor:/path/to/branch
692
$ bzr diff -r ancestor:../../mainline/branch
696
def _match_on(self, branch, revs):
697
trace.mutter('matching ancestor: on: %s, %s', self.spec, branch)
698
return self._find_revision_info(branch, self.spec)
700
def _as_revision_id(self, context_branch):
701
return self._find_revision_id(context_branch, self.spec)
704
def _find_revision_info(branch, other_location):
705
revision_id = RevisionSpec_ancestor._find_revision_id(branch,
708
revno = branch.revision_id_to_revno(revision_id)
709
except errors.NoSuchRevision:
711
return RevisionInfo(branch, revno, revision_id)
714
def _find_revision_id(branch, other_location):
715
from bzrlib.branch import Branch
719
revision_a = revision.ensure_null(branch.last_revision())
720
if revision_a == revision.NULL_REVISION:
721
raise errors.NoCommits(branch)
722
other_branch = Branch.open(other_location)
723
other_branch.lock_read()
725
revision_b = revision.ensure_null(other_branch.last_revision())
726
if revision_b == revision.NULL_REVISION:
727
raise errors.NoCommits(other_branch)
728
graph = branch.repository.get_graph(other_branch.repository)
729
rev_id = graph.find_unique_lca(revision_a, revision_b)
731
other_branch.unlock()
732
if rev_id == revision.NULL_REVISION:
733
raise errors.NoCommonAncestor(revision_a, revision_b)
739
SPEC_TYPES.append(RevisionSpec_ancestor)
742
class RevisionSpec_branch(RevisionSpec):
743
"""Selects the last revision of a specified branch."""
745
help_txt = """Selects the last revision of a specified branch.
747
Supply the path to a branch to select its last revision.
751
branch:/path/to/branch
755
def _match_on(self, branch, revs):
756
from bzrlib.branch import Branch
757
other_branch = Branch.open(self.spec)
758
revision_b = other_branch.last_revision()
759
if revision_b in (None, revision.NULL_REVISION):
760
raise errors.NoCommits(other_branch)
761
# pull in the remote revisions so we can diff
762
branch.fetch(other_branch, revision_b)
764
revno = branch.revision_id_to_revno(revision_b)
765
except errors.NoSuchRevision:
767
return RevisionInfo(branch, revno, revision_b)
769
def _as_revision_id(self, context_branch):
770
from bzrlib.branch import Branch
771
other_branch = Branch.open(self.spec)
772
last_revision = other_branch.last_revision()
773
last_revision = revision.ensure_null(last_revision)
774
if last_revision == revision.NULL_REVISION:
775
raise errors.NoCommits(other_branch)
778
SPEC_TYPES.append(RevisionSpec_branch)
781
class RevisionSpec_submit(RevisionSpec_ancestor):
782
"""Selects a common ancestor with a submit branch."""
784
help_txt = """Selects a common ancestor with the submit branch.
786
Diffing against this shows all the changes that were made in this branch,
787
and is a good predictor of what merge will do. The submit branch is
788
used by the bundle and merge directive comands. If no submit branch
789
is specified, the parent branch is used instead.
791
The common ancestor is the last revision that existed in both
792
branches. Usually this is the branch point, but it could also be
793
a revision that was merged.
797
$ bzr diff -r submit:
802
def _get_submit_location(self, branch):
803
submit_location = branch.get_submit_branch()
804
location_type = 'submit branch'
805
if submit_location is None:
806
submit_location = branch.get_parent()
807
location_type = 'parent branch'
808
if submit_location is None:
809
raise errors.NoSubmitBranch(branch)
810
trace.note('Using %s %s', location_type, submit_location)
811
return submit_location
813
def _match_on(self, branch, revs):
814
trace.mutter('matching ancestor: on: %s, %s', self.spec, branch)
815
return self._find_revision_info(branch,
816
self._get_submit_location(branch))
818
def _as_revision_id(self, context_branch):
819
return self._find_revision_id(context_branch,
820
self._get_submit_location(context_branch))
823
SPEC_TYPES.append(RevisionSpec_submit)
added
removed
bzrlib/revisionspec.py
