← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/revisionspec.py

  • Committer: John Arbash Meinel
  • Date: 2008-10-04 14:10:13 UTC
  • mto: This revision was merged to the branch mainline in revision 3805.
  • Revision ID: john@arbash-meinel.com-20081004141013-yskxjlwtuy2k18ue
Playing around with expanding requests for btree index nodes into neighboring nodes.

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
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
 
 
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
 
 
18
import re
17
19
 
18
20
from bzrlib.lazy_import import lazy_import
19
21
lazy_import(globals(), """
20
22
import bisect
21
23
import datetime
 
24
""")
22
25
 
23
26
from bzrlib import (
24
 
    branch as _mod_branch,
 
27
    errors,
25
28
    osutils,
26
29
    revision,
27
30
    symbol_versioning,
28
 
    workingtree,
29
 
    )
30
 
""")
31
 
 
32
 
from bzrlib import (
33
 
    errors,
34
 
    lazy_regex,
35
 
    registry,
36
31
    trace,
37
32
    )
38
33
 
117
112
        return RevisionInfo(branch, revno, revision_id)
118
113
 
119
114
 
 
115
# classes in this list should have a "prefix" attribute, against which
 
116
# string specs are matched
 
117
SPEC_TYPES = []
 
118
_revno_regex = None
 
119
 
 
120
 
120
121
class RevisionSpec(object):
121
122
    """A parsed revision specification."""
122
123
 
123
124
    help_txt = """A parsed revision specification.
124
125
 
125
 
    A revision specification is a string, which may be unambiguous about
126
 
    what it represents by giving a prefix like 'date:' or 'revid:' etc,
127
 
    or it may have no prefix, in which case it's tried against several
128
 
    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.
129
130
 
130
131
    Revision specs are an UI element, and they have been moved out
131
132
    of the branch class to leave "back-end" classes unaware of such
138
139
 
139
140
    prefix = None
140
141
    wants_revision_history = True
141
 
    dwim_catchable_exceptions = (errors.InvalidRevisionSpec,)
142
 
    """Exceptions that RevisionSpec_dwim._match_on will catch.
143
 
 
144
 
    If the revspec is part of ``dwim_revspecs``, it may be tried with an
145
 
    invalid revspec and raises some exception. The exceptions mentioned here
146
 
    will not be reported to the user but simply ignored without stopping the
147
 
    dwim processing.
148
 
    """
149
142
 
150
143
    @staticmethod
151
144
    def from_string(spec):
160
153
 
161
154
        if spec is None:
162
155
            return RevisionSpec(None, _internal=True)
163
 
        match = revspec_registry.get_prefix(spec)
164
 
        if match is not None:
165
 
            spectype, specsuffix = match
166
 
            trace.mutter('Returning RevisionSpec %s for %s',
167
 
                         spectype.__name__, spec)
168
 
            return spectype(spec, _internal=True)
 
156
        for spectype in SPEC_TYPES:
 
157
            if spec.startswith(spectype.prefix):
 
158
                trace.mutter('Returning RevisionSpec %s for %s',
 
159
                             spectype.__name__, spec)
 
160
                return spectype(spec, _internal=True)
169
161
        else:
170
 
            # Otherwise treat it as a DWIM, build the RevisionSpec object and
171
 
            # wait for _match_on to be called.
172
 
            return RevisionSpec_dwim(spec, _internal=True)
 
162
            # RevisionSpec_revno is special cased, because it is the only
 
163
            # one that directly handles plain integers
 
164
            # TODO: This should not be special cased rather it should be
 
165
            # a method invocation on spectype.canparse()
 
166
            global _revno_regex
 
167
            if _revno_regex is None:
 
168
                _revno_regex = re.compile(r'^(?:(\d+(\.\d+)*)|-\d+)(:.*)?$')
 
169
            if _revno_regex.match(spec) is not None:
 
170
                return RevisionSpec_revno(spec, _internal=True)
 
171
 
 
172
            raise errors.NoSuchRevisionSpec(spec)
173
173
 
174
174
    def __init__(self, spec, _internal=False):
175
175
        """Create a RevisionSpec referring to the Null revision.
179
179
            called directly. Only from RevisionSpec.from_string()
180
180
        """
181
181
        if not _internal:
 
182
            # XXX: Update this after 0.10 is released
