← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/revisionspec.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-05-11 11:47:36 UTC
  • mfrom: (5200.3.8 lock_return)
  • Revision ID: pqm@pqm.ubuntu.com-20100511114736-mc1sq9zyo3vufec7
(lifeless) Provide a consistent interface to Tree, Branch,
 Repository where lock methods return an object with an unlock method to
 unlock the lock. This breaks the API for Branch,
 Repository on their lock_write methods. (Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/revisionspec.py
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
 
 
18
import re
 
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,
 
29
    registry,
26
30
    revision,
27
31
    symbol_versioning,
28
 
    workingtree,
29
 
    )
30
 
""")
31
 
 
32
 
from bzrlib import (
33
 
    errors,
34
 
    lazy_regex,
35
 
    registry,
36
32
    trace,
37
33
    )
38
34
 
117
113
        return RevisionInfo(branch, revno, revision_id)
118
114
 
119
115
 
 
116
_revno_regex = None
 
117
 
 
118
 
120
119
class RevisionSpec(object):
121
120
    """A parsed revision specification."""
122
121
 
167
166
                         spectype.__name__, spec)
168
167
            return spectype(spec, _internal=True)
169
168
        else:
 
169
            for spectype in SPEC_TYPES:
 
170
                if spec.startswith(spectype.prefix):
 
171
                    trace.mutter('Returning RevisionSpec %s for %s',
 
172
                                 spectype.__name__, spec)
 
173
                    return spectype(spec, _internal=True)
170
174
            # Otherwise treat it as a DWIM, build the RevisionSpec object and
171
175
            # wait for _match_on to be called.
172
176
            return RevisionSpec_dwim(spec, _internal=True)
298
302
    # each revspec we try.
299
303
    wants_revision_history = False
300
304
 
301
 
    _revno_regex = lazy_regex.lazy_compile(r'^(?:(\d+(\.\d+)*)|-\d+)(:.*)?$')
302
 
 
303
 
    # The revspecs to try
304
 
    _possible_revspecs = []
305
 
 
306
305
    def _try_spectype(self, rstype, branch):
307
306
        rs = rstype(self.spec, _internal=True)
308
307
        # Hit in_history to find out if it exists, or we need to try the
313
312
        """Run the lookup and see what we can get."""
314
313
 
315
314
        # First, see if it's a revno
316
 
        if self._revno_regex.match(self.spec) is not None:
 
315
        global _revno_regex
 
316
        if _revno_regex is None:
 
317
            _revno_regex = re.compile(r'^(?:(\d+(\.\d+)*)|-\d+)(:.*)?$')
 
318
        if _revno_regex.match(self.spec) is not None:
317
319
            try:
318
320
                return self._try_spectype(RevisionSpec_revno, branch)
319
321
            except RevisionSpec_revno.dwim_catchable_exceptions:
320
322
                pass
321
323
 
322
324
        # 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
325
        for rs_class in dwim_revspecs:
332
326
            try:
333
327
                return self._try_spectype(rs_class, branch)
339
333
        # really relevant.
340
334
        raise errors.InvalidRevisionSpec(self.spec, branch)
341
335
 
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
336
 
361
337
class RevisionSpec_revno(RevisionSpec):
362
338
    """Selects a revision using a number."""
468
444
 
469
445
 
470
446
 
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):
 
447
class RevisionSpec_revid(RevisionSpec):
479
448
    """Selects a revision using the revision id."""
480
449
 
481
450
    help_txt = """Selects a revision using the revision id.
490
459
 
491
460
    prefix = 'revid:'
492
461
 
493
 
    def _as_revision_id(self, context_branch):
 
462
    def _match_on(self, branch, revs):
494
463
        # self.spec comes straight from parsing the command line arguments,
495
464
        # so we expect it to be a Unicode string. Switch it to the internal
496
465
        # representation.
 
466
        revision_id = osutils.safe_revision_id(self.spec, warn=False)
 
467
        return RevisionInfo.from_revision_id(branch, revision_id, revs)
 
468
 
 
469
    def _as_revision_id(self, context_branch):
497
470
        return osutils.safe_revision_id(self.spec, warn=False)
498
471
 
499
472
 
685
658
                                   August 14th, 2006 at 5:10pm.
686
659
    """
687
660
    prefix = 'date:'
688
 
    _date_regex = lazy_regex.lazy_compile(
 
661
    _date_re = re.compile(
689
662
            r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
690
663
            r'(,|T)?\s*'
691
664
            r'(?P<time>(?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d))?)?'
709
682
        elif self.spec.lower() == 'tomorrow':
710
683
            dt = today + datetime.timedelta(days=1)
711
684
        else:
712
 
            m = self._date_regex.match(self.spec)
 
685
            m = self._date_re.match(self.spec)
713
686
            if not m or (not m.group('date') and not m.group('time')):
714
687
                raise errors.InvalidRevisionSpec(self.user_spec,
715
688
                                                 branch, 'invalid date')
840
813
        revision_b = other_branch.last_revision()
841
814
        if revision_b in (None, revision.NULL_REVISION):
842
815
            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
 
816
        # pull in the remote revisions so we can diff
 
817
        branch.fetch(other_branch, revision_b)
851
818
        try:
852
819
            revno = branch.revision_id_to_revno(revision_b)
853
820
        except errors.NoSuchRevision:
873
840
            raise errors.NoCommits(other_branch)
874
841
        return other_branch.repository.revision_tree(last_revision)
875
842
 
876
 
    def needs_branch(self):
877
 
        return False
878
 
 
879
 
    def get_branch(self):
880
 
        return self.spec
881
 
 
882
843
 
883
844
 
884
845
class RevisionSpec_submit(RevisionSpec_ancestor):
923
884
            self._get_submit_location(context_branch))
924
885
 
925
886
 
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
887
# The order in which we want to DWIM a revision spec without any prefix.
994
888
# revno is always tried first and isn't listed here, this is used by
995
889
# RevisionSpec_dwim._match_on
996
 
dwim_revspecs = symbol_versioning.deprecated_list(
997
 
    symbol_versioning.deprecated_in((2, 4, 0)), "dwim_revspecs", [])
 
890
dwim_revspecs = [
 
891
    RevisionSpec_tag, # Let's try for a tag
 
892
    RevisionSpec_revid, # Maybe it's a revid?
 
893
    RevisionSpec_date, # Perhaps a date?
 
894
    RevisionSpec_branch, # OK, last try, maybe it's a branch
 
895
    ]
998
896
 
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
897
 
1004
898
revspec_registry = registry.Registry()
1005
899
def _register_revspec(revspec):
1014
908
_register_revspec(RevisionSpec_ancestor)
1015
909
_register_revspec(RevisionSpec_branch)
1016
910
_register_revspec(RevisionSpec_submit)
1017
 
_register_revspec(RevisionSpec_annotate)
1018
 
_register_revspec(RevisionSpec_mainline)
 
911
 
 
912
# classes in this list should have a "prefix" attribute, against which
 
913
# string specs are matched
 
914
SPEC_TYPES = symbol_versioning.deprecated_list(
 
915
    symbol_versioning.deprecated_in((1, 12, 0)), "SPEC_TYPES", [])