13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
from __future__ import absolute_import
20
from bzrlib.lazy_import import lazy_import
21
lazy_import(globals(), """
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25
22
from bzrlib import (
26
branch as _mod_branch,
32
from bzrlib.i18n import gettext
43
35
class RevisionInfo(object):
44
36
"""The results of applying a revision specification to a branch."""
57
49
or treat the result as a tuple.
60
def __init__(self, branch, revno=None, rev_id=None):
52
def __init__(self, branch, revno, rev_id=_marker):
61
53
self.branch = branch
62
self._has_revno = (revno is not None)
65
if self.rev_id is None and self._revno is not None:
66
56
# allow caller to be lazy
67
self.rev_id = branch.get_rev_id(self._revno)
71
if not self._has_revno and self.rev_id is not None:
73
self._revno = self.branch.revision_id_to_revno(self.rev_id)
74
except errors.NoSuchRevision:
76
self._has_revno = True
57
if self.revno is None:
60
self.rev_id = branch.get_rev_id(self.revno)
79
64
def __nonzero__(self):
65
# first the easy ones...
80
66
if self.rev_id is None:
68
if self.revno is not None:
82
70
# TODO: otherwise, it should depend on how I was built -
83
71
# if it's in_history(branch), then check revision_history(),
84
72
# if it's in_store(branch), do the check below
107
95
self.revno, self.rev_id, self.branch)
110
def from_revision_id(branch, revision_id, revs=symbol_versioning.DEPRECATED_PARAMETER):
98
def from_revision_id(branch, revision_id, revs):
111
99
"""Construct a RevisionInfo given just the id.
113
101
Use this if you don't know or care what the revno is.
115
if symbol_versioning.deprecated_passed(revs):
116
symbol_versioning.warn(
117
'RevisionInfo.from_revision_id(revs) was deprecated in 2.5.',
120
return RevisionInfo(branch, revno=None, rev_id=revision_id)
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
123
118
class RevisionSpec(object):
126
121
help_txt = """A parsed revision specification.
128
A revision specification is a string, which may be unambiguous about
129
what it represents by giving a prefix like 'date:' or 'revid:' etc,
130
or it may have no prefix, in which case it's tried against several
131
specifier types in sequence to determine what the user meant.
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.
133
128
Revision specs are an UI element, and they have been moved out
134
129
of the branch class to leave "back-end" classes unaware of such
143
# wants_revision_history has been deprecated in 2.5.
144
wants_revision_history = False
145
dwim_catchable_exceptions = (errors.InvalidRevisionSpec,)
146
"""Exceptions that RevisionSpec_dwim._match_on will catch.
148
If the revspec is part of ``dwim_revspecs``, it may be tried with an
149
invalid revspec and raises some exception. The exceptions mentioned here
150
will not be reported to the user but simply ignored without stopping the
139
def __new__(cls, spec, _internal=False):
141
return object.__new__(cls, spec, _internal=_internal)
143
symbol_versioning.warn('Creating a RevisionSpec directly has'
144
' been deprecated in version 0.11. Use'
145
' RevisionSpec.from_string()'
147
DeprecationWarning, stacklevel=2)
148
return RevisionSpec.from_string(spec)
155
151
def from_string(spec):
166
162
return RevisionSpec(None, _internal=True)
167
match = revspec_registry.get_prefix(spec)
168
if match is not None:
169
spectype, specsuffix = match
170
trace.mutter('Returning RevisionSpec %s for %s',
171
spectype.__name__, spec)
172
return spectype(spec, _internal=True)
164
assert isinstance(spec, basestring), \
165
"You should only supply strings not %s" % (type(spec),)
167
for spectype in SPEC_TYPES:
168
if spec.startswith(spectype.prefix):
169
trace.mutter('Returning RevisionSpec %s for %s',
170
spectype.__name__, spec)
171
return spectype(spec, _internal=True)
174
# Otherwise treat it as a DWIM, build the RevisionSpec object and
175
# wait for _match_on to be called.
176
return RevisionSpec_dwim(spec, _internal=True)
173
# RevisionSpec_revno is special cased, because it is the only
174
# one that directly handles plain integers
175
# TODO: This should not be special cased rather it should be
176
# a method invocation on spectype.canparse()
178
if _revno_regex is None:
179
_revno_regex = re.compile(r'^(?:(\d+(\.\d+)*)|-\d+)(:.*)?$')
180
if _revno_regex.match(spec) is not None:
181
return RevisionSpec_revno(spec, _internal=True)
183
raise errors.NoSuchRevisionSpec(spec)
178
185
def __init__(self, spec, _internal=False):
179
186
"""Create a RevisionSpec referring to the Null revision.
259
253
return self.in_history(context_branch).rev_id
261
def as_tree(self, context_branch):
262
"""Return the tree object for this revisions spec.
264
Some revision specs require a context_branch to be able to determine
265
the revision id and access the repository. Not all specs will make
268
return self._as_tree(context_branch)
270
def _as_tree(self, context_branch):
271
"""Implementation of as_tree().
273
Classes should override this function to provide appropriate
274
functionality. The default is to just call '.as_revision_id()'
275
and get the revision tree from context_branch's repository.
277
revision_id = self.as_revision_id(context_branch)
278
return context_branch.repository.revision_tree(revision_id)
280
255
def __repr__(self):
281
256
# this is mostly for helping with testing
282
257
return '<%s %s>' % (self.__class__.__name__,
285
260
def needs_branch(self):
286
261
"""Whether this revision spec needs a branch.
302
class RevisionSpec_dwim(RevisionSpec):
303
"""Provides a DWIMish revision specifier lookup.
305
Note that this does not go in the revspec_registry because by definition
306
there is no prefix to identify it. It's solely called from
307
RevisionSpec.from_string() because the DWIMification happen when _match_on
308
is called so the string describing the revision is kept here until needed.
313
_revno_regex = lazy_regex.lazy_compile(r'^(?:(\d+(\.\d+)*)|-\d+)(:.*)?$')
315
# The revspecs to try
316
_possible_revspecs = []
318
def _try_spectype(self, rstype, branch):
319
rs = rstype(self.spec, _internal=True)
320
# Hit in_history to find out if it exists, or we need to try the
322
return rs.in_history(branch)
324
def _match_on(self, branch, revs):
325
"""Run the lookup and see what we can get."""
327
# First, see if it's a revno
328
if self._revno_regex.match(self.spec) is not None:
330
return self._try_spectype(RevisionSpec_revno, branch)
331
except RevisionSpec_revno.dwim_catchable_exceptions:
334
# Next see what has been registered
335
for objgetter in self._possible_revspecs:
336
rs_class = objgetter.get_obj()
338
return self._try_spectype(rs_class, branch)
339
except rs_class.dwim_catchable_exceptions:
342
# Try the old (deprecated) dwim list:
343
for rs_class in dwim_revspecs:
345
return self._try_spectype(rs_class, branch)
346
except rs_class.dwim_catchable_exceptions:
349
# Well, I dunno what it is. Note that we don't try to keep track of the
350
# first of last exception raised during the DWIM tries as none seems
352
raise errors.InvalidRevisionSpec(self.spec, branch)
355
def append_possible_revspec(cls, revspec):
356
"""Append a possible DWIM revspec.
358
:param revspec: Revision spec to try.
360
cls._possible_revspecs.append(registry._ObjectGetter(revspec))
363
def append_possible_lazy_revspec(cls, module_name, member_name):
364
"""Append a possible lazily loaded DWIM revspec.
366
:param module_name: Name of the module with the revspec
367
:param member_name: Name of the revspec within the module
369
cls._possible_revspecs.append(
370
registry._LazyObjectGetter(module_name, member_name))
373
277
class RevisionSpec_revno(RevisionSpec):
374
278
"""Selects a revision using a number."""
376
280
help_txt = """Selects a revision using a number.
378
282
Use an integer to specify a revision in the history of the branch.
379
Optionally a branch can be specified. A negative number will count
380
from the end of the branch (-1 is the last revision, -2 the previous
381
one). If the negative number is larger than the branch's history, the
382
first revision is returned.
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.
385
revno:1 -> return the first revision of this branch
289
revno:1 -> return the first revision
386
290
revno:3:/path/to/branch -> return the 3rd revision of
387
291
the branch '/path/to/branch'
388
292
revno:-1 -> The last revision in a branch.
396
300
def _match_on(self, branch, revs):
397
301
"""Lookup a revision by revision number"""
398
branch, revno, revision_id = self._lookup(branch)
302
branch, revno, revision_id = self._lookup(branch, revs)
399
303
return RevisionInfo(branch, revno, revision_id)
401
def _lookup(self, branch):
305
def _lookup(self, branch, revs_or_none):
402
306
loc = self.spec.find(':')
404
308
revno_spec = self.spec
431
# the user has overriden the branch to look in.
432
branch = _mod_branch.Branch.open(branch_spec)
335
# the user has override the branch to look in.
336
# we need to refresh the revision_history map and
338
from bzrlib.branch import Branch
339
branch = Branch.open(branch_spec)
436
revision_id = branch.dotted_revno_to_revision_id(match_revno,
438
except errors.NoSuchRevision:
439
raise errors.InvalidRevisionSpec(self.user_spec, branch)
345
revision_id_to_revno = branch.get_revision_id_to_revno_map()
346
revisions = [revision_id for revision_id, revno
347
in revision_id_to_revno.iteritems()
348
if revno == match_revno]
351
if len(revisions) != 1:
352
return branch, None, None
441
354
# there is no traditional 'revno' for dotted-decimal revnos.
442
# so for API compatibility we return None.
443
return branch, None, revision_id
355
# so for API compatability we return None.
356
return branch, None, revisions[0]
445
358
last_revno, last_revision_id = branch.last_revision_info()
452
365
revno = last_revno + revno + 1
454
revision_id = branch.get_rev_id(revno)
367
revision_id = branch.get_rev_id(revno, revs_or_none)
455
368
except errors.NoSuchRevision:
456
369
raise errors.InvalidRevisionSpec(self.user_spec, branch)
457
370
return branch, revno, revision_id
459
372
def _as_revision_id(self, context_branch):
460
373
# We would have the revno here, but we don't really care
461
branch, revno, revision_id = self._lookup(context_branch)
374
branch, revno, revision_id = self._lookup(context_branch, None)
462
375
return revision_id
464
377
def needs_branch(self):
471
384
return self.spec[self.spec.find(':')+1:]
474
387
RevisionSpec_int = RevisionSpec_revno
477
class RevisionIDSpec(RevisionSpec):
479
def _match_on(self, branch, revs):
480
revision_id = self.as_revision_id(branch)
481
return RevisionInfo.from_revision_id(branch, revision_id)
484
class RevisionSpec_revid(RevisionIDSpec):
389
SPEC_TYPES.append(RevisionSpec_revno)
392
class RevisionSpec_revid(RevisionSpec):
485
393
"""Selects a revision using the revision id."""
487
395
help_txt = """Selects a revision using the revision id.
489
397
Supply a specific revision id, that can be used to specify any
490
revision id in the ancestry of the branch.
398
revision id in the ancestry of the branch.
491
399
Including merges, and pending merges.
497
405
prefix = 'revid:'
499
def _as_revision_id(self, context_branch):
407
def _match_on(self, branch, revs):
500
408
# self.spec comes straight from parsing the command line arguments,
501
409
# so we expect it to be a Unicode string. Switch it to the internal
502
410
# representation.
411
revision_id = osutils.safe_revision_id(self.spec, warn=False)
412
return RevisionInfo.from_revision_id(branch, revision_id, revs)
414
def _as_revision_id(self, context_branch):
503
415
return osutils.safe_revision_id(self.spec, warn=False)
417
SPEC_TYPES.append(RevisionSpec_revid)
507
420
class RevisionSpec_last(RevisionSpec):
522
435
def _match_on(self, branch, revs):
523
revno, revision_id = self._revno_and_revision_id(branch)
436
revno, revision_id = self._revno_and_revision_id(branch, revs)
524
437
return RevisionInfo(branch, revno, revision_id)
526
def _revno_and_revision_id(self, context_branch):
439
def _revno_and_revision_id(self, context_branch, revs_or_none):
527
440
last_revno, last_revision_id = context_branch.last_revision_info()
529
442
if self.spec == '':
561
475
help_txt = """Selects the parent of the revision specified.
563
Supply any revision spec to return the parent of that revision. This is
564
mostly useful when inspecting revisions that are not in the revision history
477
Supply any revision spec to return the parent of that revision.
567
478
It is an error to request the parent of the null revision (before:0).
479
This is mostly useful when inspecting revisions that are not in the
480
revision history of a branch.
571
484
before:1913 -> Return the parent of revno 1913 (revno 1912)
572
485
before:revid:aaaa@bbbb-1234567890 -> return the parent of revision
573
486
aaaa@bbbb-1234567890
574
bzr diff -r before:1913..1913
575
-> Find the changes between revision 1913 and its parent (1912).
576
(What changes did revision 1913 introduce).
577
This is equivalent to: bzr diff -c 1913
487
bzr diff -r before:revid:aaaa..revid:aaaa
488
-> Find the changes between revision 'aaaa' and its parent.
489
(what changes did 'aaaa' introduce)
580
492
prefix = 'before:'
582
494
def _match_on(self, branch, revs):
583
495
r = RevisionSpec.from_string(self.spec)._match_on(branch, revs)
602
518
return RevisionInfo(branch, revno, revision_id)
604
520
def _as_revision_id(self, context_branch):
605
base_revision_id = RevisionSpec.from_string(self.spec)._as_revision_id(context_branch)
521
base_revspec = RevisionSpec.from_string(self.spec)
522
base_revision_id = base_revspec.as_revision_id(context_branch)
606
523
if base_revision_id == revision.NULL_REVISION:
607
raise errors.InvalidRevisionSpec(self.user_spec, context_branch,
524
raise errors.InvalidRevisionSpec(self.user_spec, branch,
608
525
'cannot go before the null: revision')
609
526
context_repo = context_branch.repository
610
527
context_repo.lock_read()
636
dwim_catchable_exceptions = (errors.NoSuchTag, errors.TagsNotSupported)
638
555
def _match_on(self, branch, revs):
639
556
# Can raise tags not supported, NoSuchTag, etc
640
557
return RevisionInfo.from_revision_id(branch,
641
branch.tags.lookup_tag(self.spec))
558
branch.tags.lookup_tag(self.spec),
643
561
def _as_revision_id(self, context_branch):
644
562
return context_branch.tags.lookup_tag(self.spec)
564
SPEC_TYPES.append(RevisionSpec_tag)
648
567
class _RevListToTimestamps(object):
649
568
"""This takes a list of revisions, and allows you to bisect by date"""
651
__slots__ = ['branch']
570
__slots__ = ['revs', 'branch']
653
def __init__(self, branch):
572
def __init__(self, revs, branch):
654
574
self.branch = branch
656
576
def __getitem__(self, index):
657
577
"""Get the date of the index'd item"""
658
r = self.branch.repository.get_revision(self.branch.get_rev_id(index))
578
r = self.branch.repository.get_revision(self.revs[index])
659
579
# TODO: Handle timezone.
660
580
return datetime.datetime.fromtimestamp(r.timestamp)
662
582
def __len__(self):
663
return self.branch.revno()
583
return len(self.revs)
666
586
class RevisionSpec_date(RevisionSpec):
740
660
hour=hour, minute=minute, second=second)
741
661
branch.lock_read()
743
rev = bisect.bisect(_RevListToTimestamps(branch), dt, 1)
663
rev = bisect.bisect(_RevListToTimestamps(revs, branch), dt)
746
if rev == branch.revno():
747
667
raise errors.InvalidRevisionSpec(self.user_spec, branch)
748
return RevisionInfo(branch, rev)
669
return RevisionInfo(branch, rev + 1)
671
SPEC_TYPES.append(RevisionSpec_date)
752
674
class RevisionSpec_ancestor(RevisionSpec):
834
758
revision_b = other_branch.last_revision()
835
759
if revision_b in (None, revision.NULL_REVISION):
836
760
raise errors.NoCommits(other_branch)
838
branch = other_branch
841
# pull in the remote revisions so we can diff
842
branch.fetch(other_branch, revision_b)
843
except errors.ReadOnlyError:
844
branch = other_branch
845
return RevisionInfo(branch, None, revision_b)
761
# pull in the remote revisions so we can diff
762
branch.fetch(other_branch, revision_b)
764
revno = branch.revision_id_to_revno(revision_b)
765
except errors.NoSuchRevision:
767
return RevisionInfo(branch, revno, revision_b)
847
769
def _as_revision_id(self, context_branch):
848
770
from bzrlib.branch import Branch
849
771
other_branch = Branch.open(self.spec)
850
772
last_revision = other_branch.last_revision()
851
773
last_revision = revision.ensure_null(last_revision)
852
context_branch.fetch(other_branch, last_revision)
853
774
if last_revision == revision.NULL_REVISION:
854
775
raise errors.NoCommits(other_branch)
855
776
return last_revision
857
def _as_tree(self, context_branch):
858
from bzrlib.branch import Branch
859
other_branch = Branch.open(self.spec)
860
last_revision = other_branch.last_revision()
861
last_revision = revision.ensure_null(last_revision)
862
if last_revision == revision.NULL_REVISION:
863
raise errors.NoCommits(other_branch)
864
return other_branch.repository.revision_tree(last_revision)
866
def needs_branch(self):
869
def get_branch(self):
778
SPEC_TYPES.append(RevisionSpec_branch)
874
781
class RevisionSpec_submit(RevisionSpec_ancestor):
914
820
self._get_submit_location(context_branch))
917
class RevisionSpec_annotate(RevisionIDSpec):
921
help_txt = """Select the revision that last modified the specified line.
923
Select the revision that last modified the specified line. Line is
924
specified as path:number. Path is a relative path to the file. Numbers
925
start at 1, and are relative to the current version, not the last-
926
committed version of the file.
929
def _raise_invalid(self, numstring, context_branch):
930
raise errors.InvalidRevisionSpec(self.user_spec, context_branch,
931
'No such line: %s' % numstring)
933
def _as_revision_id(self, context_branch):
934
path, numstring = self.spec.rsplit(':', 1)
936
index = int(numstring) - 1
938
self._raise_invalid(numstring, context_branch)
939
tree, file_path = workingtree.WorkingTree.open_containing(path)
942
file_id = tree.path2id(file_path)
944
raise errors.InvalidRevisionSpec(self.user_spec,
945
context_branch, "File '%s' is not versioned." %
947
revision_ids = [r for (r, l) in tree.annotate_iter(file_id)]
951
revision_id = revision_ids[index]
953
self._raise_invalid(numstring, context_branch)
954
if revision_id == revision.CURRENT_REVISION:
955
raise errors.InvalidRevisionSpec(self.user_spec, context_branch,
956
'Line %s has not been committed.' % numstring)
960
class RevisionSpec_mainline(RevisionIDSpec):
962
help_txt = """Select mainline revision that merged the specified revision.
964
Select the revision that merged the specified revision into mainline.
969
def _as_revision_id(self, context_branch):
970
revspec = RevisionSpec.from_string(self.spec)
971
if revspec.get_branch() is None:
972
spec_branch = context_branch
974
spec_branch = _mod_branch.Branch.open(revspec.get_branch())
975
revision_id = revspec.as_revision_id(spec_branch)
976
graph = context_branch.repository.get_graph()
977
result = graph.find_lefthand_merger(revision_id,
978
context_branch.last_revision())
980
raise errors.InvalidRevisionSpec(self.user_spec, context_branch)
984
# The order in which we want to DWIM a revision spec without any prefix.
985
# revno is always tried first and isn't listed here, this is used by
986
# RevisionSpec_dwim._match_on
987
dwim_revspecs = symbol_versioning.deprecated_list(
988
symbol_versioning.deprecated_in((2, 4, 0)), "dwim_revspecs", [])
990
RevisionSpec_dwim.append_possible_revspec(RevisionSpec_tag)
991
RevisionSpec_dwim.append_possible_revspec(RevisionSpec_revid)
992
RevisionSpec_dwim.append_possible_revspec(RevisionSpec_date)
993
RevisionSpec_dwim.append_possible_revspec(RevisionSpec_branch)
995
revspec_registry = registry.Registry()
996
def _register_revspec(revspec):
997
revspec_registry.register(revspec.prefix, revspec)
999
_register_revspec(RevisionSpec_revno)
1000
_register_revspec(RevisionSpec_revid)
1001
_register_revspec(RevisionSpec_last)
1002
_register_revspec(RevisionSpec_before)
1003
_register_revspec(RevisionSpec_tag)
1004
_register_revspec(RevisionSpec_date)
1005
_register_revspec(RevisionSpec_ancestor)
1006
_register_revspec(RevisionSpec_branch)
1007
_register_revspec(RevisionSpec_submit)
1008
_register_revspec(RevisionSpec_annotate)
1009
_register_revspec(RevisionSpec_mainline)
823
SPEC_TYPES.append(RevisionSpec_submit)
added
removed
bzrlib/revisionspec.py