182
183
            symbol_versioning.warn('Creating a RevisionSpec directly has'
183
184
                                   ' been deprecated in version 0.11. Use'
184
185
                                   ' RevisionSpec.from_string()'
266
267
        # this is mostly for helping with testing
267
268
        return '<%s %s>' % (self.__class__.__name__,
268
269
                              self.user_spec)
269
 
 
 
270
    
270
271
    def needs_branch(self):
271
272
        """Whether this revision spec needs a branch.
272
273
 
276
277
 
277
278
    def get_branch(self):
278
279
        """When the revision specifier contains a branch location, return it.
279
 
 
 
280
        
280
281
        Otherwise, return None.
281
282
        """
282
283
        return None
284
285
 
285
286
# private API
286
287
 
287
 
class RevisionSpec_dwim(RevisionSpec):
288
 
    """Provides a DWIMish revision specifier lookup.
289
 
 
290
 
    Note that this does not go in the revspec_registry because by definition
291
 
    there is no prefix to identify it.  It's solely called from
292
 
    RevisionSpec.from_string() because the DWIMification happen when _match_on
293
 
    is called so the string describing the revision is kept here until needed.
294
 
    """
295
 
 
296
 
    help_txt = None
297
 
    # We don't need to build the revision history ourself, that's delegated to
298
 
    # each revspec we try.
299
 
    wants_revision_history = False
300
 
 
301
 
    _revno_regex = lazy_regex.lazy_compile(r'^(?:(\d+(\.\d+)*)|-\d+)(:.*)?$')
302
 
 
303
 
    # The revspecs to try
304
 
    _possible_revspecs = []
305
 
 
306
 
    def _try_spectype(self, rstype, branch):
307
 
        rs = rstype(self.spec, _internal=True)
308
 
        # Hit in_history to find out if it exists, or we need to try the
309
 
        # next type.
310
 
        return rs.in_history(branch)
311
 
 
312
 
    def _match_on(self, branch, revs):
313
 
        """Run the lookup and see what we can get."""
314
 
 
315
 
        # First, see if it's a revno
316
 
        if self._revno_regex.match(self.spec) is not None:
317
 
            try:
318
 
                return self._try_spectype(RevisionSpec_revno, branch)
319
 
            except RevisionSpec_revno.dwim_catchable_exceptions:
320
 
                pass
321
 
 
322
 
        # Next see what has been registered
323
 
        for objgetter in self._possible_revspecs:
324
 
            rs_class = objgetter.get_obj()
325
 
            try:
326
 
                return self._try_spectype(rs_class, branch)
327
 
            except rs_class.dwim_catchable_exceptions:
328
 
                pass
329
 
 
330
 
        # Try the old (deprecated) dwim list:
331
 
        for rs_class in dwim_revspecs:
332
 
            try:
333
 
                return self._try_spectype(rs_class, branch)
334
 
            except rs_class.dwim_catchable_exceptions:
335
 
                pass
336
 
 
337
 
        # Well, I dunno what it is. Note that we don't try to keep track of the
338
 
        # first of last exception raised during the DWIM tries as none seems
339
 
        # really relevant.
340
 
        raise errors.InvalidRevisionSpec(self.spec, branch)
341
 
 
342
 
    @classmethod
343
 
    def append_possible_revspec(cls, revspec):
344
 
        """Append a possible DWIM revspec.
345
 
 
346
 
        :param revspec: Revision spec to try.
347
 
        """
348
 
        cls._possible_revspecs.append(registry._ObjectGetter(revspec))
349
 
 
350
 
    @classmethod
351
 
    def append_possible_lazy_revspec(cls, module_name, member_name):
352
 
        """Append a possible lazily loaded DWIM revspec.
353
 
 
354
 
        :param module_name: Name of the module with the revspec
355
 
        :param member_name: Name of the revspec within the module
356
 
        """
357
 
        cls._possible_revspecs.append(
358
 
            registry._LazyObjectGetter(module_name, member_name))
359
 
 
360
 
 
361
288
class RevisionSpec_revno(RevisionSpec):
362
289
    """Selects a revision using a number."""
363
290
 
364
291
    help_txt = """Selects a revision using a number.
365
292
 
366
293
    Use an integer to specify a revision in the history of the branch.
367
 
    Optionally a branch can be specified.  A negative number will count
368
 
    from the end of the branch (-1 is the last revision, -2 the previous
369
 
    one). If the negative number is larger than the branch's history, the
370
 
    first revision is returned.
 
294
    Optionally a branch can be specified. The 'revno:' prefix is optional.
 
295
    A negative number will count from the end of the branch (-1 is the
 
296
    last revision, -2 the previous one). If the negative number is larger
 
297
    than the branch's history, the first revision is returned.
371
298
    Examples::
372
299
 
373
300
      revno:1                   -> return the first revision of this branch
407
334
                dotted = False
408
335
            except ValueError:
409
336
                # dotted decimal. This arguably should not be here
410
 
                # but the from_string method is a little primitive
 
337
                # but the from_string method is a little primitive 
411
338
                # right now - RBC 20060928
412
339
                try:
413
340
                    match_revno = tuple((int(number) for number in revno_spec.split('.')))
425
352
            revs_or_none = None
426
353
 
427
354
        if dotted:
 
355
            branch.lock_read()
428
356
            try:
429
 
                revision_id = branch.dotted_revno_to_revision_id(match_revno,
430
 
                    _cache_reverse=True)
431
 
            except errors.NoSuchRevision:
432
 
                raise errors.InvalidRevisionSpec(self.user_spec, branch)
 
357
                revision_id_to_revno = branch.get_revision_id_to_revno_map()
 
358
                revisions = [revision_id for revision_id, revno
 
359
                             in revision_id_to_revno.iteritems()
 
360
                             if revno == match_revno]
 
361
            finally:
 
362
                branch.unlock()
 
363
            if len(revisions) != 1:
 
364
                return branch, None, None
433
365
            else:
434
366
                # there is no traditional 'revno' for dotted-decimal revnos.
435
367
                # so for  API compatability we return None.
436
 
                return branch, None, revision_id
 
368
                return branch, None, revisions[0]
437
369
        else:
438
370
            last_revno, last_revision_id = branch.last_revision_info()
439
371
            if revno < 0:
463
395
        else:
464
396
            return self.spec[self.spec.find(':')+1:]
465
397
 
466
 
# Old compatibility
 
398
# Old compatibility 
467
399
RevisionSpec_int = RevisionSpec_revno
468
400
 
469
 
 
470
 
 
471
 
class RevisionIDSpec(RevisionSpec):
472
 
 
473
 
    def _match_on(self, branch, revs):
474
 
        revision_id = self.as_revision_id(branch)
475
 
        return RevisionInfo.from_revision_id(branch, revision_id, revs)
476
 
 
477
 
 
478
 
class RevisionSpec_revid(RevisionIDSpec):
 
401
SPEC_TYPES.append(RevisionSpec_revno)
 
402
 
 
403
 
 
404
class RevisionSpec_revid(RevisionSpec):
479
405
    """Selects a revision using the revision id."""
480
406
 
481
407
    help_txt = """Selects a revision using the revision id.
482
408
 
483
409
    Supply a specific revision id, that can be used to specify any
484
 
    revision id in the ancestry of the branch.
 
410
    revision id in the ancestry of the branch. 
485
411
    Including merges, and pending merges.
486
412
    Examples::
487
413
 
490
416
 
491
417
    prefix = 'revid:'
492
418
 
493
 
    def _as_revision_id(self, context_branch):
 
419
    def _match_on(self, branch, revs):
494
420
        # self.spec comes straight from parsing the command line arguments,
495
421
        # so we expect it to be a Unicode string. Switch it to the internal
496
422
        # representation.
 
423
        revision_id = osutils.safe_revision_id(self.spec, warn=False)
 
424
        return RevisionInfo.from_revision_id(branch, revision_id, revs)
 
425
 
 
426
    def _as_revision_id(self, context_branch):
497
427
        return osutils.safe_revision_id(self.spec, warn=False)
498
428
 
 
429
SPEC_TYPES.append(RevisionSpec_revid)
499
430
 
500
431
 
501
432
class RevisionSpec_last(RevisionSpec):
547
478
        revno, revision_id = self._revno_and_revision_id(context_branch, None)
548
479
        return revision_id
549
480
 
 
481
SPEC_TYPES.append(RevisionSpec_last)
550
482
 
551
483
 
552
484
class RevisionSpec_before(RevisionSpec):
572
504
    """
573
505
 
574
506
    prefix = 'before:'
575
 
 
 
507
    
576
508
    def _match_on(self, branch, revs):
577
509
        r = RevisionSpec.from_string(self.spec)._match_on(branch, revs)
578
510
        if r.revno == 0:
621
553
                'No parents for revision.')
