← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/revisionspec.py

  • Committer: Alexander Belchenko
  • Date: 2007-04-30 19:52:44 UTC
  • mto: This revision was merged to the branch mainline in revision 2478.
  • Revision ID: bialix@ukr.net-20070430195244-pxc5r3x72ckh027e
Bugfix #110901: commit message template written with native line-endings; corresponding unit tests added

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/revisionspec.py
12
12
#
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
16
 
 
17
 
 
18
 
import re
19
 
 
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
 
16
 
 
17
 
22
18
import bisect
23
19
import datetime
24
 
""")
 
20
import re
25
21
 
26
22
from bzrlib import (
27
23
    errors,
28
24
    osutils,
29
 
    registry,
30
25
    revision,
31
26
    symbol_versioning,
32
27
    trace,
 
28
    tsort,
33
29
    )
34
30
 
35
31
 
104
100
 
105
101
        Use this if you don't know or care what the revno is.
106
102
        """
107
 
        if revision_id == revision.NULL_REVISION:
108
 
            return RevisionInfo(branch, 0, revision_id)
109
103
        try:
110
104
            revno = revs.index(revision_id) + 1
111
105
        except ValueError:
115
109
 
116
110
# classes in this list should have a "prefix" attribute, against which
117
111
# string specs are matched
 
112
SPEC_TYPES = []
118
113
_revno_regex = None
119
114
 
120
115
 
138
133
    """
139
134
 
140
135
    prefix = None
141
 
    wants_revision_history = True
 
136
 
 
137
    def __new__(cls, spec, _internal=False):
 
138
        if _internal:
 
139
            return object.__new__(cls, spec, _internal=_internal)
 
140
 
 
141
        symbol_versioning.warn('Creating a RevisionSpec directly has'
 
142
                               ' been deprecated in version 0.11. Use'
 
143
                               ' RevisionSpec.from_string()'
 
144
                               ' instead.',
 
145
                               DeprecationWarning, stacklevel=2)
 
146
        return RevisionSpec.from_string(spec)
142
147
 
143
148
    @staticmethod
144
149
    def from_string(spec):
153
158
 
154
159
        if spec is None:
155
160
            return RevisionSpec(None, _internal=True)
156
 
        match = revspec_registry.get_prefix(spec)
157
 
        if match is not None:
158
 
            spectype, specsuffix = match
159
 
            trace.mutter('Returning RevisionSpec %s for %s',
160
 
                         spectype.__name__, spec)
161
 
            return spectype(spec, _internal=True)
162
 
        else:
163
 
            for spectype in SPEC_TYPES:
 
161
 
 
162
        assert isinstance(spec, basestring), \
 
163
            "You should only supply strings not %s" % (type(spec),)
 
164
 
 
165
        for spectype in SPEC_TYPES:
 
166
            if spec.startswith(spectype.prefix):
164
167
                trace.mutter('Returning RevisionSpec %s for %s',
165
168
                             spectype.__name__, spec)
166
 
                if spec.startswith(spectype.prefix):
167
 
                    return spectype(spec, _internal=True)
 
169
                return spectype(spec, _internal=True)
 
170
        else:
168
171
            # RevisionSpec_revno is special cased, because it is the only
169
172
            # one that directly handles plain integers
170
173
            # TODO: This should not be special cased rather it should be
198
201
 
199
202
    def _match_on(self, branch, revs):
200
203
        trace.mutter('Returning RevisionSpec._match_on: None')
201
 
        return RevisionInfo(branch, None, None)
 
204
        return RevisionInfo(branch, 0, None)
202
205
 
203
206
    def _match_on_and_check(self, branch, revs):
204
207
        info = self._match_on(branch, revs)
205
208
        if info:
206
209
            return info
207
 
        elif info == (None, None):
208
 
            # special case - nothing supplied
 
210
        elif info == (0, None):
 
211
            # special case - the empty tree
209
212
            return info
210
213
        elif self.prefix:
211
214
            raise errors.InvalidRevisionSpec(self.user_spec, branch)
214
217
 
215
218
    def in_history(self, branch):
216
219
        if branch:
217
 
            if self.wants_revision_history:
218
 
                revs = branch.revision_history()
219
 
            else:
220
 
                revs = None
 
220
            revs = branch.revision_history()
221
221
        else:
222
222
            # this should never trigger.
223
223
            # TODO: make it a deprecated code path. RBC 20060928
233
233
    # will do what you expect.
234
234
    in_store = in_history
235
235
    in_branch = in_store
236
 
 
237
 
    def as_revision_id(self, context_branch):
238
 
        """Return just the revision_id for this revisions spec.
