107
def __new__(cls, spec, foo=_marker):
108
"""Parse a revision specifier.
137
def __new__(cls, spec, _internal=False):
139
return object.__new__(cls, spec, _internal=_internal)
141
symbol_versioning.warn('Creating a RevisionSpec directly has'
142
' been deprecated in version 0.11. Use'
143
' RevisionSpec.from_string()'
145
DeprecationWarning, stacklevel=2)
146
return RevisionSpec.from_string(spec)
149
def from_string(spec):
150
"""Parse a revision spec string into a RevisionSpec object.
152
:param spec: A string specified by the user
153
:return: A RevisionSpec object that understands how to parse the
156
if not isinstance(spec, (type(None), basestring)):
157
raise TypeError('error')
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' %
160
return RevisionSpec(None, _internal=True)
162
assert isinstance(spec, basestring), \
163
"You should only supply strings not %s" % (type(spec),)
165
for spectype in SPEC_TYPES:
166
if spec.startswith(spectype.prefix):
167
trace.mutter('Returning RevisionSpec %s for %s',
168
spectype.__name__, spec)
169
return spectype(spec, _internal=True)
128
raise TypeError('Unhandled revision type %s' % spec)
130
def __init__(self, spec):
171
# RevisionSpec_revno is special cased, because it is the only
172
# one that directly handles plain integers
173
# TODO: This should not be special cased rather it should be
174
# a method invocation on spectype.canparse()
176
if _revno_regex is None:
177
_revno_regex = re.compile(r'^(?:(\d+(\.\d+)*)|-\d+)(:.*)?$')
178
if _revno_regex.match(spec) is not None:
179
return RevisionSpec_revno(spec, _internal=True)
181
raise errors.NoSuchRevisionSpec(spec)
183
def __init__(self, spec, _internal=False):
184
"""Create a RevisionSpec referring to the Null revision.
186
:param spec: The original spec supplied by the user
187
:param _internal: Used to ensure that RevisionSpec is not being
188
called directly. Only from RevisionSpec.from_string()
191
# XXX: Update this after 0.10 is released
192
symbol_versioning.warn('Creating a RevisionSpec directly has'
193
' been deprecated in version 0.11. Use'
194
' RevisionSpec.from_string()'
196
DeprecationWarning, stacklevel=2)
197
self.user_spec = spec
131
198
if self.prefix and spec.startswith(self.prefix):
132
199
spec = spec[len(self.prefix):]
135
202
def _match_on(self, branch, revs):
203
trace.mutter('Returning RevisionSpec._match_on: None')
136
204
return RevisionInfo(branch, 0, None)
138
206
def _match_on_and_check(self, branch, revs):
164
237
def __repr__(self):
165
238
# this is mostly for helping with testing
166
return '<%s %s%s>' % (self.__class__.__name__,
239
return '<%s %s>' % (self.__class__.__name__,
242
def needs_branch(self):
243
"""Whether this revision spec needs a branch.
245
Set this to False the branch argument of _match_on is not used.
249
def get_branch(self):
250
"""When the revision specifier contains a branch location, return it.
252
Otherwise, return None.
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)
187
259
class RevisionSpec_revno(RevisionSpec):
260
"""Selects a revision using a number."""
262
help_txt = """Selects a revision using a number.
264
Use an integer to specify a revision in the history of the branch.
265
Optionally a branch can be specified. The 'revno:' prefix is optional.
266
A negative number will count from the end of the branch (-1 is the
267
last revision, -2 the previous one). If the negative number is larger
268
than the branch's history, the first revision is returned.
270
revno:1 -> return the first revision
271
revno:3:/path/to/branch -> return the 3rd revision of
272
the branch '/path/to/branch'
273
revno:-1 -> The last revision in a branch.
274
-2:http://other/branch -> The second to last revision in the
276
-1000000 -> Most likely the first revision, unless
277
your history is very long.
188
279
prefix = 'revno:'
190
281
def _match_on(self, branch, revs):
191
282
"""Lookup a revision by revision number"""
193
return RevisionInfo(branch, int(self.spec))
195
return RevisionInfo(branch, None)
283
loc = self.spec.find(':')
285
revno_spec = self.spec
288
revno_spec = self.spec[:loc]
289
branch_spec = self.spec[loc+1:]
293
raise errors.InvalidRevisionSpec(self.user_spec,
294
branch, 'cannot have an empty revno and no branch')
298
revno = int(revno_spec)
301
# dotted decimal. This arguably should not be here
302
# but the from_string method is a little primitive
303
# right now - RBC 20060928
305
match_revno = tuple((int(number) for number in revno_spec.split('.')))
306
except ValueError, e:
307
raise errors.InvalidRevisionSpec(self.user_spec, branch, e)
312
# the user has override the branch to look in.
313
# we need to refresh the revision_history map and
315
from bzrlib.branch import Branch
316
branch = Branch.open(branch_spec)
317
# Need to use a new revision history
318
# because we are using a specific branch
319
revs = branch.revision_history()
324
last_rev = branch.last_revision()
325
merge_sorted_revisions = tsort.merge_sort(
326
branch.repository.get_revision_graph(last_rev),
330
return item[3] == match_revno
331
revisions = filter(match, merge_sorted_revisions)
334
if len(revisions) != 1:
335
return RevisionInfo(branch, None, None)
337
# there is no traditional 'revno' for dotted-decimal revnos.
338
# so for API compatability we return None.
339
return RevisionInfo(branch, None, revisions[0][1])
342
# if get_rev_id supported negative revnos, there would not be a
343
# need for this special case.
344
if (-revno) >= len(revs):
347
revno = len(revs) + revno + 1
349
revision_id = branch.get_rev_id(revno, revs)
350
except errors.NoSuchRevision:
351
raise errors.InvalidRevisionSpec(self.user_spec, branch)
352
return RevisionInfo(branch, revno, revision_id)
354
def needs_branch(self):
355
return self.spec.find(':') == -1
357
def get_branch(self):
358
if self.spec.find(':') == -1:
361
return self.spec[self.spec.find(':')+1:]
364
RevisionSpec_int = RevisionSpec_revno
197
366
SPEC_TYPES.append(RevisionSpec_revno)
200
369
class RevisionSpec_revid(RevisionSpec):
370
"""Selects a revision using the revision id."""
372
help_txt = """Selects a revision using the revision id.
374
Supply a specific revision id, that can be used to specify any
375
revision id in the ancestry of the branch.
376
Including merges, and pending merges.
378
revid:aaaa@bbbb-123456789 -> Select revision 'aaaa@bbbb-123456789'
201
380
prefix = 'revid:'
203
382
def _match_on(self, branch, revs):
205
return RevisionInfo(branch, revs.index(self.spec) + 1, self.spec)
207
return RevisionInfo(branch, None)
383
# self.spec comes straight from parsing the command line arguments,
384
# so we expect it to be a Unicode string. Switch it to the internal
386
revision_id = osutils.safe_revision_id(self.spec, warn=False)
387
return RevisionInfo.from_revision_id(branch, revision_id, revs)
209
389
SPEC_TYPES.append(RevisionSpec_revid)
212
392
class RevisionSpec_last(RevisionSpec):
393
"""Selects the nth revision from the end."""
395
help_txt = """Selects the nth revision from the end.
397
Supply a positive number to get the nth revision from the end.
398
This is the same as supplying negative numbers to the 'revno:' spec.
400
last:1 -> return the last revision
401
last:3 -> return the revision 2 before the end.
216
406
def _match_on(self, branch, revs):
409
raise errors.NoCommits(branch)
410
return RevisionInfo(branch, len(revs), revs[-1])
218
413
offset = int(self.spec)
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)
414
except ValueError, e:
415
raise errors.InvalidRevisionSpec(self.user_spec, branch, e)
418
raise errors.InvalidRevisionSpec(self.user_spec, branch,
419
'you must supply a positive value')
420
revno = len(revs) - offset + 1
422
revision_id = branch.get_rev_id(revno, revs)
423
except errors.NoSuchRevision:
424
raise errors.InvalidRevisionSpec(self.user_spec, branch)
425
return RevisionInfo(branch, revno, revision_id)
226
427
SPEC_TYPES.append(RevisionSpec_last)
229
430
class RevisionSpec_before(RevisionSpec):
431
"""Selects the parent of the revision specified."""
433
help_txt = """Selects the parent of the revision specified.
435
Supply any revision spec to return the parent of that revision.
436
It is an error to request the parent of the null revision (before:0).
437
This is mostly useful when inspecting revisions that are not in the
438
revision history of a branch.
441
before:1913 -> Return the parent of revno 1913 (revno 1912)
442
before:revid:aaaa@bbbb-1234567890 -> return the parent of revision
444
bzr diff -r before:revid:aaaa..revid:aaaa
445
-> Find the changes between revision 'aaaa' and its parent.
446
(what changes did 'aaaa' introduce)
231
449
prefix = 'before:'
233
451
def _match_on(self, branch, revs):
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)
452
r = RevisionSpec.from_string(self.spec)._match_on(branch, revs)
454
raise errors.InvalidRevisionSpec(self.user_spec, branch,
455
'cannot go before the null: revision')
457
# We need to use the repository history here
458
rev = branch.repository.get_revision(r.rev_id)
459
if not rev.parent_ids:
463
revision_id = rev.parent_ids[0]
465
revno = revs.index(revision_id) + 1
471
revision_id = branch.get_rev_id(revno, revs)
472
except errors.NoSuchRevision:
473
raise errors.InvalidRevisionSpec(self.user_spec,
475
return RevisionInfo(branch, revno, revision_id)
239
477
SPEC_TYPES.append(RevisionSpec_before)
242
480
class RevisionSpec_tag(RevisionSpec):
481
"""Select a revision identified by tag name"""
483
help_txt = """Selects a revision identified by a tag name.
485
Tags are stored in the branch and created by the 'tag' command.
245
490
def _match_on(self, branch, revs):
246
raise BzrError('tag: namespace registered, but not implemented.')
491
# Can raise tags not supported, NoSuchTag, etc
492
return RevisionInfo.from_revision_id(branch,
493
branch.tags.lookup_tag(self.spec),
248
496
SPEC_TYPES.append(RevisionSpec_tag)
499
class _RevListToTimestamps(object):
500
"""This takes a list of revisions, and allows you to bisect by date"""
502
__slots__ = ['revs', 'branch']
504
def __init__(self, revs, branch):
508
def __getitem__(self, index):
509
"""Get the date of the index'd item"""
510
r = self.branch.repository.get_revision(self.revs[index])
511
# TODO: Handle timezone.
512
return datetime.datetime.fromtimestamp(r.timestamp)
515
return len(self.revs)
251
518
class RevisionSpec_date(RevisionSpec):
519
"""Selects a revision on the basis of a datestamp."""
521
help_txt = """Selects a revision on the basis of a datestamp.
523
Supply a datestamp to select the first revision that matches the date.
524
Date can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
525
Matches the first entry after a given date (either at midnight or
526
at a specified time).
528
One way to display all the changes since yesterday would be:
529
bzr log -r date:yesterday..-1
532
date:yesterday -> select the first revision since yesterday
533
date:2006-08-14,17:10:14 -> select the first revision after
534
August 14th, 2006 at 5:10pm.
253
537
_date_re = re.compile(
254
538
r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
278
561
m = self._date_re.match(self.spec)
279
562
if not m or (not m.group('date') and not m.group('time')):
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
563
raise errors.InvalidRevisionSpec(self.user_spec,
564
branch, 'invalid date')
568
year = int(m.group('year'))
569
month = int(m.group('month'))
570
day = int(m.group('day'))
577
hour = int(m.group('hour'))
578
minute = int(m.group('minute'))
579
if m.group('second'):
580
second = int(m.group('second'))
584
hour, minute, second = 0,0,0
586
raise errors.InvalidRevisionSpec(self.user_spec,
587
branch, 'invalid date')
296
589
dt = datetime.datetime(year=year, month=month, day=day,
297
590
hour=hour, minute=minute, second=second)
299
for i in range(len(revs)):
300
r = branch.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)
593
rev = bisect.bisect(_RevListToTimestamps(revs, branch), dt)
597
return RevisionInfo(branch, None)
599
return RevisionInfo(branch, rev + 1)
307
601
SPEC_TYPES.append(RevisionSpec_date)
310
604
class RevisionSpec_ancestor(RevisionSpec):
605
"""Selects a common ancestor with a second branch."""
607
help_txt = """Selects a common ancestor with a second branch.
609
Supply the path to a branch to select the common ancestor.
611
The common ancestor is the last revision that existed in both
612
branches. Usually this is the branch point, but it could also be
613
a revision that was merged.
615
This is frequently used with 'diff' to return all of the changes
616
that your branch introduces, while excluding the changes that you
617
have not merged from the remote branch.
620
ancestor:/path/to/branch
621
$ bzr diff -r ancestor:../../mainline/branch
311
623
prefix = 'ancestor:'
313
625
def _match_on(self, branch, revs):
314
from branch import Branch
315
from revision import common_ancestor, MultipleRevisionSources
316
other_branch = Branch.open_containing(self.spec)[0]
626
trace.mutter('matching ancestor: on: %s, %s', self.spec, branch)
627
return self._find_revision_info(branch, self.spec)
630
def _find_revision_info(branch, other_location):
631
from bzrlib.branch import Branch
633
other_branch = Branch.open(other_location)
317
634
revision_a = branch.last_revision()
318
635
revision_b = other_branch.last_revision()
319
636
for r, b in ((revision_a, branch), (revision_b, other_branch)):
322
revision_source = MultipleRevisionSources(branch, other_branch)
323
rev_id = common_ancestor(revision_a, revision_b, revision_source)
637
if r in (None, revision.NULL_REVISION):
638
raise errors.NoCommits(b)
639
revision_source = revision.MultipleRevisionSources(
640
branch.repository, other_branch.repository)
641
rev_id = revision.common_ancestor(revision_a, revision_b,
325
644
revno = branch.revision_id_to_revno(rev_id)
326
except NoSuchRevision:
645
except errors.NoSuchRevision:
328
647
return RevisionInfo(branch, revno, rev_id)
330
650
SPEC_TYPES.append(RevisionSpec_ancestor)
332
653
class RevisionSpec_branch(RevisionSpec):
333
"""A branch: revision specifier.
335
This takes the path to a branch and returns its tip revision id.
654
"""Selects the last revision of a specified branch."""
656
help_txt = """Selects the last revision of a specified branch.
658
Supply the path to a branch to select its last revision.
661
branch:/path/to/branch
337
663
prefix = 'branch:'
339
665
def _match_on(self, branch, revs):
340
from branch import Branch
341
from fetch import greedy_fetch
342
other_branch = Branch.open_containing(self.spec)[0]
666
from bzrlib.branch import Branch
667
other_branch = Branch.open(self.spec)
343
668
revision_b = other_branch.last_revision()
344
if revision_b is None:
345
raise NoCommits(other_branch)
669
if revision_b in (None, revision.NULL_REVISION):
670
raise errors.NoCommits(other_branch)
346
671
# pull in the remote revisions so we can diff
347
greedy_fetch(branch, other_branch, revision=revision_b)
672
branch.fetch(other_branch, revision_b)
349
674
revno = branch.revision_id_to_revno(revision_b)
350
except NoSuchRevision:
675
except errors.NoSuchRevision:
352
677
return RevisionInfo(branch, revno, revision_b)
354
679
SPEC_TYPES.append(RevisionSpec_branch)
682
class RevisionSpec_submit(RevisionSpec_ancestor):
683
"""Selects a common ancestor with a submit branch."""
685
help_txt = """Selects a common ancestor with the submit branch.
687
Diffing against this shows all the changes that were made in this branch,
688
and is a good predictor of what merge will do. The submit branch is
689
used by the bundle and merge directive comands. If no submit branch
690
is specified, the parent branch is used instead.
692
The common ancestor is the last revision that existed in both
693
branches. Usually this is the branch point, but it could also be
694
a revision that was merged.
697
$ bzr diff -r submit:
702
def _match_on(self, branch, revs):
703
trace.mutter('matching ancestor: on: %s, %s', self.spec, branch)
704
submit_location = branch.get_submit_branch()
705
location_type = 'submit branch'
706
if submit_location is None:
707
submit_location = branch.get_parent()
708
location_type = 'parent branch'
709
if submit_location is None:
710
raise errors.NoSubmitBranch(branch)
711
trace.note('Using %s %s', location_type, submit_location)
712
return self._find_revision_info(branch, submit_location)
715
SPEC_TYPES.append(RevisionSpec_submit)
added
removed
bzrlib/revisionspec.py