622
554
        return parents[0]
623
555
 
 
556
SPEC_TYPES.append(RevisionSpec_before)
624
557
 
625
558
 
626
559
class RevisionSpec_tag(RevisionSpec):
632
565
    """
633
566
 
634
567
    prefix = 'tag:'
635
 
    dwim_catchable_exceptions = (errors.NoSuchTag, errors.TagsNotSupported)
636
568
 
637
569
    def _match_on(self, branch, revs):
638
570
        # Can raise tags not supported, NoSuchTag, etc
643
575
    def _as_revision_id(self, context_branch):
644
576
        return context_branch.tags.lookup_tag(self.spec)
645
577
 
 
578
SPEC_TYPES.append(RevisionSpec_tag)
646
579
 
647
580
 
648
581
class _RevListToTimestamps(object):
683
616
      date:yesterday            -> select the first revision since yesterday
684
617
      date:2006-08-14,17:10:14  -> select the first revision after
685
618
                                   August 14th, 2006 at 5:10pm.
686
 
    """
 
619
    """    
687
620
    prefix = 'date:'
688
 
    _date_regex = lazy_regex.lazy_compile(
 
621
    _date_re = re.compile(
689
622
            r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
690
623
            r'(,|T)?\s*'
691
624
            r'(?P<time>(?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d))?)?'
709
642
        elif self.spec.lower() == 'tomorrow':
710
643
            dt = today + datetime.timedelta(days=1)
711
644
        else:
712
 
            m = self._date_regex.match(self.spec)
 
645
            m = self._date_re.match(self.spec)
713
646
            if not m or (not m.group('date') and not m.group('time')):
714
647
                raise errors.InvalidRevisionSpec(self.user_spec,
715
648
                                                 branch, 'invalid date')
749
682
        else:
750
683
            return RevisionInfo(branch, rev + 1)
751
684
 
 
685
SPEC_TYPES.append(RevisionSpec_date)
752
686
 
753
687
 
754
688
class RevisionSpec_ancestor(RevisionSpec):
799
733
            revision_a = revision.ensure_null(branch.last_revision())
800
734
            if revision_a == revision.NULL_REVISION:
801
735
                raise errors.NoCommits(branch)
802
 
            if other_location == '':
803
 
                other_location = branch.get_parent()
804
736
            other_branch = Branch.open(other_location)
805
737
            other_branch.lock_read()
806
738
            try:
818
750
            branch.unlock()
819
751
 
820
752
 
 
753
SPEC_TYPES.append(RevisionSpec_ancestor)
821
754
 
822
755
 
823
756
class RevisionSpec_branch(RevisionSpec):
832
765
      branch:/path/to/branch
833
766
    """
