← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/revisionspec.py

  • Committer: Andrew Bennetts
  • Date: 2009-10-13 05:20:50 UTC
  • mfrom: (4634.52.16 2.0)
  • mto: This revision was merged to the branch mainline in revision 4738.
  • Revision ID: andrew.bennetts@canonical.com-20091013052050-u1w6tv0z7kqhn8d0
Merge 2.0 into lp:bzr, resolving conflicts in NEWS and releasing.txt.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/revisionspec.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
from __future__ import absolute_import
18
17
 
 
18
import re
19
19
 
20
20
from bzrlib.lazy_import import lazy_import
21
21
lazy_import(globals(), """
22
22
import bisect
23
23
import datetime
 
24
""")
24
25
 
25
26
from bzrlib import (
26
 
    branch as _mod_branch,
 
27
    errors,
27
28
    osutils,
 
29
    registry,
28
30
    revision,
29
31
    symbol_versioning,
30
 
    workingtree,
31
 
    )
32
 
from bzrlib.i18n import gettext
33
 
""")
34
 
 
35
 
from bzrlib import (
36
 
    errors,
37
 
    lazy_regex,
38
 
    registry,
39
32
    trace,
40
33
    )
41
34
 
42
35
 
 
36
_marker = []
 
37
 
 
38
 
43
39
class RevisionInfo(object):
44
40
    """The results of applying a revision specification to a branch."""
45
41
 
57
53
    or treat the result as a tuple.
58
54
    """
59
55
 
60
 
    def __init__(self, branch, revno=None, rev_id=None):
 
56
    def __init__(self, branch, revno, rev_id=_marker):
61
57
        self.branch = branch
62
 
        self._has_revno = (revno is not None)
63
 
        self._revno = revno
64
 
        self.rev_id = rev_id
65
 
        if self.rev_id is None and self._revno is not None:
 
58
        self.revno = revno
 
59
        if rev_id is _marker:
66
60
            # allow caller to be lazy
67
 
            self.rev_id = branch.get_rev_id(self._revno)
68
 
 
69
 
    @property
70
 
    def revno(self):
71
 
        if not self._has_revno and self.rev_id is not None:
72
 
            try:
73
 
                self._revno = self.branch.revision_id_to_revno(self.rev_id)
74
 
            except errors.NoSuchRevision:
75
 
                self._revno = None
76
 
            self._has_revno = True
77
 
        return self._revno
 
61
            if self.revno is None:
 
62
                self.rev_id = None
 
63
            else:
 
64
                self.rev_id = branch.get_rev_id(self.revno)
 
65
        else:
 
66
            self.rev_id = rev_id
78
67
 
79
68
    def __nonzero__(self):
 
69
        # first the easy ones...
80
70
        if self.rev_id is None:
81
71
            return False
 
72
        if self.revno is not None:
 
73
            return True
82
74
        # TODO: otherwise, it should depend on how I was built -
83
75
        # if it's in_history(branch), then check revision_history(),
84
76
        # if it's in_store(branch), do the check below
107
99
            self.revno, self.rev_id, self.branch)
108
100
 
109
101
    @staticmethod
110
 
    def from_revision_id(branch, revision_id, revs=symbol_versioning.DEPRECATED_PARAMETER):
 
102
    def from_revision_id(branch, revision_id, revs):
111
103
        """Construct a RevisionInfo given just the id.
112
104
 
113
105
        Use this if you don't know or care what the revno is.
114
106
        """
115
 
        if symbol_versioning.deprecated_passed(revs):
116
 
            symbol_versioning.warn(
117
 
                'RevisionInfo.from_revision_id(revs) was deprecated in 2.5.',
118
 
                DeprecationWarning,
119
 
                stacklevel=2)
120
 
        return RevisionInfo(branch, revno=None, rev_id=revision_id)
 
107
        if revision_id == revision.NULL_REVISION:
 
108
            return RevisionInfo(branch, 0, revision_id)
 
109
        try:
 
110
            revno = revs.index(revision_id) + 1
 
111
        except ValueError:
 
112
            revno = None
 
113
        return RevisionInfo(branch, revno, revision_id)
 
