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
107
def __new__(cls, spec, foo=_marker):
108
"""Parse a revision specifier.
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)
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' %
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
128
raise TypeError('Unhandled revision type %s' % spec)
130
def __init__(self, spec):
197
131
if self.prefix and spec.startswith(self.prefix):
198
132
spec = spec[len(self.prefix):]
201
135
def _match_on(self, branch, revs):
202
trace.mutter('Returning RevisionSpec._match_on: None')
203
return RevisionInfo(branch, None, None)
136
return RevisionInfo(branch, 0, None)
205
138
def _match_on_and_check(self, branch, revs):
206
139
info = self._match_on(branch, revs)
209
elif info == (None, None):
210
# special case - nothing supplied
142
elif info == (0, None):
143
# special case - the empty tree
212
145
elif self.prefix:
213
raise errors.InvalidRevisionSpec(self.user_spec, branch)
146
raise NoSuchRevision(branch, self.prefix + str(self.spec))
215
raise errors.InvalidRevisionSpec(self.spec, branch)
148
raise NoSuchRevision(branch, str(self.spec))
217
150
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
151
revs = branch.revision_history()
227
152
return self._match_on_and_check(branch, revs)
229
154
# FIXME: in_history is somewhat broken,
235
160
# will do what you expect.
236
161
in_store = in_history
237
162
in_branch = in_store
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
164
def __repr__(self):
256
165
# 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.
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)
277
187
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.
298
188
prefix = 'revno:'
299
wants_revision_history = False
301
190
def _match_on(self, branch, revs):
302
191
"""Lookup a revision by revision number"""
303
branch, revno, revision_id = self._lookup(branch, revs)
304
return RevisionInfo(branch, revno, revision_id)
306
def _lookup(self, branch, revs_or_none):
307
loc = self.spec.find(':')
309
revno_spec = self.spec
312
revno_spec = self.spec[:loc]
313
branch_spec = self.spec[loc+1:]
317
raise errors.InvalidRevisionSpec(self.user_spec,
318
branch, 'cannot have an empty revno and no branch')
322
revno = int(revno_spec)
325
# dotted decimal. This arguably should not be here
326
# but the from_string method is a little primitive
327
# right now - RBC 20060928
329
match_revno = tuple((int(number) for number in revno_spec.split('.')))
330
except ValueError, e:
331
raise errors.InvalidRevisionSpec(self.user_spec, branch, e)
336
# the user has override the branch to look in.
337
# we need to refresh the revision_history map and
339
from bzrlib.branch import Branch
340
branch = Branch.open(branch_spec)
346
revision_id_to_revno = branch.get_revision_id_to_revno_map()
347
revisions = [revision_id for revision_id, revno
348
in revision_id_to_revno.iteritems()
349
if revno == match_revno]
352
if len(revisions) != 1:
353
return branch, None, None
355
# there is no traditional 'revno' for dotted-decimal revnos.
356
# so for API compatability we return None.
357
return branch, None, revisions[0]
359
last_revno, last_revision_id = branch.last_revision_info()
361
# if get_rev_id supported negative revnos, there would not be a
362
# need for this special case.
363
if (-revno) >= last_revno:
366
revno = last_revno + revno + 1
368
revision_id = branch.get_rev_id(revno, revs_or_none)
369
except errors.NoSuchRevision:
370
raise errors.InvalidRevisionSpec(self.user_spec, branch)
371
return branch, revno, revision_id
373
def _as_revision_id(self, context_branch):
374
# We would have the revno here, but we don't really care
375
branch, revno, revision_id = self._lookup(context_branch, None)
378
def needs_branch(self):
379
return self.spec.find(':') == -1
381
def get_branch(self):
382
if self.spec.find(':') == -1:
385
return self.spec[self.spec.find(':')+1:]
388
RevisionSpec_int = RevisionSpec_revno
193
return RevisionInfo(branch, int(self.spec))
195
return RevisionInfo(branch, None)
390
197
SPEC_TYPES.append(RevisionSpec_revno)
393
200
class RevisionSpec_revid(RevisionSpec):
394
"""Selects a revision using the revision id."""
396
help_txt = """Selects a revision using the revision id.
398
Supply a specific revision id, that can be used to specify any
399
revision id in the ancestry of the branch.
400
Including merges, and pending merges.
403
revid:aaaa@bbbb-123456789 -> Select revision 'aaaa@bbbb-123456789'
406
201
prefix = 'revid:'
408
203
def _match_on(self, branch, revs):
409
# self.spec comes straight from parsing the command line arguments,
410
# so we expect it to be a Unicode string. Switch it to the internal
412
revision_id = osutils.safe_revision_id(self.spec, warn=False)
413
return RevisionInfo.from_revision_id(branch, revision_id, revs)
415
def _as_revision_id(self, context_branch):
416
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)
418
209
SPEC_TYPES.append(RevisionSpec_revid)
421
212
class RevisionSpec_last(RevisionSpec):
422
"""Selects the nth revision from the end."""
424
help_txt = """Selects the nth revision from the end.
426
Supply a positive number to get the nth revision from the end.
427
This is the same as supplying negative numbers to the 'revno:' spec.
430
last:1 -> return the last revision
431
last:3 -> return the revision 2 before the end.
436
216
def _match_on(self, branch, revs):
437
revno, revision_id = self._revno_and_revision_id(branch, revs)
438
return RevisionInfo(branch, revno, revision_id)
440
def _revno_and_revision_id(self, context_branch, revs_or_none):
441
last_revno, last_revision_id = context_branch.last_revision_info()
445
raise errors.NoCommits(context_branch)
446
return last_revno, last_revision_id
449
218
offset = int(self.spec)
450
except ValueError, e:
451
raise errors.InvalidRevisionSpec(self.user_spec, context_branch, e)
454
raise errors.InvalidRevisionSpec(self.user_spec, context_branch,
455
'you must supply a positive value')
457
revno = last_revno - offset + 1
459
revision_id = context_branch.get_rev_id(revno, revs_or_none)
460
except errors.NoSuchRevision:
461
raise errors.InvalidRevisionSpec(self.user_spec, context_branch)
462
return revno, revision_id
464
def _as_revision_id(self, context_branch):
465
# We compute the revno as part of the process, but we don't really care
467
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)
470
226
SPEC_TYPES.append(RevisionSpec_last)
473
229
class RevisionSpec_before(RevisionSpec):
474
"""Selects the parent of the revision specified."""
476
help_txt = """Selects the parent of the revision specified.
478
Supply any revision spec to return the parent of that revision.
479
It is an error to request the parent of the null revision (before:0).
480
This is mostly useful when inspecting revisions that are not in the
481
revision history of a branch.
485
before:1913 -> Return the parent of revno 1913 (revno 1912)
486
before:revid:aaaa@bbbb-1234567890 -> return the parent of revision
488
bzr diff -r before:revid:aaaa..revid:aaaa
489
-> Find the changes between revision 'aaaa' and its parent.
490
(what changes did 'aaaa' introduce)
493
231
prefix = 'before:'
495
233
def _match_on(self, branch, revs):
496
r = RevisionSpec.from_string(self.spec)._match_on(branch, revs)
498
raise errors.InvalidRevisionSpec(self.user_spec, branch,
499
'cannot go before the null: revision')
501
# We need to use the repository history here
502
rev = branch.repository.get_revision(r.rev_id)
503
if not rev.parent_ids:
505
revision_id = revision.NULL_REVISION
507
revision_id = rev.parent_ids[0]
509
revno = revs.index(revision_id) + 1
515
revision_id = branch.get_rev_id(revno, revs)
516
except errors.NoSuchRevision:
517
raise errors.InvalidRevisionSpec(self.user_spec,
519
return RevisionInfo(branch, revno, revision_id)
521
def _as_revision_id(self, context_branch):
522
base_revspec = RevisionSpec.from_string(self.spec)
523
base_revision_id = base_revspec.as_revision_id(context_branch)
524
if base_revision_id == revision.NULL_REVISION:
525
raise errors.InvalidRevisionSpec(self.user_spec, context_branch,
526
'cannot go before the null: revision')
527
context_repo = context_branch.repository
528
context_repo.lock_read()
530
parent_map = context_repo.get_parent_map([base_revision_id])
532
context_repo.unlock()
533
if base_revision_id not in parent_map:
534
# Ghost, or unknown revision id
535
raise errors.InvalidRevisionSpec(self.user_spec, context_branch,
536
'cannot find the matching revision')
537
parents = parent_map[base_revision_id]
539
raise errors.InvalidRevisionSpec(self.user_spec, context_branch,
540
'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)
543
239
SPEC_TYPES.append(RevisionSpec_before)
546
242
class RevisionSpec_tag(RevisionSpec):
547
"""Select a revision identified by tag name"""
549
help_txt = """Selects a revision identified by a tag name.
551
Tags are stored in the branch and created by the 'tag' command.
556
245
def _match_on(self, branch, revs):
557
# Can raise tags not supported, NoSuchTag, etc
558
return RevisionInfo.from_revision_id(branch,
559
branch.tags.lookup_tag(self.spec),
562
def _as_revision_id(self, context_branch):
563
return context_branch.tags.lookup_tag(self.spec)
246
raise BzrError('tag: namespace registered, but not implemented.')
565
248
SPEC_TYPES.append(RevisionSpec_tag)
568
class _RevListToTimestamps(object):
569
"""This takes a list of revisions, and allows you to bisect by date"""
571
__slots__ = ['revs', 'branch']
573
def __init__(self, revs, branch):
577
def __getitem__(self, index):
578
"""Get the date of the index'd item"""
579
r = self.branch.repository.get_revision(self.revs[index])
580
# TODO: Handle timezone.
581
return datetime.datetime.fromtimestamp(r.timestamp)
584
return len(self.revs)
587
251
class RevisionSpec_date(RevisionSpec):
588
"""Selects a revision on the basis of a datestamp."""
590
help_txt = """Selects a revision on the basis of a datestamp.
592
Supply a datestamp to select the first revision that matches the date.
593
Date can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
594
Matches the first entry after a given date (either at midnight or
595
at a specified time).
597
One way to display all the changes since yesterday would be::
599
bzr log -r date:yesterday..
603
date:yesterday -> select the first revision since yesterday
604
date:2006-08-14,17:10:14 -> select the first revision after
605
August 14th, 2006 at 5:10pm.
608
253
_date_re = re.compile(
609
254
r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
632
278
m = self._date_re.match(self.spec)
633
279
if not m or (not m.group('date') and not m.group('time')):
634
raise errors.InvalidRevisionSpec(self.user_spec,
635
branch, 'invalid date')
639
year = int(m.group('year'))
640
month = int(m.group('month'))
641
day = int(m.group('day'))
648
hour = int(m.group('hour'))
649
minute = int(m.group('minute'))
650
if m.group('second'):
651
second = int(m.group('second'))
655
hour, minute, second = 0,0,0
657
raise errors.InvalidRevisionSpec(self.user_spec,
658
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
660
296
dt = datetime.datetime(year=year, month=month, day=day,
661
297
hour=hour, minute=minute, second=second)
664
rev = bisect.bisect(_RevListToTimestamps(revs, branch), dt)
668
raise errors.InvalidRevisionSpec(self.user_spec, branch)
670
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)
672
307
SPEC_TYPES.append(RevisionSpec_date)
675
310
class RevisionSpec_ancestor(RevisionSpec):
676
"""Selects a common ancestor with a second branch."""
678
help_txt = """Selects a common ancestor with a second branch.
680
Supply the path to a branch to select the common ancestor.
682
The common ancestor is the last revision that existed in both
683
branches. Usually this is the branch point, but it could also be
684
a revision that was merged.
686
This is frequently used with 'diff' to return all of the changes
687
that your branch introduces, while excluding the changes that you
688
have not merged from the remote branch.
692
ancestor:/path/to/branch
693
$ bzr diff -r ancestor:../../mainline/branch
695
311
prefix = 'ancestor:'
697
313
def _match_on(self, branch, revs):
698
trace.mutter('matching ancestor: on: %s, %s', self.spec, branch)
699
return self._find_revision_info(branch, self.spec)
701
def _as_revision_id(self, context_branch):
702
return self._find_revision_id(context_branch, self.spec)
705
def _find_revision_info(branch, other_location):
706
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)
709
revno = branch.revision_id_to_revno(revision_id)
710
except errors.NoSuchRevision:
326
revno = branch.revision_id_to_revno(rev_id)
327
except NoSuchRevision:
712
return RevisionInfo(branch, revno, revision_id)
715
def _find_revision_id(branch, other_location):
716
from bzrlib.branch import Branch
720
revision_a = revision.ensure_null(branch.last_revision())
721
if revision_a == revision.NULL_REVISION:
722
raise errors.NoCommits(branch)
723
other_branch = Branch.open(other_location)
724
other_branch.lock_read()
726
revision_b = revision.ensure_null(other_branch.last_revision())
727
if revision_b == revision.NULL_REVISION:
728
raise errors.NoCommits(other_branch)
729
graph = branch.repository.get_graph(other_branch.repository)
730
rev_id = graph.find_unique_lca(revision_a, revision_b)
732
other_branch.unlock()
733
if rev_id == revision.NULL_REVISION:
734
raise errors.NoCommonAncestor(revision_a, revision_b)
329
return RevisionInfo(branch, revno, rev_id)
740
331
SPEC_TYPES.append(RevisionSpec_ancestor)
743
333
class RevisionSpec_branch(RevisionSpec):
744
"""Selects the last revision of a specified branch."""
746
help_txt = """Selects the last revision of a specified branch.
748
Supply the path to a branch to select its last revision.
752
branch:/path/to/branch
334
"""A branch: revision specifier.
336
This takes the path to a branch and returns its tip revision id.
754
338
prefix = 'branch:'
756
340
def _match_on(self, branch, revs):
757
from bzrlib.branch import Branch
758
other_branch = Branch.open(self.spec)
341
from branch import Branch
342
other_branch = Branch.open_containing(self.spec)[0]
759
343
revision_b = other_branch.last_revision()
760
if revision_b in (None, revision.NULL_REVISION):
761
raise errors.NoCommits(other_branch)
344
if revision_b is None:
345
raise NoCommits(other_branch)
762
346
# pull in the remote revisions so we can diff
763
347
branch.fetch(other_branch, revision_b)
765
349
revno = branch.revision_id_to_revno(revision_b)
766
except errors.NoSuchRevision:
350
except NoSuchRevision:
768
352
return RevisionInfo(branch, revno, revision_b)
770
def _as_revision_id(self, context_branch):
771
from bzrlib.branch import Branch
772
other_branch = Branch.open(self.spec)
773
last_revision = other_branch.last_revision()
774
last_revision = revision.ensure_null(last_revision)
775
context_branch.fetch(other_branch, last_revision)
776
if last_revision == revision.NULL_REVISION:
777
raise errors.NoCommits(other_branch)
780
354
SPEC_TYPES.append(RevisionSpec_branch)
783
class RevisionSpec_submit(RevisionSpec_ancestor):
784
"""Selects a common ancestor with a submit branch."""
786
help_txt = """Selects a common ancestor with the submit branch.
788
Diffing against this shows all the changes that were made in this branch,
789
and is a good predictor of what merge will do. The submit branch is
790
used by the bundle and merge directive commands. If no submit branch
791
is specified, the parent branch is used instead.
793
The common ancestor is the last revision that existed in both
794
branches. Usually this is the branch point, but it could also be
795
a revision that was merged.
799
$ bzr diff -r submit:
804
def _get_submit_location(self, branch):
805
submit_location = branch.get_submit_branch()
806
location_type = 'submit branch'
807
if submit_location is None:
808
submit_location = branch.get_parent()
809
location_type = 'parent branch'
810
if submit_location is None:
811
raise errors.NoSubmitBranch(branch)
812
trace.note('Using %s %s', location_type, submit_location)
813
return submit_location
815
def _match_on(self, branch, revs):
816
trace.mutter('matching ancestor: on: %s, %s', self.spec, branch)
817
return self._find_revision_info(branch,
818
self._get_submit_location(branch))
820
def _as_revision_id(self, context_branch):
821
return self._find_revision_id(context_branch,
822
self._get_submit_location(context_branch))
825
SPEC_TYPES.append(RevisionSpec_submit)
added
removed
bzrlib/revisionspec.py