239
 
 
240
 
        Some revision specs require a context_branch to be able to determine
241
 
        their value. Not all specs will make use of it.
242
 
        """
243
 
        return self._as_revision_id(context_branch)
244
 
 
245
 
    def _as_revision_id(self, context_branch):
246
 
        """Implementation of as_revision_id()
247
 
 
248
 
        Classes should override this function to provide appropriate
249
 
        functionality. The default is to just call '.in_history().rev_id'
250
 
        """
251
 
        return self.in_history(context_branch).rev_id
252
 
 
253
 
    def as_tree(self, context_branch):
254
 
        """Return the tree object for this revisions spec.
255
 
 
256
 
        Some revision specs require a context_branch to be able to determine
257
 
        the revision id and access the repository. Not all specs will make
258
 
        use of it.
259
 
        """
260
 
        return self._as_tree(context_branch)
261
 
 
262
 
    def _as_tree(self, context_branch):
263
 
        """Implementation of as_tree().
264
 
 
265
 
        Classes should override this function to provide appropriate
266
 
        functionality. The default is to just call '.as_revision_id()'
267
 
        and get the revision tree from context_branch's repository.
268
 
        """
269
 
        revision_id = self.as_revision_id(context_branch)
270
 
        return context_branch.repository.revision_tree(revision_id)
271
 
 
 
236
        
272
237
    def __repr__(self):
273
238
        # this is mostly for helping with testing
274
239
        return '<%s %s>' % (self.__class__.__name__,
275
240
                              self.user_spec)
276
 
 
 
241
    
277
242
    def needs_branch(self):
278
243
        """Whether this revision spec needs a branch.
279
244
 
283
248
 
284
249
    def get_branch(self):
285
250
        """When the revision specifier contains a branch location, return it.
286
 
 
 
251
        
287
252
        Otherwise, return None.
288
253
        """
289
254
        return None
301
266
    A negative number will count from the end of the branch (-1 is the
302
267
    last revision, -2 the previous one). If the negative number is larger
303
268
    than the branch's history, the first revision is returned.
304
 
    Examples::
305
 
 
306
 
      revno:1                   -> return the first revision of this branch
 
269
    examples:
 
270
      revno:1                   -> return the first revision
307
271
      revno:3:/path/to/branch   -> return the 3rd revision of
308
272
                                   the branch '/path/to/branch'
309
273
      revno:-1                  -> The last revision in a branch.
313
277
                                   your history is very long.