114
 
 
115
 
 
116
# classes in this list should have a "prefix" attribute, against which
 
117
# string specs are matched
 
118
_revno_regex = None
121
119
 
122
120
 
123
121
class RevisionSpec(object):
125
123
 
126
124
    help_txt = """A parsed revision specification.
127
125
 
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.
 
126
    A revision specification can be an integer, in which case it is
 
127
    assumed to be a revno (though this will translate negative values
 
128
    into positive ones); or it can be a string, in which case it is
 
129
    parsed for something like 'date:' or 'revid:' etc.
132
130
 
133
131
    Revision specs are an UI element, and they have been moved out
134
132
    of the branch class to leave "back-end" classes unaware of such
140
138
    """
141
139
 
142
140
    prefix = None
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.
147
 
 
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
151
 
    dwim processing.
152
 
    """
 
141
    wants_revision_history = True
153
142
 
154
143
    @staticmethod
155
144
    def from_string(spec):
171
160
                         spectype.__name__, spec)
172
161
            return spectype(spec, _internal=True)
173
162
        else:
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)
 
163
            for spectype in SPEC_TYPES:
 
164
                if spec.startswith(spectype.prefix):
 
165
                    trace.mutter('Returning RevisionSpec %s for %s',
 
166
                                 spectype.__name__, spec)
 
167
                    return spectype(spec, _internal=True)
 
168
            # RevisionSpec_revno is special cased, because it is the only
 
169
            # one that directly handles plain integers
 
170
            # TODO: This should not be special cased rather it should be
 
171
            # a method invocation on spectype.canparse()
 
172
            global _revno_regex
 
173
            if _revno_regex is None:
 
174
                _revno_regex = re.compile(r'^(?:(\d+(\.\d+)*)|-\d+)(:.*)?$')
 
175
            if _revno_regex.match(spec) is not None:
 
176
                return RevisionSpec_revno(spec, _internal=True)
 
177
 
 
178
            raise errors.NoSuchRevisionSpec(spec)
177
179
 
178
180
    def __init__(self, spec, _internal=False):
179
181
        """Create a RevisionSpec referring to the Null revision.
212
214
    def in_history(self, branch):
213
215
        if branch:
214
216
            if self.wants_revision_history:
215
 
                symbol_versioning.warn(
216
 
                    "RevisionSpec.wants_revision_history was "
217
 
                    "deprecated in 2.5 (%s)." % self.__class__.__name__,
218
 
                    DeprecationWarning)
219
 
                branch.lock_read()
220
 
                try:
221
 
                    graph = branch.repository.get_graph()
222
 
                    revs = list(graph.iter_lefthand_ancestry(
223
 
                        branch.last_revision(), [revision.NULL_REVISION]))
224
 
                finally:
225
 
                    branch.unlock()
226
 
                revs.reverse()
 
217
                revs = branch.revision_history()
227
218
            else:
228
219
                revs = None
229
220
        else:
299
290
 
300
291
# private API
301
292
 
302
 
class RevisionSpec_dwim(RevisionSpec):
303
 
    """Provides a DWIMish revision specifier lookup.
304
 
 
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.
309
 
    """
310
 
 
311
 
    help_txt = None
312
 
 
313
 
    _revno_regex = lazy_regex.lazy_compile(r'^(?:(\d+(\.\d+)*)|-\d+)(:.*)?$')
314
 
 
315
 
    # The revspecs to try
316
 
    _possible_revspecs = []
317
 
 
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
321
 
        # next type.
322
 
        return rs.in_history(branch)
323
 
 
324
 
    def _match_on(self, branch, revs):
325
 
        """Run the lookup and see what we can get."""
326
 
 
327
 
        # First, see if it's a revno
328
 
        if self._revno_regex.match(self.spec) is not None:
329
 
            try:
330
 
                return self._try_spectype(RevisionSpec_revno, branch)
331
 
            except RevisionSpec_revno.dwim_catchable_exceptions:
332
 
                pass
333
 
 
334
 
        # Next see what has been registered
335
 
        for objgetter in self._possible_revspecs:
336
 
            rs_class = objgetter.get_obj()
