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())
138
wants_revision_history = True
140
def __new__(cls, spec, _internal=False):
142
return object.__new__(cls, spec, _internal=_internal)
144
symbol_versioning.warn('Creating a RevisionSpec directly has'
145
' been deprecated in version 0.11. Use'
146
' RevisionSpec.from_string()'
148
DeprecationWarning, stacklevel=2)
149
return RevisionSpec.from_string(spec)
152
def from_string(spec):
153
"""Parse a revision spec string into a RevisionSpec object.
155
:param spec: A string specified by the user
156
:return: A RevisionSpec object that understands how to parse the
159
if not isinstance(spec, (type(None), basestring)):
160
raise TypeError('error')
163
return RevisionSpec(None, _internal=True)
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, None, None)
205
def _match_on_and_check(self, branch, revs):
206
info = self._match_on(branch, revs)
209
elif info == (None, None):
210
# special case - nothing supplied
213
raise errors.InvalidRevisionSpec(self.user_spec, branch)
215
raise errors.InvalidRevisionSpec(self.spec, branch)
217
def in_history(self, branch):
219
if self.wants_revision_history:
220
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
255
def as_tree(self, context_branch):
256
"""Return the tree object for this revisions spec.
258
Some revision specs require a context_branch to be able to determine
259
the revision id and access the repository. Not all specs will make
262
return self._as_tree(context_branch)
264
def _as_tree(self, context_branch):
265
"""Implementation of as_tree().
267
Classes should override this function to provide appropriate
268
functionality. The default is to just call '.as_revision_id()'
269
and get the revision tree from context_branch's repository.
271
revision_id = self.as_revision_id(context_branch)
272
return context_branch.repository.revision_tree(revision_id)
275
# this is mostly for helping with testing
276
return '<%s %s>' % (self.__class__.__name__,
279
def needs_branch(self):
280
"""Whether this revision spec needs a branch.
282
Set this to False the branch argument of _match_on is not used.
286
def get_branch(self):
287
"""When the revision specifier contains a branch location, return it.
289
Otherwise, return None.
296
class RevisionSpec_revno(RevisionSpec):
297
"""Selects a revision using a number."""
299
help_txt = """Selects a revision using a number.
301
Use an integer to specify a revision in the history of the branch.
302
Optionally a branch can be specified. The 'revno:' prefix is optional.
303
A negative number will count from the end of the branch (-1 is the
304
last revision, -2 the previous one). If the negative number is larger
305
than the branch's history, the first revision is returned.
308
revno:1 -> return the first revision of this branch
309
revno:3:/path/to/branch -> return the 3rd revision of
310
the branch '/path/to/branch'
311
revno:-1 -> The last revision in a branch.
312
-2:http://other/branch -> The second to last revision in the
314
-1000000 -> Most likely the first revision, unless
315
your history is very long.
318
wants_revision_history = False
320
def _match_on(self, branch, revs):
321
"""Lookup a revision by revision number"""
322
branch, revno, revision_id = self._lookup(branch, revs)
323
return RevisionInfo(branch, revno, revision_id)
325
def _lookup(self, branch, revs_or_none):
326
loc = self.spec.find(':')
328
revno_spec = self.spec
331
revno_spec = self.spec[:loc]
332
branch_spec = self.spec[loc+1:]
336
raise errors.InvalidRevisionSpec(self.user_spec,
337
branch, 'cannot have an empty revno and no branch')
341
revno = int(revno_spec)
344
# dotted decimal. This arguably should not be here
345
# but the from_string method is a little primitive
346
# right now - RBC 20060928
348
match_revno = tuple((int(number) for number in revno_spec.split('.')))
349
except ValueError, e:
350
raise errors.InvalidRevisionSpec(self.user_spec, branch, e)
355
# the user has override the branch to look in.
356
# we need to refresh the revision_history map and
358
from bzrlib.branch import Branch
359
branch = Branch.open(branch_spec)
365
revision_id_to_revno = branch.get_revision_id_to_revno_map()
366
revisions = [revision_id for revision_id, revno
367
in revision_id_to_revno.iteritems()
368
if revno == match_revno]
371
if len(revisions) != 1:
372
return branch, None, None
374
# there is no traditional 'revno' for dotted-decimal revnos.
375
# so for API compatability we return None.
376
return branch, None, revisions[0]
378
last_revno, last_revision_id = branch.last_revision_info()
380
# if get_rev_id supported negative revnos, there would not be a
381
# need for this special case.
382
if (-revno) >= last_revno:
385
revno = last_revno + revno + 1
387
revision_id = branch.get_rev_id(revno, revs_or_none)
388
except errors.NoSuchRevision:
389
raise errors.InvalidRevisionSpec(self.user_spec, branch)
390
return branch, revno, revision_id
392
def _as_revision_id(self, context_branch):
393
# We would have the revno here, but we don't really care
394
branch, revno, revision_id = self._lookup(context_branch, None)
397
def needs_branch(self):
398
return self.spec.find(':') == -1
400
def get_branch(self):
401
if self.spec.find(':') == -1:
404
return self.spec[self.spec.find(':')+1:]
407
RevisionSpec_int = RevisionSpec_revno
409
SPEC_TYPES.append(RevisionSpec_revno)
412
class RevisionSpec_revid(RevisionSpec):
413
"""Selects a revision using the revision id."""
415
help_txt = """Selects a revision using the revision id.
417
Supply a specific revision id, that can be used to specify any
418
revision id in the ancestry of the branch.
419
Including merges, and pending merges.
422
revid:aaaa@bbbb-123456789 -> Select revision 'aaaa@bbbb-123456789'
427
def _match_on(self, branch, revs):
428
# self.spec comes straight from parsing the command line arguments,
429
# so we expect it to be a Unicode string. Switch it to the internal
431
revision_id = osutils.safe_revision_id(self.spec, warn=False)
432
return RevisionInfo.from_revision_id(branch, revision_id, revs)
434
def _as_revision_id(self, context_branch):
435
return osutils.safe_revision_id(self.spec, warn=False)
437
SPEC_TYPES.append(RevisionSpec_revid)
440
class RevisionSpec_last(RevisionSpec):
441
"""Selects the nth revision from the end."""
443
help_txt = """Selects the nth revision from the end.
445
Supply a positive number to get the nth revision from the end.
446
This is the same as supplying negative numbers to the 'revno:' spec.
449
last:1 -> return the last revision
450
last:3 -> return the revision 2 before the end.
455
def _match_on(self, branch, revs):
456
revno, revision_id = self._revno_and_revision_id(branch, revs)
457
return RevisionInfo(branch, revno, revision_id)
459
def _revno_and_revision_id(self, context_branch, revs_or_none):
460
last_revno, last_revision_id = context_branch.last_revision_info()
464
raise errors.NoCommits(context_branch)
465
return last_revno, last_revision_id
468
offset = int(self.spec)
469
except ValueError, e:
470
raise errors.InvalidRevisionSpec(self.user_spec, context_branch, e)
473
raise errors.InvalidRevisionSpec(self.user_spec, context_branch,
474
'you must supply a positive value')
476
revno = last_revno - offset + 1
478
revision_id = context_branch.get_rev_id(revno, revs_or_none)
479
except errors.NoSuchRevision:
480
raise errors.InvalidRevisionSpec(self.user_spec, context_branch)
481
return revno, revision_id
483
def _as_revision_id(self, context_branch):
484
# We compute the revno as part of the process, but we don't really care
486
revno, revision_id = self._revno_and_revision_id(context_branch, None)
489
SPEC_TYPES.append(RevisionSpec_last)
492
class RevisionSpec_before(RevisionSpec):
493
"""Selects the parent of the revision specified."""
495
help_txt = """Selects the parent of the revision specified.
497
Supply any revision spec to return the parent of that revision. This is
498
mostly useful when inspecting revisions that are not in the revision history
501
It is an error to request the parent of the null revision (before:0).
505
before:1913 -> Return the parent of revno 1913 (revno 1912)
506
before:revid:aaaa@bbbb-1234567890 -> return the parent of revision
508
bzr diff -r before:1913..1913
509
-> Find the changes between revision 1913 and its parent (1912).
510
(What changes did revision 1913 introduce).
511
This is equivalent to: bzr diff -c 1913
516
def _match_on(self, branch, revs):
517
r = RevisionSpec.from_string(self.spec)._match_on(branch, revs)
519
raise errors.InvalidRevisionSpec(self.user_spec, branch,
520
'cannot go before the null: revision')
522
# We need to use the repository history here
523
rev = branch.repository.get_revision(r.rev_id)
524
if not rev.parent_ids:
526
revision_id = revision.NULL_REVISION
528
revision_id = rev.parent_ids[0]
530
revno = revs.index(revision_id) + 1
536
revision_id = branch.get_rev_id(revno, revs)
537
except errors.NoSuchRevision:
538
raise errors.InvalidRevisionSpec(self.user_spec,
540
return RevisionInfo(branch, revno, revision_id)
542
def _as_revision_id(self, context_branch):
543
base_revspec = RevisionSpec.from_string(self.spec)
544
base_revision_id = base_revspec.as_revision_id(context_branch)
545
if base_revision_id == revision.NULL_REVISION:
546
raise errors.InvalidRevisionSpec(self.user_spec, context_branch,
547
'cannot go before the null: revision')
548
context_repo = context_branch.repository
549
context_repo.lock_read()
551
parent_map = context_repo.get_parent_map([base_revision_id])
553
context_repo.unlock()
554
if base_revision_id not in parent_map:
555
# Ghost, or unknown revision id
556
raise errors.InvalidRevisionSpec(self.user_spec, context_branch,
557
'cannot find the matching revision')
558
parents = parent_map[base_revision_id]
560
raise errors.InvalidRevisionSpec(self.user_spec, context_branch,
561
'No parents for revision.')
564
SPEC_TYPES.append(RevisionSpec_before)
567
class RevisionSpec_tag(RevisionSpec):
568
"""Select a revision identified by tag name"""
570
help_txt = """Selects a revision identified by a tag name.
572
Tags are stored in the branch and created by the 'tag' command.
577
def _match_on(self, branch, revs):
578
# Can raise tags not supported, NoSuchTag, etc
579
return RevisionInfo.from_revision_id(branch,
580
branch.tags.lookup_tag(self.spec),
583
def _as_revision_id(self, context_branch):
584
return context_branch.tags.lookup_tag(self.spec)
586
SPEC_TYPES.append(RevisionSpec_tag)
589
class _RevListToTimestamps(object):
590
"""This takes a list of revisions, and allows you to bisect by date"""
592
__slots__ = ['revs', 'branch']
594
def __init__(self, revs, branch):
598
def __getitem__(self, index):
599
"""Get the date of the index'd item"""
600
r = self.branch.repository.get_revision(self.revs[index])
601
# TODO: Handle timezone.
602
return datetime.datetime.fromtimestamp(r.timestamp)
605
return len(self.revs)
608
class RevisionSpec_date(RevisionSpec):
609
"""Selects a revision on the basis of a datestamp."""
611
help_txt = """Selects a revision on the basis of a datestamp.
613
Supply a datestamp to select the first revision that matches the date.
614
Date can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
615
Matches the first entry after a given date (either at midnight or
616
at a specified time).
618
One way to display all the changes since yesterday would be::
620
bzr log -r date:yesterday..
624
date:yesterday -> select the first revision since yesterday
625
date:2006-08-14,17:10:14 -> select the first revision after
626
August 14th, 2006 at 5:10pm.
629
_date_re = re.compile(
630
r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
632
r'(?P<time>(?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d))?)?'
635
def _match_on(self, branch, revs):
636
"""Spec for date revisions:
638
value can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
639
matches the first entry after a given date (either at midnight or
640
at a specified time).
642
# XXX: This doesn't actually work
643
# So the proper way of saying 'give me all entries for today' is:
644
# -r date:yesterday..date:today
645
today = datetime.datetime.fromordinal(datetime.date.today().toordinal())
646
if self.spec.lower() == 'yesterday':
647
dt = today - datetime.timedelta(days=1)
648
elif self.spec.lower() == 'today':
650
elif self.spec.lower() == 'tomorrow':
651
dt = today + datetime.timedelta(days=1)
653
m = self._date_re.match(self.spec)
654
if not m or (not m.group('date') and not m.group('time')):
655
raise errors.InvalidRevisionSpec(self.user_spec,
656
branch, 'invalid date')
660
year = int(m.group('year'))
661
month = int(m.group('month'))
662
day = int(m.group('day'))
669
hour = int(m.group('hour'))
670
minute = int(m.group('minute'))
671
if m.group('second'):
672
second = int(m.group('second'))
676
hour, minute, second = 0,0,0
678
raise errors.InvalidRevisionSpec(self.user_spec,
679
branch, 'invalid date')
681
dt = datetime.datetime(year=year, month=month, day=day,
682
hour=hour, minute=minute, second=second)
685
rev = bisect.bisect(_RevListToTimestamps(revs, branch), dt)
689
raise errors.InvalidRevisionSpec(self.user_spec, branch)
691
return RevisionInfo(branch, rev + 1)
693
SPEC_TYPES.append(RevisionSpec_date)
696
class RevisionSpec_ancestor(RevisionSpec):
697
"""Selects a common ancestor with a second branch."""
699
help_txt = """Selects a common ancestor with a second branch.
701
Supply the path to a branch to select the common ancestor.
703
The common ancestor is the last revision that existed in both
704
branches. Usually this is the branch point, but it could also be
705
a revision that was merged.
707
This is frequently used with 'diff' to return all of the changes
708
that your branch introduces, while excluding the changes that you
709
have not merged from the remote branch.
713
ancestor:/path/to/branch
714
$ bzr diff -r ancestor:../../mainline/branch
718
def _match_on(self, branch, revs):
719
trace.mutter('matching ancestor: on: %s, %s', self.spec, branch)
720
return self._find_revision_info(branch, self.spec)
722
def _as_revision_id(self, context_branch):
723
return self._find_revision_id(context_branch, self.spec)
726
def _find_revision_info(branch, other_location):
727
revision_id = RevisionSpec_ancestor._find_revision_id(branch,
730
revno = branch.revision_id_to_revno(revision_id)
731
except errors.NoSuchRevision:
733
return RevisionInfo(branch, revno, revision_id)
736
def _find_revision_id(branch, other_location):
737
from bzrlib.branch import Branch
741
revision_a = revision.ensure_null(branch.last_revision())
742
if revision_a == revision.NULL_REVISION:
743
raise errors.NoCommits(branch)
744
other_branch = Branch.open(other_location)
745
other_branch.lock_read()
747
revision_b = revision.ensure_null(other_branch.last_revision())
748
if revision_b == revision.NULL_REVISION:
749
raise errors.NoCommits(other_branch)
750
graph = branch.repository.get_graph(other_branch.repository)
751
rev_id = graph.find_unique_lca(revision_a, revision_b)
753
other_branch.unlock()
754
if rev_id == revision.NULL_REVISION:
755
raise errors.NoCommonAncestor(revision_a, revision_b)
761
SPEC_TYPES.append(RevisionSpec_ancestor)
764
class RevisionSpec_branch(RevisionSpec):
765
"""Selects the last revision of a specified branch."""
767
help_txt = """Selects the last revision of a specified branch.
769
Supply the path to a branch to select its last revision.
773
branch:/path/to/branch
777
def _match_on(self, branch, revs):
778
from bzrlib.branch import Branch
779
other_branch = Branch.open(self.spec)
780
revision_b = other_branch.last_revision()
781
if revision_b in (None, revision.NULL_REVISION):
782
raise errors.NoCommits(other_branch)
783
# pull in the remote revisions so we can diff
784
branch.fetch(other_branch, revision_b)
786
revno = branch.revision_id_to_revno(revision_b)
787
except errors.NoSuchRevision:
789
return RevisionInfo(branch, revno, revision_b)
791
def _as_revision_id(self, context_branch):
792
from bzrlib.branch import Branch
793
other_branch = Branch.open(self.spec)
794
last_revision = other_branch.last_revision()
795
last_revision = revision.ensure_null(last_revision)
796
context_branch.fetch(other_branch, last_revision)
797
if last_revision == revision.NULL_REVISION:
798
raise errors.NoCommits(other_branch)
801
def _as_tree(self, context_branch):
802
from bzrlib.branch import Branch
803
other_branch = Branch.open(self.spec)
804
last_revision = other_branch.last_revision()
805
last_revision = revision.ensure_null(last_revision)
806
if last_revision == revision.NULL_REVISION:
807
raise errors.NoCommits(other_branch)
808
return other_branch.repository.revision_tree(last_revision)
810
SPEC_TYPES.append(RevisionSpec_branch)
813
class RevisionSpec_submit(RevisionSpec_ancestor):
814
"""Selects a common ancestor with a submit branch."""
816
help_txt = """Selects a common ancestor with the submit branch.
818
Diffing against this shows all the changes that were made in this branch,
819
and is a good predictor of what merge will do. The submit branch is
820
used by the bundle and merge directive commands. If no submit branch
821
is specified, the parent branch is used instead.
823
The common ancestor is the last revision that existed in both
824
branches. Usually this is the branch point, but it could also be
825
a revision that was merged.
829
$ bzr diff -r submit:
834
def _get_submit_location(self, branch):
835
submit_location = branch.get_submit_branch()
836
location_type = 'submit branch'
837
if submit_location is None:
838
submit_location = branch.get_parent()
839
location_type = 'parent branch'
840
if submit_location is None:
841
raise errors.NoSubmitBranch(branch)
842
trace.note('Using %s %s', location_type, submit_location)
843
return submit_location
845
def _match_on(self, branch, revs):
846
trace.mutter('matching ancestor: on: %s, %s', self.spec, branch)
847
return self._find_revision_info(branch,
848
self._get_submit_location(branch))
850
def _as_revision_id(self, context_branch):
851
return self._find_revision_id(context_branch,
852
self._get_submit_location(context_branch))
855
SPEC_TYPES.append(RevisionSpec_submit)
added
removed
bzrlib/revisionspec.py