314
278
    """
315
279
    prefix = 'revno:'
316
 
    wants_revision_history = False
317
280
 
318
281
    def _match_on(self, branch, revs):
319
282
        """Lookup a revision by revision number"""
320
 
        branch, revno, revision_id = self._lookup(branch, revs)
321
 
        return RevisionInfo(branch, revno, revision_id)
322
 
 
323
 
    def _lookup(self, branch, revs_or_none):
324
283
        loc = self.spec.find(':')
325
284
        if loc == -1:
326
285
            revno_spec = self.spec
340
299
                dotted = False
341
300
            except ValueError:
342
301
                # dotted decimal. This arguably should not be here
343
 
                # but the from_string method is a little primitive
 
302
                # but the from_string method is a little primitive 
344
303
                # right now - RBC 20060928
345
304
                try:
346
305
                    match_revno = tuple((int(number) for number in revno_spec.split('.')))
355
314
            # the branch object.
356
315
            from bzrlib.branch import Branch
357
316
            branch = Branch.open(branch_spec)
358
 
            revs_or_none = None
 
317
            # Need to use a new revision history
 
318
            # because we are using a specific branch
 
319
            revs = branch.revision_history()
359
320
 
360
321
        if dotted:
 
322
            branch.lock_read()
361
323
            try:
362
 
                revision_id = branch.dotted_revno_to_revision_id(match_revno,
363
 
                    _cache_reverse=True)
364
 
            except errors.NoSuchRevision:
365
 
                raise errors.InvalidRevisionSpec(self.user_spec, branch)
 
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]
 
328
            finally:
 
329
                branch.unlock()
 
330
            if len(revisions) != 1:
 
331
                return RevisionInfo(branch, None, None)
366
332
            else:
367
333
                # there is no traditional 'revno' for dotted-decimal revnos.
368
334
                # so for  API compatability we return None.
369
 
                return branch, None, revision_id
 
335
                return RevisionInfo(branch, None, revisions[0])
370
336
        else:
371
 
            last_revno, last_revision_id = branch.last_revision_info()
372
337
            if revno < 0:
373
338
                # if get_rev_id supported negative revnos, there would not be a
374
339
                # need for this special case.
375
 
                if (-revno) >= last_revno:
 
340
                if (-revno) >= len(revs):
376
341
                    revno = 1
377
342
                else:
378
 
                    revno = last_revno + revno + 1
 
343
                    revno = len(revs) + revno + 1
379
344
            try:
380
 
                revision_id = branch.get_rev_id(revno, revs_or_none)
 
345
                revision_id = branch.get_rev_id(revno, revs)
381
346
            except errors.NoSuchRevision:
382
347
                raise errors.InvalidRevisionSpec(self.user_spec, branch)
383
 
        return branch, revno, revision_id
384
 
 
385
 
    def _as_revision_id(self, context_branch):
386
 
        # We would have the revno here, but we don't really care
387
 
        branch, revno, revision_id = self._lookup(context_branch, None)
388
 
        return revision_id
389
 
 
 
348
        return RevisionInfo(branch, revno, revision_id)
 
349
        
390
350
    def needs_branch(self):
391
351
        return self.spec.find(':') == -1
392
352
 
396
356
        else:
397
357
            return self.spec[self.spec.find(':')+1:]
398
358
 
399
 
# Old compatibility
 
359
# Old compatibility 
400
360
RevisionSpec_int = RevisionSpec_revno
401
361
 
 
362
SPEC_TYPES.append(RevisionSpec_revno)
402
363
 
403
364
 
404
365
class RevisionSpec_revid(RevisionSpec):
407
368
    help_txt = """Selects a revision using the revision id.
408
369
 
409
370
    Supply a specific revision id, that can be used to specify any
410
 
    revision id in the ancestry of the branch.
 
371
    revision id in the ancestry of the branch. 
411
372
    Including merges, and pending merges.
412
 
    Examples::
413
 
 
 
373
    examples:
414
374
      revid:aaaa@bbbb-123456789 -> Select revision 'aaaa@bbbb-123456789'
415
 
    """
416
 
 
 
375
    """    
417
376
    prefix = 'revid:'
418
377
 
419
378
    def _match_on(self, branch, revs):
423
382
        revision_id = osutils.safe_revision_id(self.spec, warn=False)
424
383
        return RevisionInfo.from_revision_id(branch, revision_id, revs)
425
384
 
426
 
    def _as_revision_id(self, context_branch):
427
 
        return osutils.safe_revision_id(self.spec, warn=False)
428
 
 
 
385
SPEC_TYPES.append(RevisionSpec_revid)
429
386
 
430
387
 
431
388
class RevisionSpec_last(RevisionSpec):
435
392
 
436
393
    Supply a positive number to get the nth revision from the end.
437
394
    This is the same as supplying negative numbers to the 'revno:' spec.
438
 
    Examples::
439
 
 
 
395
    examples:
440
396
      last:1        -> return the last revision
441
397
      last:3        -> return the revision 2 before the end.
442
 
    """
 
398
    """    
443
399
 
444
400
    prefix = 'last:'
445
401
 
446
402
    def _match_on(self, branch, revs):
447
 
        revno, revision_id = self._revno_and_revision_id(branch, revs)
448
 
        return RevisionInfo(branch, revno, revision_id)
449
 
 
450
 
    def _revno_and_revision_id(self, context_branch, revs_or_none):
451
 
        last_revno, last_revision_id = context_branch.last_revision_info()
452
 
 
453
403
        if self.spec == '':
454
 
            if not last_revno:
455
 
                raise errors.NoCommits(context_branch)
456
 
            return last_revno, last_revision_id
 
404
            if not revs:
 
405
                raise errors.NoCommits(branch)
 
406
            return RevisionInfo(branch, len(revs), revs[-1])
457
407
 
458
408
        try:
459
409
            offset = int(self.spec)
460
410
        except ValueError, e:
461
 
            raise errors.InvalidRevisionSpec(self.user_spec, context_branch, e)
 
411
            raise errors.InvalidRevisionSpec(self.user_spec, branch, e)
462
412
 