337
 
            try:
338
 
                return self._try_spectype(rs_class, branch)
339
 
            except rs_class.dwim_catchable_exceptions:
340
 
                pass
341
 
 
342
 
        # Try the old (deprecated) dwim list:
343
 
        for rs_class in dwim_revspecs:
344
 
            try:
345
 
                return self._try_spectype(rs_class, branch)
346
 
            except rs_class.dwim_catchable_exceptions:
347
 
                pass
348
 
 
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
351
 
        # really relevant.
352
 
        raise errors.InvalidRevisionSpec(self.spec, branch)
353
 
 
354
 
    @classmethod
355
 
    def append_possible_revspec(cls, revspec):
356
 
        """Append a possible DWIM revspec.
357
 
 
358
 
        :param revspec: Revision spec to try.
359
 
        """
360
 
        cls._possible_revspecs.append(registry._ObjectGetter(revspec))
361
 
 
362
 
    @classmethod
363
 
    def append_possible_lazy_revspec(cls, module_name, member_name):
364
 
        """Append a possible lazily loaded DWIM revspec.
365
 
 
366
 
        :param module_name: Name of the module with the revspec
367
 
        :param member_name: Name of the revspec within the module
368
 
        """
369
 
        cls._possible_revspecs.append(
370
 
            registry._LazyObjectGetter(module_name, member_name))
371
 
 
372
 
 
373
293
class RevisionSpec_revno(RevisionSpec):
374
294
    """Selects a revision using a number."""
375
295
 
376
296
    help_txt = """Selects a revision using a number.
377
297
 
378
298
    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.
 
299
    Optionally a branch can be specified. The 'revno:' prefix is optional.
 
300
    A negative number will count from the end of the branch (-1 is the
 
301
    last revision, -2 the previous one). If the negative number is larger
 
302
    than the branch's history, the first revision is returned.
383
303
    Examples::
384
304
 
385
305
      revno:1                   -> return the first revision of this branch
392
312
                                   your history is very long.
393
313
    """
394
314
    prefix = 'revno:'
 
315
    wants_revision_history = False
395
316
 
396
317
    def _match_on(self, branch, revs):
397
318
        """Lookup a revision by revision number"""
398
 
        branch, revno, revision_id = self._lookup(branch)
 
319
        branch, revno, revision_id = self._lookup(branch, revs)
399
320
        return RevisionInfo(branch, revno, revision_id)
400
321
 
401
 
    def _lookup(self, branch):
 
322
    def _lookup(self, branch, revs_or_none):
402
323
        loc = self.spec.find(':')
403
324
        if loc == -1:
404
325
            revno_spec = self.spec
428
349
                dotted = True
429
350
 
430
351
        if branch_spec:
431
 
            # the user has overriden the branch to look in.
432
 
            branch = _mod_branch.Branch.open(branch_spec)
 
352
            # the user has override the branch to look in.
 
353
            # we need to refresh the revision_history map and
 
354
            # the branch object.
 
355
            from bzrlib.branch import Branch
 
356
            branch = Branch.open(branch_spec)
 
357
            revs_or_none = None
433
358
 
434
359
        if dotted:
435
360
            try:
439
364
                raise errors.InvalidRevisionSpec(self.user_spec, branch)
440
365
            else:
441
366
                # there is no traditional 'revno' for dotted-decimal revnos.
442
 
                # so for API compatibility we return None.
 
367
                # so for  API compatability we return None.
443
368
                return branch, None, revision_id
444
369
        else:
445
370
            last_revno, last_revision_id = branch.last_revision_info()
451
376
                else:
452
377
                    revno = last_revno + revno + 1
453
378
            try:
454
 
                revision_id = branch.get_rev_id(revno)
 
379
                revision_id = branch.get_rev_id(revno, revs_or_none)
455
380
            except errors.NoSuchRevision:
456
381
                raise errors.InvalidRevisionSpec(self.user_spec, branch)
457
382
        return branch, revno, revision_id
458
383
 
459
384
    def _as_revision_id(self, context_branch):
460
385
        # We would have the revno here, but we don't really care
