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
107
def __new__(cls, spec, foo=_marker):
108
"""Parse a revision specifier.
156
if not isinstance(spec, (type(None), basestring)):
157
raise TypeError('error')
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)
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' %
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
128
raise TypeError('Unhandled revision type %s' % spec)
130
def __init__(self, spec):
198
131
if self.prefix and spec.startswith(self.prefix):
199
132
spec = spec[len(self.prefix):]
202
135
def _match_on(self, branch, revs):
203
trace.mutter('Returning RevisionSpec._match_on: None')
204
136
return RevisionInfo(branch, 0, None)
206
138
def _match_on_and_check(self, branch, revs):
237
164
def __repr__(self):
238
165
# this is mostly for helping with testing
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.
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)
259
187
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.
279
188
prefix = 'revno:'
281
190
def _match_on(self, branch, revs):
282
191
"""Lookup a revision by revision number"""
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
revision_id_to_revno = branch.get_revision_id_to_revno_map()
325
revisions = [revision_id for revision_id, revno
326
in revision_id_to_revno.iteritems()
327
if revno == match_revno]
330
if len(revisions) != 1:
331
return RevisionInfo(branch, None, None)
333
# there is no traditional 'revno' for dotted-decimal revnos.
334
# so for API compatability we return None.
335
return RevisionInfo(branch, None, revisions[0])
338
# if get_rev_id supported negative revnos, there would not be a
339
# need for this special case.
340
if (-revno) >= len(revs):
343
revno = len(revs) + revno + 1
345
revision_id = branch.get_rev_id(revno, revs)
346
except errors.NoSuchRevision:
347
raise errors.InvalidRevisionSpec(self.user_spec, branch)
348
return RevisionInfo(branch, revno, revision_id)
350
def needs_branch(self):
351
return self.spec.find(':') == -1
353
def get_branch(self):
354
if self.spec.find(':') == -1:
357
return self.spec[self.spec.find(':')+1:]
360
RevisionSpec_int = RevisionSpec_revno
193
return RevisionInfo(branch, int(self.spec))
195
return RevisionInfo(branch, None)
362
197
SPEC_TYPES.append(RevisionSpec_revno)
365
200
class RevisionSpec_revid(RevisionSpec):
366
"""Selects a revision using the revision id."""
368
help_txt = """Selects a revision using the revision id.
370
Supply a specific revision id, that can be used to specify any
371
revision id in the ancestry of the branch.
372
Including merges, and pending merges.
374
revid:aaaa@bbbb-123456789 -> Select revision 'aaaa@bbbb-123456789'
376
201
prefix = 'revid:'
378
203
def _match_on(self, branch, revs):
379
# self.spec comes straight from parsing the command line arguments,
380
# so we expect it to be a Unicode string. Switch it to the internal
382
revision_id = osutils.safe_revision_id(self.spec, warn=False)
383
return RevisionInfo.from_revision_id(branch, revision_id, revs)
205
return RevisionInfo(branch, revs.index(self.spec) + 1, self.spec)
207
return RevisionInfo(branch, None)
385
209
SPEC_TYPES.append(RevisionSpec_revid)
388
212
class RevisionSpec_last(RevisionSpec):
389
"""Selects the nth revision from the end."""
391
help_txt = """Selects the nth revision from the end.
393
Supply a positive number to get the nth revision from the end.
394
This is the same as supplying negative numbers to the 'revno:' spec.
396
last:1 -> return the last revision
397
last:3 -> return the revision 2 before the end.
402
216
def _match_on(self, branch, revs):
405
raise errors.NoCommits(branch)
406
return RevisionInfo(branch, len(revs), revs[-1])
409
218
offset = int(self.spec)
410
except ValueError, e:
411
raise errors.InvalidRevisionSpec(self.user_spec, branch, e)
414
raise errors.InvalidRevisionSpec(self.user_spec, branch,
415
'you must supply a positive value')
416
revno = len(revs) - offset + 1
418
revision_id = branch.get_rev_id(revno, revs)
419
except errors.NoSuchRevision:
420
raise errors.InvalidRevisionSpec(self.user_spec, branch)
421
return RevisionInfo(branch, revno, revision_id)
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)
423
226
SPEC_TYPES.append(RevisionSpec_last)
426
229
class RevisionSpec_before(RevisionSpec):
427
"""Selects the parent of the revision specified."""
429
help_txt = """Selects the parent of the revision specified.
431
Supply any revision spec to return the parent of that revision.
432
It is an error to request the parent of the null revision (before:0).
433
This is mostly useful when inspecting revisions that are not in the
434
revision history of a branch.
437
before:1913 -> Return the parent of revno 1913 (revno 1912)
438
before:revid:aaaa@bbbb-1234567890 -> return the parent of revision
440
bzr diff -r before:revid:aaaa..revid:aaaa
441
-> Find the changes between revision 'aaaa' and its parent.
442
(what changes did 'aaaa' introduce)
445
231
prefix = 'before:'
447
233
def _match_on(self, branch, revs):
448
r = RevisionSpec.from_string(self.spec)._match_on(branch, revs)
450
raise errors.InvalidRevisionSpec(self.user_spec, branch,
451
'cannot go before the null: revision')
453
# We need to use the repository history here
454
rev = branch.repository.get_revision(r.rev_id)
455
if not rev.parent_ids:
459
revision_id = rev.parent_ids[0]
461
revno = revs.index(revision_id) + 1
467
revision_id = branch.get_rev_id(revno, revs)
468
except errors.NoSuchRevision:
469
raise errors.InvalidRevisionSpec(self.user_spec,
471
return RevisionInfo(branch, revno, revision_id)
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)
473
239
SPEC_TYPES.append(RevisionSpec_before)
476
242
class RevisionSpec_tag(RevisionSpec):
477
"""Select a revision identified by tag name"""
479
help_txt = """Selects a revision identified by a tag name.
481
Tags are stored in the branch and created by the 'tag' command.
486
245
def _match_on(self, branch, revs):
487
# Can raise tags not supported, NoSuchTag, etc
488
return RevisionInfo.from_revision_id(branch,
489
branch.tags.lookup_tag(self.spec),
246
raise BzrError('tag: namespace registered, but not implemented.')
492
248
SPEC_TYPES.append(RevisionSpec_tag)
495
class _RevListToTimestamps(object):
496
"""This takes a list of revisions, and allows you to bisect by date"""
498
__slots__ = ['revs', 'branch']
500
def __init__(self, revs, branch):
504
def __getitem__(self, index):
505
"""Get the date of the index'd item"""
506
r = self.branch.repository.get_revision(self.revs[index])
507
# TODO: Handle timezone.
508
return datetime.datetime.fromtimestamp(r.timestamp)
511
return len(self.revs)
514
251
class RevisionSpec_date(RevisionSpec):
515
"""Selects a revision on the basis of a datestamp."""
517
help_txt = """Selects a revision on the basis of a datestamp.
519
Supply a datestamp to select the first revision that matches the date.
520
Date can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
521
Matches the first entry after a given date (either at midnight or
522
at a specified time).
524
One way to display all the changes since yesterday would be:
525
bzr log -r date:yesterday..-1
528
date:yesterday -> select the first revision since yesterday
529
date:2006-08-14,17:10:14 -> select the first revision after
530
August 14th, 2006 at 5:10pm.
533
253
_date_re = re.compile(
534
254
r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
557
278
m = self._date_re.match(self.spec)
558
279
if not m or (not m.group('date') and not m.group('time')):
559
raise errors.InvalidRevisionSpec(self.user_spec,
560
branch, 'invalid date')
564
year = int(m.group('year'))
565
month = int(m.group('month'))
566
day = int(m.group('day'))
573
hour = int(m.group('hour'))
574
minute = int(m.group('minute'))
575
if m.group('second'):
576
second = int(m.group('second'))
580
hour, minute, second = 0,0,0
582
raise errors.InvalidRevisionSpec(self.user_spec,
583
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
585
296
dt = datetime.datetime(year=year, month=month, day=day,
586
297
hour=hour, minute=minute, second=second)
589
rev = bisect.bisect(_RevListToTimestamps(revs, branch), dt)
593
return RevisionInfo(branch, None)
595
return RevisionInfo(branch, rev + 1)
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)
597
307
SPEC_TYPES.append(RevisionSpec_date)
600
310
class RevisionSpec_ancestor(RevisionSpec):
601
"""Selects a common ancestor with a second branch."""
603
help_txt = """Selects a common ancestor with a second branch.
605
Supply the path to a branch to select the common ancestor.
607
The common ancestor is the last revision that existed in both
608
branches. Usually this is the branch point, but it could also be
609
a revision that was merged.
611
This is frequently used with 'diff' to return all of the changes
612
that your branch introduces, while excluding the changes that you
613
have not merged from the remote branch.
616
ancestor:/path/to/branch
617
$ bzr diff -r ancestor:../../mainline/branch
619
311
prefix = 'ancestor:'
621
313
def _match_on(self, branch, revs):
622
trace.mutter('matching ancestor: on: %s, %s', self.spec, branch)
623
return self._find_revision_info(branch, self.spec)
626
def _find_revision_info(branch, other_location):
627
from bzrlib.branch import Branch
629
other_branch = Branch.open(other_location)
314
from branch import Branch
315
from revision import common_ancestor, MultipleRevisionSources
316
other_branch = Branch.open_containing(self.spec)[0]
630
317
revision_a = branch.last_revision()
631
318
revision_b = other_branch.last_revision()
632
319
for r, b in ((revision_a, branch), (revision_b, other_branch)):
633
if r in (None, revision.NULL_REVISION):
634
raise errors.NoCommits(b)
635
revision_source = revision.MultipleRevisionSources(
636
branch.repository, other_branch.repository)
637
rev_id = revision.common_ancestor(revision_a, revision_b,
322
revision_source = MultipleRevisionSources(branch, other_branch)
323
rev_id = common_ancestor(revision_a, revision_b, revision_source)
640
325
revno = branch.revision_id_to_revno(rev_id)
641
except errors.NoSuchRevision:
326
except NoSuchRevision:
643
328
return RevisionInfo(branch, revno, rev_id)
646
330
SPEC_TYPES.append(RevisionSpec_ancestor)
649
332
class RevisionSpec_branch(RevisionSpec):
650
"""Selects the last revision of a specified branch."""
652
help_txt = """Selects the last revision of a specified branch.
654
Supply the path to a branch to select its last revision.
657
branch:/path/to/branch
333
"""A branch: revision specifier.
335
This takes the path to a branch and returns its tip revision id.
659
337
prefix = 'branch:'
661
339
def _match_on(self, branch, revs):
662
from bzrlib.branch import Branch
663
other_branch = Branch.open(self.spec)
340
from branch import Branch
341
from fetch import greedy_fetch
342
other_branch = Branch.open_containing(self.spec)[0]
664
343
revision_b = other_branch.last_revision()
665
if revision_b in (None, revision.NULL_REVISION):
666
raise errors.NoCommits(other_branch)
344
if revision_b is None:
345
raise NoCommits(other_branch)
667
346
# pull in the remote revisions so we can diff
668
branch.fetch(other_branch, revision_b)
347
greedy_fetch(branch, other_branch, revision=revision_b)
670
349
revno = branch.revision_id_to_revno(revision_b)
671
except errors.NoSuchRevision:
350
except NoSuchRevision:
673
352
return RevisionInfo(branch, revno, revision_b)
675
354
SPEC_TYPES.append(RevisionSpec_branch)
678
class RevisionSpec_submit(RevisionSpec_ancestor):
679
"""Selects a common ancestor with a submit branch."""
681
help_txt = """Selects a common ancestor with the submit branch.
683
Diffing against this shows all the changes that were made in this branch,
684
and is a good predictor of what merge will do. The submit branch is
685
used by the bundle and merge directive comands. If no submit branch
686
is specified, the parent branch is used instead.
688
The common ancestor is the last revision that existed in both
689
branches. Usually this is the branch point, but it could also be
690
a revision that was merged.
693
$ bzr diff -r submit:
698
def _match_on(self, branch, revs):
699
trace.mutter('matching ancestor: on: %s, %s', self.spec, branch)
700
submit_location = branch.get_submit_branch()
701
location_type = 'submit branch'
702
if submit_location is None:
703
submit_location = branch.get_parent()
704
location_type = 'parent branch'
705
if submit_location is None:
706
raise errors.NoSubmitBranch(branch)
707
trace.note('Using %s %s', location_type, submit_location)
708
return self._find_revision_info(branch, submit_location)
711
SPEC_TYPES.append(RevisionSpec_submit)
added
removed
bzrlib/revisionspec.py