834
767
    prefix = 'branch:'
835
 
    dwim_catchable_exceptions = (errors.NotBranchError,)
836
768
 
837
769
    def _match_on(self, branch, revs):
838
770
        from bzrlib.branch import Branch
840
772
        revision_b = other_branch.last_revision()
841
773
        if revision_b in (None, revision.NULL_REVISION):
842
774
            raise errors.NoCommits(other_branch)
843
 
        if branch is None:
844
 
            branch = other_branch
845
 
        else:
846
 
            try:
847
 
                # pull in the remote revisions so we can diff
848
 
                branch.fetch(other_branch, revision_b)
849
 
            except errors.ReadOnlyError:
850
 
                branch = other_branch
 
775
        # pull in the remote revisions so we can diff
 
776
        branch.fetch(other_branch, revision_b)
851
777
        try:
852
778
            revno = branch.revision_id_to_revno(revision_b)
853
779
        except errors.NoSuchRevision:
873
799
            raise errors.NoCommits(other_branch)
874
800
        return other_branch.repository.revision_tree(last_revision)
875
801
 
876
 
    def needs_branch(self):
877
 
        return False
878
 
 
879
 
    def get_branch(self):
880
 
        return self.spec
881
 
 
 
802
SPEC_TYPES.append(RevisionSpec_branch)
882
803
 
883
804
 
884
805
class RevisionSpec_submit(RevisionSpec_ancestor):
923
844
            self._get_submit_location(context_branch))
924
845
 
925
846
 
926
 
class RevisionSpec_annotate(RevisionIDSpec):
927
 
 
928
 
    prefix = 'annotate:'