463
413
        if offset <= 0:
464
 
            raise errors.InvalidRevisionSpec(self.user_spec, context_branch,
 
414
            raise errors.InvalidRevisionSpec(self.user_spec, branch,
465
415
                                             'you must supply a positive value')
466
 
 
467
 
        revno = last_revno - offset + 1
 
416
        revno = len(revs) - offset + 1
468
417
        try:
469
 
            revision_id = context_branch.get_rev_id(revno, revs_or_none)
 
418
            revision_id = branch.get_rev_id(revno, revs)
470
419
        except errors.NoSuchRevision:
471
 
            raise errors.InvalidRevisionSpec(self.user_spec, context_branch)
472
 
        return revno, revision_id
473
 
 
474
 
    def _as_revision_id(self, context_branch):
475
 
        # We compute the revno as part of the process, but we don't really care
476
 
        # about it.
477
 
        revno, revision_id = self._revno_and_revision_id(context_branch, None)
478
 
        return revision_id
479
 
 
 
420
            raise errors.InvalidRevisionSpec(self.user_spec, branch)
 
421
        return RevisionInfo(branch, revno, revision_id)
 
422
 
 
423
SPEC_TYPES.append(RevisionSpec_last)
480
424
 
481
425
 
482
426
class RevisionSpec_before(RevisionSpec):
484
428
 
485
429
    help_txt = """Selects the parent of the revision specified.
486
430
 
487
 
    Supply any revision spec to return the parent of that revision.  This is
488
 
    mostly useful when inspecting revisions that are not in the revision history
489
 
    of a branch.
490
 
 
 
431
    Supply any revision spec to return the parent of that revision.
491
432
    It is an error to request the parent of the null revision (before:0).
492
 
 
493
 
    Examples::
494
 
 
 
433
    This is mostly useful when inspecting revisions that are not in the
 
434
    revision history of a branch.
 
435
 
 
436
    examples:
495
437
      before:1913    -> Return the parent of revno 1913 (revno 1912)
496
438
      before:revid:aaaa@bbbb-1234567890  -> return the parent of revision
497
439
                                            aaaa@bbbb-1234567890
498
 
      bzr diff -r before:1913..1913
499
 
            -> Find the changes between revision 1913 and its parent (1912).
500
 
               (What changes did revision 1913 introduce).
501
 
               This is equivalent to:  bzr diff -c 1913
 
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)
502
443
    """
503
444
 
504
445
    prefix = 'before:'
505
 
 
 
446
    
506
447
    def _match_on(self, branch, revs):
507
448
        r = RevisionSpec.from_string(self.spec)._match_on(branch, revs)
508
449
        if r.revno == 0:
513
454
            rev = branch.repository.get_revision(r.rev_id)
514
455
            if not rev.parent_ids:
515
456
                revno = 0
516
 
                revision_id = revision.NULL_REVISION
 
457
                revision_id = None
517
458
            else:
518
459
                revision_id = rev.parent_ids[0]
519
460
                try:
529
470
                                                 branch)
530
471
        return RevisionInfo(branch, revno, revision_id)
531
472
 
532
 
    def _as_revision_id(self, context_branch):
533
 
        base_revspec = RevisionSpec.from_string(self.spec)
534
 
        base_revision_id = base_revspec.as_revision_id(context_branch)
535
 
        if base_revision_id == revision.NULL_REVISION:
536
 
            raise errors.InvalidRevisionSpec(self.user_spec, context_branch,
537
 
                                         'cannot go before the null: revision')
538
 
        context_repo = context_branch.repository
539
 
        context_repo.lock_read()
540
 
        try:
541
 
            parent_map = context_repo.get_parent_map([base_revision_id])
542
 
        finally:
543
 
            context_repo.unlock()
544
 
        if base_revision_id not in parent_map:
545
 
            # Ghost, or unknown revision id
546
 
            raise errors.InvalidRevisionSpec(self.user_spec, context_branch,
547
 
                'cannot find the matching revision')
548
 
        parents = parent_map[base_revision_id]
549
 
        if len(parents) < 1:
550
 
            raise errors.InvalidRevisionSpec(self.user_spec, context_branch,
551
 
                'No parents for revision.')
552
 
        return parents[0]
553
 
 
 
473
SPEC_TYPES.append(RevisionSpec_before)
554
474
 
555
475
 
556
476
class RevisionSpec_tag(RevisionSpec):
569
489
            branch.tags.lookup_tag(self.spec),