461
 
        branch, revno, revision_id = self._lookup(context_branch)
 
386
        branch, revno, revision_id = self._lookup(context_branch, None)
462
387
        return revision_id
463
388
 
464
389
    def needs_branch(self):
474
399
RevisionSpec_int = RevisionSpec_revno
475
400
 
476
401
 
477
 
class RevisionIDSpec(RevisionSpec):
478
 
 
479
 
    def _match_on(self, branch, revs):
480
 
        revision_id = self.as_revision_id(branch)
481
 
        return RevisionInfo.from_revision_id(branch, revision_id)
482
 
 
483
 
 
484
 
class RevisionSpec_revid(RevisionIDSpec):
 
402
 
 
403
class RevisionSpec_revid(RevisionSpec):
485
404
    """Selects a revision using the revision id."""
486
405
 
487
406
    help_txt = """Selects a revision using the revision id.
496
415
 
497
416
    prefix = 'revid:'
498
417
 
499
 
    def _as_revision_id(self, context_branch):
 
418
    def _match_on(self, branch, revs):
500
419
        # self.spec comes straight from parsing the command line arguments,
501
420
        # so we expect it to be a Unicode string. Switch it to the internal
502
421
        # representation.
 
422
        revision_id = osutils.safe_revision_id(self.spec, warn=False)
 
423
        return RevisionInfo.from_revision_id(branch, revision_id, revs)
 
424
 
 
425
    def _as_revision_id(self, context_branch):
503
426
        return osutils.safe_revision_id(self.spec, warn=False)
504
427
 
505
428
 
520
443
    prefix = 'last:'
521
444
 
522
445
    def _match_on(self, branch, revs):
523
 
        revno, revision_id = self._revno_and_revision_id(branch)
 
446
        revno, revision_id = self._revno_and_revision_id(branch, revs)
524
447
        return RevisionInfo(branch, revno, revision_id)
525
448
 
526
 
    def _revno_and_revision_id(self, context_branch):
 
449
    def _revno_and_revision_id(self, context_branch, revs_or_none):
527
450
        last_revno, last_revision_id = context_branch.last_revision_info()
528
451
 
529
452
        if self.spec == '':
542
465
 
543
466
        revno = last_revno - offset + 1
544
467
        try:
545
 
            revision_id = context_branch.get_rev_id(revno)
 
468
            revision_id = context_branch.get_rev_id(revno, revs_or_none)
546
469
        except errors.NoSuchRevision:
547
470
            raise errors.InvalidRevisionSpec(self.user_spec, context_branch)
548
471
        return revno, revision_id
550
473
    def _as_revision_id(self, context_branch):
551
474
        # We compute the revno as part of the process, but we don't really care
552
475
        # about it.
553
 
        revno, revision_id = self._revno_and_revision_id(context_branch)
 
476
        revno, revision_id = self._revno_and_revision_id(context_branch, None)
554
477
        return revision_id
555
478
 
556
479
 
588
511
            # We need to use the repository history here
589
512
            rev = branch.repository.get_revision(r.rev_id)
590
513
            if not rev.parent_ids:
 
514
                revno = 0
591
515
                revision_id = revision.NULL_REVISION
592
516
            else:
593
517
                revision_id = rev.parent_ids[0]
594
 
            revno = None
 
518
                try:
 
519
                    revno = revs.index(revision_id) + 1
 
520
                except ValueError:
 
521
                    revno = None
595
522
        else:
596
523
            revno = r.revno - 1
597
524
            try:
602
529
        return RevisionInfo(branch, revno, revision_id)
603
530
 
604
531
    def _as_revision_id(self, context_branch):
605
 
        base_revision_id = RevisionSpec.from_string(self.spec)._as_revision_id(context_branch)
 
532
        base_revspec = RevisionSpec.from_string(self.spec)
 
533
        base_revision_id = base_revspec.as_revision_id(context_branch)
606
534
        if base_revision_id == revision.NULL_REVISION:
607
535
            raise errors.InvalidRevisionSpec(self.user_spec, context_branch,
608
536
                                         'cannot go before the null: revision')
633
561
    """
634
562
 
635
563
    prefix = 'tag:'