929
 
 
930
 
    help_txt = """Select the revision that last modified the specified line.
931
 
 
932
 
    Select the revision that last modified the specified line.  Line is
933
 
    specified as path:number.  Path is a relative path to the file.  Numbers
934
 
    start at 1, and are relative to the current version, not the last-
935
 
    committed version of the file.
936
 
    """
937
 
 
938
 
    def _raise_invalid(self, numstring, context_branch):
939
 
        raise errors.InvalidRevisionSpec(self.user_spec, context_branch,
940
 
            'No such line: %s' % numstring)
941
 
 
942
 
    def _as_revision_id(self, context_branch):
943
 
        path, numstring = self.spec.rsplit(':', 1)
944
 
        try:
945
 
            index = int(numstring) - 1
946
 
        except ValueError:
947
 
            self._raise_invalid(numstring, context_branch)
948
 
        tree, file_path = workingtree.WorkingTree.open_containing(path)
949
 
        tree.lock_read()
950
 
        try:
951
 
            file_id = tree.path2id(file_path)
952
 
            if file_id is None:
953
 
                raise errors.InvalidRevisionSpec(self.user_spec,
954
 
                    context_branch, "File '%s' is not versioned." %
955
 
                    file_path)
956
 
            revision_ids = [r for (r, l) in tree.annotate_iter(file_id)]
957
 
        finally:
958
 
            tree.unlock()
959
 
        try:
960
 
            revision_id = revision_ids[index]
961
 
        except IndexError:
962
 
            self._raise_invalid(numstring, context_branch)
963
 
        if revision_id == revision.CURRENT_REVISION:
964
 
            raise errors.InvalidRevisionSpec(self.user_spec, context_branch,
965
 
                'Line %s has not been committed.' % numstring)
966
 
        return revision_id
967
 
 
968
 
 
969
 
class RevisionSpec_mainline(RevisionIDSpec):
970
 
 
971
 
    help_txt = """Select mainline revision that merged the specified revision.
972
 
 
973
 
    Select the revision that merged the specified revision into mainline.
974
 
    """
975
 
 
976
 
    prefix = 'mainline:'
977
 
 
978
 
    def _as_revision_id(self, context_branch):
979
 
        revspec = RevisionSpec.from_string(self.spec)
980
 
        if revspec.get_branch() is None:
981
 
            spec_branch = context_branch
982
 
        else:
983
 
            spec_branch = _mod_branch.Branch.open(revspec.get_branch())
984
 
        revision_id = revspec.as_revision_id(spec_branch)
985
 
        graph = context_branch.repository.get_graph()
986
 
        result = graph.find_lefthand_merger(revision_id,
987
 
                                            context_branch.last_revision())
988
 
        if result is None:
989
 
            raise errors.InvalidRevisionSpec(self.user_spec, context_branch)
990
 
        return result
991
 
 
992
 
 
993
 
# The order in which we want to DWIM a revision spec without any prefix.
994
 
# revno is always tried first and isn't listed here, this is used by
995
 
# RevisionSpec_dwim._match_on
996
 
dwim_revspecs = symbol_versioning.deprecated_list(
997
 
    symbol_versioning.deprecated_in((2, 4, 0)), "dwim_revspecs", [])
998
 
 
999
 
RevisionSpec_dwim.append_possible_revspec(RevisionSpec_tag)
1000
 
RevisionSpec_dwim.append_possible_revspec(RevisionSpec_revid)
1001
 
RevisionSpec_dwim.append_possible_revspec(RevisionSpec_date)
1002
 
RevisionSpec_dwim.append_possible_revspec(RevisionSpec_branch)
1003
 
 
1004
 
revspec_registry = registry.Registry()
1005
 
def _register_revspec(revspec):
1006
 
    revspec_registry.register(revspec.prefix, revspec)
1007
 
 
1008
 
_register_revspec(RevisionSpec_revno)
1009
 
_register_revspec(RevisionSpec_revid)
1010
 
_register_revspec(RevisionSpec_last)
1011
 
_register_revspec(RevisionSpec_before)
1012
 
_register_revspec(RevisionSpec_tag)
1013
 
_register_revspec(RevisionSpec_date)
1014
 
_register_revspec(RevisionSpec_ancestor)
1015
 
_register_revspec(RevisionSpec_branch)
1016
 
_register_revspec(RevisionSpec_submit)
1017
 
_register_revspec(RevisionSpec_annotate)
1018
 
_register_revspec(RevisionSpec_mainline)
 
847
SPEC_TYPES.append(RevisionSpec_submit)