570
490
            revs)
571
491
 
572
 
    def _as_revision_id(self, context_branch):
573
 
        return context_branch.tags.lookup_tag(self.spec)
574
 
 
 
492
SPEC_TYPES.append(RevisionSpec_tag)
575
493
 
576
494
 
577
495
class _RevListToTimestamps(object):
603
521
    Matches the first entry after a given date (either at midnight or
604
522
    at a specified time).
605
523
 
606
 
    One way to display all the changes since yesterday would be::
607
 
 
608
 
        bzr log -r date:yesterday..
609
 
 
610
 
    Examples::
611
 
 
 
524
    One way to display all the changes since yesterday would be:
 
525
        bzr log -r date:yesterday..-1
 
526
 
 
527
    examples:
612
528
      date:yesterday            -> select the first revision since yesterday
613
529
      date:2006-08-14,17:10:14  -> select the first revision after
614
530
                                   August 14th, 2006 at 5:10pm.
615
 
    """
 
531
    """    
616
532
    prefix = 'date:'
617
533
    _date_re = re.compile(
618
534
            r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
674
590
        finally:
675
591
            branch.unlock()
676
592
        if rev == len(revs):
677
 
            raise errors.InvalidRevisionSpec(self.user_spec, branch)
 
593
            return RevisionInfo(branch, None)
678
594
        else:
679
595
            return RevisionInfo(branch, rev + 1)
680
596
 
 
597
SPEC_TYPES.append(RevisionSpec_date)
681
598
 
682
599
 
683
600
class RevisionSpec_ancestor(RevisionSpec):
695
612
    that your branch introduces, while excluding the changes that you
696
613
    have not merged from the remote branch.
697
614
 
698
 
    Examples::
699
 
 
 
615
    examples:
700
616
      ancestor:/path/to/branch
701
617
      $ bzr diff -r ancestor:../../mainline/branch
702
618
    """
706
622
        trace.mutter('matching ancestor: on: %s, %s', self.spec, branch)
707
623
        return self._find_revision_info(branch, self.spec)
708
624
 
709
 
    def _as_revision_id(self, context_branch):
710
 
        return self._find_revision_id(context_branch, self.spec)
711
 
 
712
625
    @staticmethod
713
626
    def _find_revision_info(branch, other_location):
714
 
        revision_id = RevisionSpec_ancestor._find_revision_id(branch,
715
 
                                                              other_location)
 
627
        from bzrlib.branch import Branch
 
628
 
 
629
        other_branch = Branch.open(other_location)
 
630
        revision_a = branch.last_revision()
 
631
        revision_b = other_branch.last_revision()
 
632
        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,
 
638
                                          revision_source)
716
639
        try:
717
 
            revno = branch.revision_id_to_revno(revision_id)
 
640
            revno = branch.revision_id_to_revno(rev_id)
718
641
        except errors.NoSuchRevision:
719
642
            revno = None
720
 
        return RevisionInfo(branch, revno, revision_id)
721
 
 
722
 
    @staticmethod
723
 
    def _find_revision_id(branch, other_location):
724
 
        from bzrlib.branch import Branch
725
 
 
726
 
        branch.lock_read()
727
 
        try:
728
 
            revision_a = revision.ensure_null(branch.last_revision())
729
 
            if revision_a == revision.NULL_REVISION:
730
 
                raise errors.NoCommits(branch)
731
 
            if other_location == '':
732
 
                other_location = branch.get_parent()
733
 
            other_branch = Branch.open(other_location)
734
 
            other_branch.lock_read()
735
 
            try:
736
 
                revision_b = revision.ensure_null(other_branch.last_revision())
737
 
                if revision_b == revision.NULL_REVISION:
738
 
                    raise errors.NoCommits(other_branch)
739
 
                graph = branch.repository.get_graph(other_branch.repository)
740
 
                rev_id = graph.find_unique_lca(revision_a, revision_b)
741
 
            finally:
742
 
                other_branch.unlock()
743
 
            if rev_id == revision.NULL_REVISION:
744
 
                raise errors.NoCommonAncestor(revision_a, revision_b)
745
 
            return rev_id
746
 
        finally:
747
 
            branch.unlock()
748
 
 
749
 
 
 
643
        return RevisionInfo(branch, revno, rev_id)
 
644
 
 
645
 
 
646
SPEC_TYPES.append(RevisionSpec_ancestor)
750
647
 
751
648
 
752
649
class RevisionSpec_branch(RevisionSpec):
756
653
 
757
654
    Supply the path to a branch to select its last revision.
758
655
 
759
 
    Examples::
760
 
 
 
656
    examples:
761
657
      branch:/path/to/branch
762
658
    """
763
659
    prefix = 'branch:'
775
671
        except errors.NoSuchRevision:
776
672
            revno = None
777
673
        return RevisionInfo(branch, revno, revision_b)
778
 
 
779
 
    def _as_revision_id(self, context_branch):
780
 
        from bzrlib.branch import Branch
781
 
        other_branch = Branch.open(self.spec)
782
 
        last_revision = other_branch.last_revision()
783
 
        last_revision = revision.ensure_null(last_revision)
784
 
        context_branch.fetch(other_branch, last_revision)
785
 
        if last_revision == revision.NULL_REVISION:
786
 
            raise errors.NoCommits(other_branch)
787
 
        return last_revision
788
 
 
789
 
    def _as_tree(self, context_branch):
790
 
        from bzrlib.branch import Branch
791
 
        other_branch = Branch.open(self.spec)
792
 
        last_revision = other_branch.last_revision()
793
 
        last_revision = revision.ensure_null(last_revision)
794
 
        if last_revision == revision.NULL_REVISION:
795
 
            raise errors.NoCommits(other_branch)
796
 
        return other_branch.repository.revision_tree(last_revision)
797
 
 
 
674
        
 
675
SPEC_TYPES.append(RevisionSpec_branch)
798
676
 
799
677
 
800
678
class RevisionSpec_submit(RevisionSpec_ancestor):
804
682
 
805
683
    Diffing against this shows all the changes that were made in this branch,
806
684
    and is a good predictor of what merge will do.  The submit branch is
807
 
    used by the bundle and merge directive commands.  If no submit branch
 
685
    used by the bundle and merge directive comands.  If no submit branch
808
686
    is specified, the parent branch is used instead.
809
687
 
810
688
    The common ancestor is the last revision that existed in both
811
689
    branches. Usually this is the branch point, but it could also be
812
690
    a revision that was merged.
813
691
 
814
 
    Examples::
815
 
 
 
692
    examples:
816
693
      $ bzr diff -r submit:
817
694
    """
818
695
 
819
696
    prefix = 'submit:'
820
697
 
821
 
    def _get_submit_location(self, branch):
 
698
    def _match_on(self, branch, revs):
 
699
        trace.mutter('matching ancestor: on: %s, %s', self.spec, branch)
822
700
        submit_location = branch.get_submit_branch()
823
701
        location_type = 'submit branch'
824
702
        if submit_location is None:
827
705
        if submit_location is None:
828
706
            raise errors.NoSubmitBranch(branch)
829
707
        trace.note('Using %s %s', location_type, submit_location)
830
 
        return submit_location
831
 
 
832
 
    def _match_on(self, branch, revs):
833
 
        trace.mutter('matching ancestor: on: %s, %s', self.spec, branch)
834
 
        return self._find_revision_info(branch,
835
 
            self._get_submit_location(branch))
836
 
 
837
 
    def _as_revision_id(self, context_branch):
838
 
        return self._find_revision_id(context_branch,
839
 
            self._get_submit_location(context_branch))
840
 
 
841
 
 
842
 
revspec_registry = registry.Registry()
843
 
def _register_revspec(revspec):
844
 
    revspec_registry.register(revspec.prefix, revspec)
845
 
 
846
 
_register_revspec(RevisionSpec_revno)
847
 
_register_revspec(RevisionSpec_revid)
848
 
_register_revspec(RevisionSpec_last)
849
 
_register_revspec(RevisionSpec_before)
850
 
_register_revspec(RevisionSpec_tag)
851
 
_register_revspec(RevisionSpec_date)
852
 
_register_revspec(RevisionSpec_ancestor)
853
 
_register_revspec(RevisionSpec_branch)
854
 
_register_revspec(RevisionSpec_submit)
855
 
 
856
 
SPEC_TYPES = symbol_versioning.deprecated_list(
857
 
    symbol_versioning.deprecated_in((1, 12, 0)), "SPEC_TYPES", [])
 
708
        return self._find_revision_info(branch, submit_location)
 
709
 
 
710
 
 
711
SPEC_TYPES.append(RevisionSpec_submit)