636
 
    dwim_catchable_exceptions = (errors.NoSuchTag, errors.TagsNotSupported)
637
564
 
638
565
    def _match_on(self, branch, revs):
639
566
        # Can raise tags not supported, NoSuchTag, etc
640
567
        return RevisionInfo.from_revision_id(branch,
641
 
            branch.tags.lookup_tag(self.spec))
 
568
            branch.tags.lookup_tag(self.spec),
 
569
            revs)
642
570
 
643
571
    def _as_revision_id(self, context_branch):
644
572
        return context_branch.tags.lookup_tag(self.spec)
648
576
class _RevListToTimestamps(object):
649
577
    """This takes a list of revisions, and allows you to bisect by date"""
650
578
 
651
 
    __slots__ = ['branch']
 
579
    __slots__ = ['revs', 'branch']
652
580
 
653
 
    def __init__(self, branch):
 
581
    def __init__(self, revs, branch):
 
582
        self.revs = revs
654
583
        self.branch = branch
655
584
 
656
585
    def __getitem__(self, index):
657
586
        """Get the date of the index'd item"""
658
 
        r = self.branch.repository.get_revision(self.branch.get_rev_id(index))
 
587
        r = self.branch.repository.get_revision(self.revs[index])
659
588
        # TODO: Handle timezone.
660
589
        return datetime.datetime.fromtimestamp(r.timestamp)
661
590
 
662
591
    def __len__(self):
663
 
        return self.branch.revno()
 
592
        return len(self.revs)
664
593
 
665
594
 
666
595
class RevisionSpec_date(RevisionSpec):
684
613
                                   August 14th, 2006 at 5:10pm.
685
614
    """
686
615
    prefix = 'date:'
687
 
    _date_regex = lazy_regex.lazy_compile(
 
616
    _date_re = re.compile(
688
617
            r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
689
618
            r'(,|T)?\s*'
690
619
            r'(?P<time>(?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d))?)?'
708
637
        elif self.spec.lower() == 'tomorrow':
709
638
            dt = today + datetime.timedelta(days=1)
710
639
        else:
711
 
            m = self._date_regex.match(self.spec)
 
640
            m = self._date_re.match(self.spec)
712
641
            if not m or (not m.group('date') and not m.group('time')):
713
642
                raise errors.InvalidRevisionSpec(self.user_spec,
714
643
                                                 branch, 'invalid date')
740
669
                    hour=hour, minute=minute, second=second)
741
670
        branch.lock_read()
742
671
        try:
743
 
            rev = bisect.bisect(_RevListToTimestamps(branch), dt, 1)
 
672
            rev = bisect.bisect(_RevListToTimestamps(revs, branch), dt)
744
673
        finally:
745
674
            branch.unlock()
746
 
        if rev == branch.revno():
 
675
        if rev == len(revs):
747
676
            raise errors.InvalidRevisionSpec(self.user_spec, branch)
748
 
        return RevisionInfo(branch, rev)
 
677
        else:
 
678
            return RevisionInfo(branch, rev + 1)
749
679
 
750
680
 
751
681
 
782
712
    def _find_revision_info(branch, other_location):
783
713
        revision_id = RevisionSpec_ancestor._find_revision_id(branch,
784
714
                                                              other_location)
785
 
        return RevisionInfo(branch, None, revision_id)
 
715
        try:
 
716
            revno = branch.revision_id_to_revno(revision_id)
 
717
        except errors.NoSuchRevision:
 
718
            revno = None
 
719
        return RevisionInfo(branch, revno, revision_id)
786
720
 
787
721
    @staticmethod
788
722
    def _find_revision_id(branch, other_location):
826
760
      branch:/path/to/branch
827
761
    """
828
762
    prefix = 'branch:'
829
 
    dwim_catchable_exceptions = (errors.NotBranchError,)
830
763
 
831
764
    def _match_on(self, branch, revs):
832
765
        from bzrlib.branch import Branch
834
767
        revision_b = other_branch.last_revision()
835
768
        if revision_b in (None, revision.NULL_REVISION):
836
769
            raise errors.NoCommits(other_branch)
837
 
        if branch is None:
838
 
            branch = other_branch
839
 
        else:
840
 
            try:
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)
 
770
        # pull in the remote revisions so we can diff
 
771
        branch.fetch(other_branch, revision_b)
 
772
        try:
 
773
            revno = branch.revision_id_to_revno(revision_b)
 
774
        except errors.NoSuchRevision:
 
775
            revno = None
 
776
        return RevisionInfo(branch, revno, revision_b)
846
777
 
847
778
    def _as_revision_id(self, context_branch):
848
779
        from bzrlib.branch import Branch
863
794
            raise errors.NoCommits(other_branch)
864
795
        return other_branch.repository.revision_tree(last_revision)
865
796
 
866
 
    def needs_branch(self):
867
 
        return False
868
 
 
869
 
    def get_branch(self):
870
 
        return self.spec
871
 
 
872
797
 
873
798
 
874
799
class RevisionSpec_submit(RevisionSpec_ancestor):
900
825
            location_type = 'parent branch'
901
826
        if submit_location is None:
902
827
            raise errors.NoSubmitBranch(branch)
903
 
        trace.note(gettext('Using {0} {1}').format(location_type,
904
 
                                                        submit_location))
 
828
        trace.note('Using %s %s', location_type, submit_location)
905
829
        return submit_location
906
830
 
907
831
    def _match_on(self, branch, revs):
914
838
            self._get_submit_location(context_branch))
915
839
 
916
840
 
917
 
class RevisionSpec_annotate(RevisionIDSpec):
918
 
 
919
 
    prefix = 'annotate:'
920
 
 
921
 
    help_txt = """Select the revision that last modified the specified line.
922
 
 
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.
927
 
    """
928
 
 
929
 
    def _raise_invalid(self, numstring, context_branch):
930
 
        raise errors.InvalidRevisionSpec(self.user_spec, context_branch,
931
 
            'No such line: %s' % numstring)
932
 
 
933
 
    def _as_revision_id(self, context_branch):
934
 
        path, numstring = self.spec.rsplit(':', 1)
935
 
        try:
936
 
            index = int(numstring) - 1
937
 
        except ValueError:
938
 
            self._raise_invalid(numstring, context_branch)
939
 
        tree, file_path = workingtree.WorkingTree.open_containing(path)
940
 
        tree.lock_read()
941
 
        try:
942
 
            file_id = tree.path2id(file_path)
943
 
            if file_id is None:
944
 
                raise errors.InvalidRevisionSpec(self.user_spec,
945
 
                    context_branch, "File '%s' is not versioned." %
946
 
                    file_path)
947
 
            revision_ids = [r for (r, l) in tree.annotate_iter(file_id)]
948
 
        finally:
949
 
            tree.unlock()
950
 
        try:
951
 
            revision_id = revision_ids[index]
952
 
        except IndexError:
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)
957
 
        return revision_id
958
 
 
959
 
 
960
 
class RevisionSpec_mainline(RevisionIDSpec):
961
 
 
962
 
    help_txt = """Select mainline revision that merged the specified revision.
963
 
 
964
 
    Select the revision that merged the specified revision into mainline.
965
 
    """
966
 
 
967
 
    prefix = 'mainline:'
968
 
 
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
973
 
        else:
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())
979
 
        if result is None:
980
 
            raise errors.InvalidRevisionSpec(self.user_spec, context_branch)
981
 
        return result
982
 
 
983
 
 
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", [])
989
 
 
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)
994
 
 
995
841
revspec_registry = registry.Registry()
996
842
def _register_revspec(revspec):
997
843
    revspec_registry.register(revspec.prefix, revspec)
1005
851
_register_revspec(RevisionSpec_ancestor)
1006
852
_register_revspec(RevisionSpec_branch)
1007
853
_register_revspec(RevisionSpec_submit)
1008
 
_register_revspec(RevisionSpec_annotate)
1009
 
_register_revspec(RevisionSpec_mainline)
 
854
 
 
855
SPEC_TYPES = symbol_versioning.deprecated_list(
 
856
    symbol_versioning.deprecated_in((1, 12, 0)), "SPEC_TYPES", [])