141
wants_revision_history = True
144
def from_string(spec):
145
"""Parse a revision spec string into a RevisionSpec object.
147
:param spec: A string specified by the user
148
:return: A RevisionSpec object that understands how to parse the
107
def __new__(cls, spec, foo=_marker):
108
"""Parse a revision specifier.
151
if not isinstance(spec, (type(None), basestring)):
152
raise TypeError('error')
155
return RevisionSpec(None, _internal=True)
156
for spectype in SPEC_TYPES:
157
if spec.startswith(spectype.prefix):
158
trace.mutter('Returning RevisionSpec %s for %s',
159
spectype.__name__, spec)
160
return spectype(spec, _internal=True)
111
return object.__new__(RevisionSpec, spec)
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)
125
raise BzrError('No namespace registered for string: %r' %
162
# RevisionSpec_revno is special cased, because it is the only
163
# one that directly handles plain integers
164
# TODO: This should not be special cased rather it should be
165
# a method invocation on spectype.canparse()
167
if _revno_regex is None:
168
_revno_regex = re.compile(r'^(?:(\d+(\.\d+)*)|-\d+)(:.*)?$')
169
if _revno_regex.match(spec) is not None:
170
return RevisionSpec_revno(spec, _internal=True)
172
raise errors.NoSuchRevisionSpec(spec)
174
def __init__(self, spec, _internal=False):
175
"""Create a RevisionSpec referring to the Null revision.
177
:param spec: The original spec supplied by the user
178
:param _internal: Used to ensure that RevisionSpec is not being
179
called directly. Only from RevisionSpec.from_string()
182
# XXX: Update this after 0.10 is released
183
symbol_versioning.warn('Creating a RevisionSpec directly has'
184
' been deprecated in version 0.11. Use'
185
' RevisionSpec.from_string()'
187
DeprecationWarning, stacklevel=2)
188
self.user_spec = spec
128
raise TypeError('Unhandled revision type %s' % spec)
130
def __init__(self, spec):
189
131
if self.prefix and spec.startswith(self.prefix):
190
132
spec = spec[len(self.prefix):]
193
135
def _match_on(self, branch, revs):
194
trace.mutter('Returning RevisionSpec._match_on: None')
195
return RevisionInfo(branch, None, None)
136
return RevisionInfo(branch, 0, None)
197
138
def _match_on_and_check(self, branch, revs):
198
139
info = self._match_on(branch, revs)
201
elif info == (None, None):
202
# special case - nothing supplied
142
elif info == (0, None):
143
# special case - the empty tree
204
145
elif self.prefix:
205
raise errors.InvalidRevisionSpec(self.user_spec, branch)
146
raise NoSuchRevision(branch, self.prefix + str(self.spec))
207
raise errors.InvalidRevisionSpec(self.spec, branch)
148
raise NoSuchRevision(branch, str(self.spec))
209
150
def in_history(self, branch):
211
if self.wants_revision_history:
212
revs = branch.revision_history()
216
# this should never trigger.
217
# TODO: make it a deprecated code path. RBC 20060928
151
revs = branch.revision_history()
219
152
return self._match_on_and_check(branch, revs)
221
154
# FIXME: in_history is somewhat broken,
227
160
# will do what you expect.
228
161
in_store = in_history
229
162
in_branch = in_store
231
def as_revision_id(self, context_branch):
232
"""Return just the revision_id for this revisions spec.
234
Some revision specs require a context_branch to be able to determine
235
their value. Not all specs will make use of it.
237
return self._as_revision_id(context_branch)
239
def _as_revision_id(self, context_branch):
240
"""Implementation of as_revision_id()
242
Classes should override this function to provide appropriate
243
functionality. The default is to just call '.in_history().rev_id'
245
return self.in_history(context_branch).rev_id
247
def as_tree(self, context_branch):
248
"""Return the tree object for this revisions spec.
250
Some revision specs require a context_branch to be able to determine
251
the revision id and access the repository. Not all specs will make
254
return self._as_tree(context_branch)
256
def _as_tree(self, context_branch):
257
"""Implementation of as_tree().
259
Classes should override this function to provide appropriate
260
functionality. The default is to just call '.as_revision_id()'
261
and get the revision tree from context_branch's repository.
263
revision_id = self.as_revision_id(context_branch)
264
return context_branch.repository.revision_tree(revision_id)
266
164
def __repr__(self):
267
165
# this is mostly for helping with testing
268
return '<%s %s>' % (self.__class__.__name__,
271
def needs_branch(self):
272
"""Whether this revision spec needs a branch.
274
Set this to False the branch argument of _match_on is not used.
278
def get_branch(self):
279
"""When the revision specifier contains a branch location, return it.
281
Otherwise, return None.
166
return '<%s %s%s>' % (self.__class__.__name__,
173
class RevisionSpec_int(RevisionSpec):
174
"""Spec is a number. Special case."""
175
def __init__(self, spec):
176
self.spec = int(spec)
178
def _match_on(self, branch, revs):
180
revno = len(revs) + self.spec + 1
183
rev_id = branch.get_rev_id(revno, revs)
184
return RevisionInfo(branch, revno, rev_id)
288
187
class RevisionSpec_revno(RevisionSpec):
289
"""Selects a revision using a number."""
291
help_txt = """Selects a revision using a number.
293
Use an integer to specify a revision in the history of the branch.
294
Optionally a branch can be specified. The 'revno:' prefix is optional.
295
A negative number will count from the end of the branch (-1 is the
296
last revision, -2 the previous one). If the negative number is larger
297
than the branch's history, the first revision is returned.
300
revno:1 -> return the first revision of this branch
301
revno:3:/path/to/branch -> return the 3rd revision of
302
the branch '/path/to/branch'
303
revno:-1 -> The last revision in a branch.
304
-2:http://other/branch -> The second to last revision in the
306
-1000000 -> Most likely the first revision, unless
307
your history is very long.
309
188
prefix = 'revno:'
310
wants_revision_history = False
312
190
def _match_on(self, branch, revs):
313
191
"""Lookup a revision by revision number"""
314
branch, revno, revision_id = self._lookup(branch, revs)
315
return RevisionInfo(branch, revno, revision_id)
317
def _lookup(self, branch, revs_or_none):
318
loc = self.spec.find(':')
320
revno_spec = self.spec
323
revno_spec = self.spec[:loc]
324
branch_spec = self.spec[loc+1:]
328
raise errors.InvalidRevisionSpec(self.user_spec,
329
branch, 'cannot have an empty revno and no branch')
333
revno = int(revno_spec)
336
# dotted decimal. This arguably should not be here
337
# but the from_string method is a little primitive
338
# right now - RBC 20060928
340
match_revno = tuple((int(number) for number in revno_spec.split('.')))
341
except ValueError, e:
342
raise errors.InvalidRevisionSpec(self.user_spec, branch, e)
347
# the user has override the branch to look in.
348
# we need to refresh the revision_history map and
350
from bzrlib.branch import Branch
351
branch = Branch.open(branch_spec)
357
revision_id_to_revno = branch.get_revision_id_to_revno_map()
358
revisions = [revision_id for revision_id, revno
359
in revision_id_to_revno.iteritems()
360
if revno == match_revno]
363
if len(revisions) != 1:
364
return branch, None, None
366
# there is no traditional 'revno' for dotted-decimal revnos.
367
# so for API compatability we return None.
368
return branch, None, revisions[0]
370
last_revno, last_revision_id = branch.last_revision_info()
372
# if get_rev_id supported negative revnos, there would not be a
373
# need for this special case.
374
if (-revno) >= last_revno:
377
revno = last_revno + revno + 1
379
revision_id = branch.get_rev_id(revno, revs_or_none)
380
except errors.NoSuchRevision:
381
raise errors.InvalidRevisionSpec(self.user_spec, branch)
382
return branch, revno, revision_id
384
def _as_revision_id(self, context_branch):
385
# We would have the revno here, but we don't really care
386
branch, revno, revision_id = self._lookup(context_branch, None)
389
def needs_branch(self):
390
return self.spec.find(':') == -1
392
def get_branch(self):
393
if self.spec.find(':') == -1:
396
return self.spec[self.spec.find(':')+1:]
399
RevisionSpec_int = RevisionSpec_revno
193
return RevisionInfo(branch, int(self.spec))
195
return RevisionInfo(branch, None)
401
197
SPEC_TYPES.append(RevisionSpec_revno)
404
200
class RevisionSpec_revid(RevisionSpec):
405
"""Selects a revision using the revision id."""
407
help_txt = """Selects a revision using the revision id.
409
Supply a specific revision id, that can be used to specify any
410
revision id in the ancestry of the branch.
411
Including merges, and pending merges.
414
revid:aaaa@bbbb-123456789 -> Select revision 'aaaa@bbbb-123456789'
417
201
prefix = 'revid:'
419
203
def _match_on(self, branch, revs):
420
# self.spec comes straight from parsing the command line arguments,
421
# so we expect it to be a Unicode string. Switch it to the internal
423
revision_id = osutils.safe_revision_id(self.spec, warn=False)
424
return RevisionInfo.from_revision_id(branch, revision_id, revs)
426
def _as_revision_id(self, context_branch):
427
return osutils.safe_revision_id(self.spec, warn=False)
205
return RevisionInfo(branch, revs.index(self.spec) + 1, self.spec)
207
return RevisionInfo(branch, None, self.spec)
429
209
SPEC_TYPES.append(RevisionSpec_revid)
432
212
class RevisionSpec_last(RevisionSpec):
433
"""Selects the nth revision from the end."""
435
help_txt = """Selects the nth revision from the end.
437
Supply a positive number to get the nth revision from the end.
438
This is the same as supplying negative numbers to the 'revno:' spec.
441
last:1 -> return the last revision
442
last:3 -> return the revision 2 before the end.
447
216
def _match_on(self, branch, revs):
448
revno, revision_id = self._revno_and_revision_id(branch, revs)
449
return RevisionInfo(branch, revno, revision_id)
451
def _revno_and_revision_id(self, context_branch, revs_or_none):
452
last_revno, last_revision_id = context_branch.last_revision_info()
456
raise errors.NoCommits(context_branch)
457
return last_revno, last_revision_id
460
218
offset = int(self.spec)
461
except ValueError, e:
462
raise errors.InvalidRevisionSpec(self.user_spec, context_branch, e)
465
raise errors.InvalidRevisionSpec(self.user_spec, context_branch,
466
'you must supply a positive value')
468
revno = last_revno - offset + 1
470
revision_id = context_branch.get_rev_id(revno, revs_or_none)
471
except errors.NoSuchRevision:
472
raise errors.InvalidRevisionSpec(self.user_spec, context_branch)
473
return revno, revision_id
475
def _as_revision_id(self, context_branch):
476
# We compute the revno as part of the process, but we don't really care
478
revno, revision_id = self._revno_and_revision_id(context_branch, None)
220
return RevisionInfo(branch, None)
223
raise BzrError('You must supply a positive value for --revision last:XXX')
224
return RevisionInfo(branch, len(revs) - offset + 1)
481
226
SPEC_TYPES.append(RevisionSpec_last)
484
229
class RevisionSpec_before(RevisionSpec):
485
"""Selects the parent of the revision specified."""
487
help_txt = """Selects the parent of the revision specified.
489
Supply any revision spec to return the parent of that revision. This is
490
mostly useful when inspecting revisions that are not in the revision history
493
It is an error to request the parent of the null revision (before:0).
497
before:1913 -> Return the parent of revno 1913 (revno 1912)
498
before:revid:aaaa@bbbb-1234567890 -> return the parent of revision
500
bzr diff -r before:1913..1913
501
-> Find the changes between revision 1913 and its parent (1912).
502
(What changes did revision 1913 introduce).
503
This is equivalent to: bzr diff -c 1913
506
231
prefix = 'before:'
508
233
def _match_on(self, branch, revs):
509
r = RevisionSpec.from_string(self.spec)._match_on(branch, revs)
511
raise errors.InvalidRevisionSpec(self.user_spec, branch,
512
'cannot go before the null: revision')
514
# We need to use the repository history here
515
rev = branch.repository.get_revision(r.rev_id)
516
if not rev.parent_ids:
518
revision_id = revision.NULL_REVISION
520
revision_id = rev.parent_ids[0]
522
revno = revs.index(revision_id) + 1
528
revision_id = branch.get_rev_id(revno, revs)
529
except errors.NoSuchRevision:
530
raise errors.InvalidRevisionSpec(self.user_spec,
532
return RevisionInfo(branch, revno, revision_id)
534
def _as_revision_id(self, context_branch):
535
base_revspec = RevisionSpec.from_string(self.spec)
536
base_revision_id = base_revspec.as_revision_id(context_branch)
537
if base_revision_id == revision.NULL_REVISION:
538
raise errors.InvalidRevisionSpec(self.user_spec, context_branch,
539
'cannot go before the null: revision')
540
context_repo = context_branch.repository
541
context_repo.lock_read()
543
parent_map = context_repo.get_parent_map([base_revision_id])
545
context_repo.unlock()
546
if base_revision_id not in parent_map:
547
# Ghost, or unknown revision id
548
raise errors.InvalidRevisionSpec(self.user_spec, context_branch,
549
'cannot find the matching revision')
550
parents = parent_map[base_revision_id]
552
raise errors.InvalidRevisionSpec(self.user_spec, context_branch,
553
'No parents for revision.')
234
r = RevisionSpec(self.spec)._match_on(branch, revs)
235
if (r.revno is None) or (r.revno == 0):
237
return RevisionInfo(branch, r.revno - 1)
556
239
SPEC_TYPES.append(RevisionSpec_before)
559
242
class RevisionSpec_tag(RevisionSpec):
560
"""Select a revision identified by tag name"""
562
help_txt = """Selects a revision identified by a tag name.
564
Tags are stored in the branch and created by the 'tag' command.
569
245
def _match_on(self, branch, revs):
570
# Can raise tags not supported, NoSuchTag, etc
571
return RevisionInfo.from_revision_id(branch,
572
branch.tags.lookup_tag(self.spec),
575
def _as_revision_id(self, context_branch):
576
return context_branch.tags.lookup_tag(self.spec)
246
raise BzrError('tag: namespace registered, but not implemented.')
578
248
SPEC_TYPES.append(RevisionSpec_tag)
581
class _RevListToTimestamps(object):
582
"""This takes a list of revisions, and allows you to bisect by date"""
584
__slots__ = ['revs', 'branch']
586
def __init__(self, revs, branch):
590
def __getitem__(self, index):
591
"""Get the date of the index'd item"""
592
r = self.branch.repository.get_revision(self.revs[index])
593
# TODO: Handle timezone.
594
return datetime.datetime.fromtimestamp(r.timestamp)
597
return len(self.revs)
600
251
class RevisionSpec_date(RevisionSpec):
601
"""Selects a revision on the basis of a datestamp."""
603
help_txt = """Selects a revision on the basis of a datestamp.
605
Supply a datestamp to select the first revision that matches the date.
606
Date can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
607
Matches the first entry after a given date (either at midnight or
608
at a specified time).
610
One way to display all the changes since yesterday would be::
612
bzr log -r date:yesterday..
616
date:yesterday -> select the first revision since yesterday
617
date:2006-08-14,17:10:14 -> select the first revision after
618
August 14th, 2006 at 5:10pm.
621
253
_date_re = re.compile(
622
254
r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
645
278
m = self._date_re.match(self.spec)
646
279
if not m or (not m.group('date') and not m.group('time')):
647
raise errors.InvalidRevisionSpec(self.user_spec,
648
branch, 'invalid date')
652
year = int(m.group('year'))
653
month = int(m.group('month'))
654
day = int(m.group('day'))
661
hour = int(m.group('hour'))
662
minute = int(m.group('minute'))
663
if m.group('second'):
664
second = int(m.group('second'))
668
hour, minute, second = 0,0,0
670
raise errors.InvalidRevisionSpec(self.user_spec,
671
branch, 'invalid date')
280
raise BzrError('Invalid revision date %r' % self.spec)
283
year, month, day = int(m.group('year')), int(m.group('month')), int(m.group('day'))
285
year, month, day = today.year, today.month, today.day
287
hour = int(m.group('hour'))
288
minute = int(m.group('minute'))
289
if m.group('second'):
290
second = int(m.group('second'))
294
hour, minute, second = 0,0,0
673
296
dt = datetime.datetime(year=year, month=month, day=day,
674
297
hour=hour, minute=minute, second=second)
677
rev = bisect.bisect(_RevListToTimestamps(revs, branch), dt)
681
raise errors.InvalidRevisionSpec(self.user_spec, branch)
683
return RevisionInfo(branch, rev + 1)
299
for i in range(len(revs)):
300
r = branch.repository.get_revision(revs[i])
301
# TODO: Handle timezone.
302
dt = datetime.datetime.fromtimestamp(r.timestamp)
304
return RevisionInfo(branch, i+1)
305
return RevisionInfo(branch, None)
685
307
SPEC_TYPES.append(RevisionSpec_date)
688
310
class RevisionSpec_ancestor(RevisionSpec):
689
"""Selects a common ancestor with a second branch."""
691
help_txt = """Selects a common ancestor with a second branch.
693
Supply the path to a branch to select the common ancestor.
695
The common ancestor is the last revision that existed in both
696
branches. Usually this is the branch point, but it could also be
697
a revision that was merged.
699
This is frequently used with 'diff' to return all of the changes
700
that your branch introduces, while excluding the changes that you
701
have not merged from the remote branch.
705
ancestor:/path/to/branch
706
$ bzr diff -r ancestor:../../mainline/branch
708
311
prefix = 'ancestor:'
710
313
def _match_on(self, branch, revs):
711
trace.mutter('matching ancestor: on: %s, %s', self.spec, branch)
712
return self._find_revision_info(branch, self.spec)
714
def _as_revision_id(self, context_branch):
715
return self._find_revision_id(context_branch, self.spec)
718
def _find_revision_info(branch, other_location):
719
revision_id = RevisionSpec_ancestor._find_revision_id(branch,
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)):
322
revision_source = MultipleRevisionSources(branch.repository,
323
other_branch.repository)
324
rev_id = common_ancestor(revision_a, revision_b, revision_source)
722
revno = branch.revision_id_to_revno(revision_id)
723
except errors.NoSuchRevision:
326
revno = branch.revision_id_to_revno(rev_id)
327
except NoSuchRevision:
725
return RevisionInfo(branch, revno, revision_id)
728
def _find_revision_id(branch, other_location):
729
from bzrlib.branch import Branch
733
revision_a = revision.ensure_null(branch.last_revision())
734
if revision_a == revision.NULL_REVISION:
735
raise errors.NoCommits(branch)
736
other_branch = Branch.open(other_location)
737
other_branch.lock_read()
739
revision_b = revision.ensure_null(other_branch.last_revision())
740
if revision_b == revision.NULL_REVISION:
741
raise errors.NoCommits(other_branch)
742
graph = branch.repository.get_graph(other_branch.repository)
743
rev_id = graph.find_unique_lca(revision_a, revision_b)
745
other_branch.unlock()
746
if rev_id == revision.NULL_REVISION:
747
raise errors.NoCommonAncestor(revision_a, revision_b)
329
return RevisionInfo(branch, revno, rev_id)
753
331
SPEC_TYPES.append(RevisionSpec_ancestor)
756
333
class RevisionSpec_branch(RevisionSpec):
757
"""Selects the last revision of a specified branch."""
759
help_txt = """Selects the last revision of a specified branch.
761
Supply the path to a branch to select its last revision.
765
branch:/path/to/branch
334
"""A branch: revision specifier.
336
This takes the path to a branch and returns its tip revision id.
767
338
prefix = 'branch:'
769
340
def _match_on(self, branch, revs):
770
from bzrlib.branch import Branch
771
other_branch = Branch.open(self.spec)
341
from branch import Branch
342
other_branch = Branch.open_containing(self.spec)[0]
772
343
revision_b = other_branch.last_revision()
773
if revision_b in (None, revision.NULL_REVISION):
774
raise errors.NoCommits(other_branch)
344
if revision_b is None:
345
raise NoCommits(other_branch)
775
346
# pull in the remote revisions so we can diff
776
347
branch.fetch(other_branch, revision_b)
778
349
revno = branch.revision_id_to_revno(revision_b)
779
except errors.NoSuchRevision:
350
except NoSuchRevision:
781
352
return RevisionInfo(branch, revno, revision_b)
783
def _as_revision_id(self, context_branch):
784
from bzrlib.branch import Branch
785
other_branch = Branch.open(self.spec)
786
last_revision = other_branch.last_revision()
787
last_revision = revision.ensure_null(last_revision)
788
context_branch.fetch(other_branch, last_revision)
789
if last_revision == revision.NULL_REVISION:
790
raise errors.NoCommits(other_branch)
793
def _as_tree(self, context_branch):
794
from bzrlib.branch import Branch
795
other_branch = Branch.open(self.spec)
796
last_revision = other_branch.last_revision()
797
last_revision = revision.ensure_null(last_revision)
798
if last_revision == revision.NULL_REVISION:
799
raise errors.NoCommits(other_branch)
800
return other_branch.repository.revision_tree(last_revision)
802
354
SPEC_TYPES.append(RevisionSpec_branch)
805
class RevisionSpec_submit(RevisionSpec_ancestor):
806
"""Selects a common ancestor with a submit branch."""
808
help_txt = """Selects a common ancestor with the submit branch.
810
Diffing against this shows all the changes that were made in this branch,
811
and is a good predictor of what merge will do. The submit branch is
812
used by the bundle and merge directive commands. If no submit branch
813
is specified, the parent branch is used instead.
815
The common ancestor is the last revision that existed in both
816
branches. Usually this is the branch point, but it could also be
817
a revision that was merged.
821
$ bzr diff -r submit:
826
def _get_submit_location(self, branch):
827
submit_location = branch.get_submit_branch()
828
location_type = 'submit branch'
829
if submit_location is None:
830
submit_location = branch.get_parent()
831
location_type = 'parent branch'
832
if submit_location is None:
833
raise errors.NoSubmitBranch(branch)
834
trace.note('Using %s %s', location_type, submit_location)
835
return submit_location
837
def _match_on(self, branch, revs):
838
trace.mutter('matching ancestor: on: %s, %s', self.spec, branch)
839
return self._find_revision_info(branch,
840
self._get_submit_location(branch))
842
def _as_revision_id(self, context_branch):
843
return self._find_revision_id(context_branch,
844
self._get_submit_location(context_branch))
847
SPEC_TYPES.append(RevisionSpec_submit)
added
removed
bzrlib/revisionspec.py
