← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/revisionspec.py

  • Committer: Vincent Ladeuil
  • Date: 2009-01-30 00:49:41 UTC
  • mto: (3982.1.1 bzr.integration)
  • mto: This revision was merged to the branch mainline in revision 3983.
  • Revision ID: v.ladeuil+lp@free.fr-20090130004941-820fpd2ryyo127vv
Add more tests, fix pycurl double handling, revert previous tracking.

* bzrlib/tests/test_http.py:
(PredefinedRequestHandler): Renamed from
PreRecordedRequestHandler.
(PredefinedRequestHandler.handle_one_request): Get the canned
response from the test server directly.
(ActivityServerMixin): Make it a true object and intialize the
attributes in the constructor. Tests can now set the
canned_response attribute before querying the server.
(TestActivity.setUp, TestActivity.tearDown,
TestActivity.get_transport, TestActivity.assertActivitiesMatch):
Extracted from test_get to be able to write other tests.
(TestActivity.test_has, TestActivity.test_readv,
TestActivity.test_post): New tests, all cases should be covered
now.

* bzrlib/transport/http/response.py:
(RangeFile.__init__, RangeFile.read, handle_response): Revert
previous tracking, both http implementations can now report
activity from the socket.

* bzrlib/transport/http/_pycurl.py:
(PyCurlTransport._get_ranged, PyCurlTransport._post): Revert
previous tracking.

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
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
 
18
18
import re
26
26
from bzrlib import (
27
27
    errors,
28
28
    osutils,
29
 
    registry,
30
29
    revision,
31
30
    symbol_versioning,
32
31
    trace,
113
112
        return RevisionInfo(branch, revno, revision_id)
114
113
 
115
114
 
 
115
# classes in this list should have a "prefix" attribute, against which
 
116
# string specs are matched
 
117
SPEC_TYPES = []
116
118
_revno_regex = None
117
119
 
118
120
 
121
123
 
122
124
    help_txt = """A parsed revision specification.
123
125
 
124
 
    A revision specification is a string, which may be unambiguous about
125
 
    what it represents by giving a prefix like 'date:' or 'revid:' etc,
126
 
    or it may have no prefix, in which case it's tried against several
127
 
    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.
128
130
 
129
131
    Revision specs are an UI element, and they have been moved out
130
132
    of the branch class to leave "back-end" classes unaware of such
137
139
 
138
140
    prefix = None
139
141
    wants_revision_history = True
140
 
    dwim_catchable_exceptions = (errors.InvalidRevisionSpec,)
141
 
    """Exceptions that RevisionSpec_dwim._match_on will catch.
142
 
 
143
 
    If the revspec is part of ``dwim_revspecs``, it may be tried with an
144
 
    invalid revspec and raises some exception. The exceptions mentioned here
145
 
    will not be reported to the user but simply ignored without stopping the
146
 
    dwim processing.
147
 
    """
148
142
 
149
143
    @staticmethod
150
144
    def from_string(spec):
159
153
 
160
154
        if spec is None:
161
155
            return RevisionSpec(None, _internal=True)
162
 
        match = revspec_registry.get_prefix(spec)
163
 
        if match is not None:
164
 
            spectype, specsuffix = match
165
 
            trace.mutter('Returning RevisionSpec %s for %s',
166
 
                         spectype.__name__, spec)
167
 
            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)
168
161
        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)
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)
 
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)
177
173
 
178
174
    def __init__(self, spec, _internal=False):
179
175
        """Create a RevisionSpec referring to the Null revision.
183
179
            called directly. Only from RevisionSpec.from_string()
184
180
        """
185
181
        if not _internal:
 
182
            # XXX: Update this after 0.10 is released
186
183
            symbol_versioning.warn('Creating a RevisionSpec directly has'
187
184
                                   ' been deprecated in version 0.11. Use'
188
185
                                   ' RevisionSpec.from_string()'
270
267
        # this is mostly for helping with testing
271
268
        return '<%s %s>' % (self.__class__.__name__,
272
269
                              self.user_spec)
273
 
 
 
270
    
274
271
    def needs_branch(self):
275
272
        """Whether this revision spec needs a branch.
276
273
 
280
277
 
281
278
    def get_branch(self):
282
279
        """When the revision specifier contains a branch location, return it.
283
 
 
 
280
        
284
281
        Otherwise, return None.
285
282
        """
286
283
        return None
288
285
 
289
286
# private API
290
287
 
291
 
class RevisionSpec_dwim(RevisionSpec):
292
 
    """Provides a DWIMish revision specifier lookup.
293
 
 
294
 
    Note that this does not go in the revspec_registry because by definition
295
 
    there is no prefix to identify it.  It's solely called from
296
 
    RevisionSpec.from_string() because the DWIMification happen when _match_on
297
 
    is called so the string describing the revision is kept here until needed.
298
 
    """
299
 
 
300
 
    help_txt = None
301
 
    # We don't need to build the revision history ourself, that's delegated to
302
 
    # each revspec we try.
303
 
    wants_revision_history = False
304
 
 
305
 
    def _try_spectype(self, rstype, branch):
306
 
        rs = rstype(self.spec, _internal=True)
307
 
        # Hit in_history to find out if it exists, or we need to try the
308
 
        # next type.
309
 
        return rs.in_history(branch)
310
 
 
311
 
    def _match_on(self, branch, revs):
312
 
        """Run the lookup and see what we can get."""
313
 
 
314
 
        # First, see if it's a revno
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:
319
 
            try:
320
 
                return self._try_spectype(RevisionSpec_revno, branch)
321
 
            except RevisionSpec_revno.dwim_catchable_exceptions:
322
 
                pass
323
 
 
324
 
        # Next see what has been registered
325
 
        for rs_class in dwim_revspecs:
326
 
            try:
327
 
                return self._try_spectype(rs_class, branch)
328
 
            except rs_class.dwim_catchable_exceptions:
329
 
                pass
330
 
 
331
 
        # Well, I dunno what it is. Note that we don't try to keep track of the
332
 
        # first of last exception raised during the DWIM tries as none seems
333
 
        # really relevant.
334
 
        raise errors.InvalidRevisionSpec(self.spec, branch)
335
 
 
336
 
 
337
288
class RevisionSpec_revno(RevisionSpec):
338
289
    """Selects a revision using a number."""
339
290
 
340
291
    help_txt = """Selects a revision using a number.
341
292
 
342
293
    Use an integer to specify a revision in the history of the branch.
343
 
    Optionally a branch can be specified.  A negative number will count
344
 
    from the end of the branch (-1 is the last revision, -2 the previous
345
 
    one). If the negative number is larger than the branch's history, the
346
 
    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.
347
298
    Examples::
348
299
 
349
300
      revno:1                   -> return the first revision of this branch
383
334
                dotted = False
384
335
            except ValueError:
385
336
                # dotted decimal. This arguably should not be here
386
 
                # but the from_string method is a little primitive
 
337
                # but the from_string method is a little primitive 
387
338
                # right now - RBC 20060928
388
339
                try:
389
340
                    match_revno = tuple((int(number) for number in revno_spec.split('.')))
439
390
        else:
440
391
            return self.spec[self.spec.find(':')+1:]
441
392
 
442
 
# Old compatibility
 
393
# Old compatibility 
443
394
RevisionSpec_int = RevisionSpec_revno
444
395
 
 
396
SPEC_TYPES.append(RevisionSpec_revno)
445
397
 
446
398
 
447
399
class RevisionSpec_revid(RevisionSpec):
450
402
    help_txt = """Selects a revision using the revision id.
451
403
 
452
404
    Supply a specific revision id, that can be used to specify any
453
 
    revision id in the ancestry of the branch.
 
405
    revision id in the ancestry of the branch. 
454
406
    Including merges, and pending merges.
455
407
    Examples::
456
408
 
469
421
    def _as_revision_id(self, context_branch):
470
422
        return osutils.safe_revision_id(self.spec, warn=False)
471
423
 
 
424
SPEC_TYPES.append(RevisionSpec_revid)
472
425
 
473
426
 
474
427
class RevisionSpec_last(RevisionSpec):
520
473
        revno, revision_id = self._revno_and_revision_id(context_branch, None)
521
474
        return revision_id
522
475
 
 
476
SPEC_TYPES.append(RevisionSpec_last)
523
477
 
524
478
 
525
479
class RevisionSpec_before(RevisionSpec):
545
499
    """
546
500
 
547
501
    prefix = 'before:'
548
 
 
 
502
    
549
503
    def _match_on(self, branch, revs):
550
504
        r = RevisionSpec.from_string(self.spec)._match_on(branch, revs)
551
505
        if r.revno == 0:
594
548
                'No parents for revision.')
595
549
        return parents[0]
596
550
 
 
551
SPEC_TYPES.append(RevisionSpec_before)
597
552
 
598
553
 
599
554
class RevisionSpec_tag(RevisionSpec):
605
560
    """
606
561
 
607
562
    prefix = 'tag:'
608
 
    dwim_catchable_exceptions = (errors.NoSuchTag, errors.TagsNotSupported)
609
563
 
610
564
    def _match_on(self, branch, revs):
611
565
        # Can raise tags not supported, NoSuchTag, etc
616
570
    def _as_revision_id(self, context_branch):
617
571
        return context_branch.tags.lookup_tag(self.spec)
618
572
 
 
573
SPEC_TYPES.append(RevisionSpec_tag)
619
574
 
620
575
 
621
576
class _RevListToTimestamps(object):
656
611
      date:yesterday            -> select the first revision since yesterday
657
612
      date:2006-08-14,17:10:14  -> select the first revision after
658
613
                                   August 14th, 2006 at 5:10pm.
659
 
    """
 
614
    """    
660
615
    prefix = 'date:'
661
616
    _date_re = re.compile(
662
617
            r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
722
677
        else:
723
678
            return RevisionInfo(branch, rev + 1)
724
679
 
 
680
SPEC_TYPES.append(RevisionSpec_date)
725
681
 
726
682
 
727
683
class RevisionSpec_ancestor(RevisionSpec):
772
728
            revision_a = revision.ensure_null(branch.last_revision())
773
729
            if revision_a == revision.NULL_REVISION:
774
730
                raise errors.NoCommits(branch)
775
 
            if other_location == '':
776
 
                other_location = branch.get_parent()
777
731
            other_branch = Branch.open(other_location)
778
732
            other_branch.lock_read()
779
733
            try:
791
745
            branch.unlock()
792
746
 
793
747
 
 
748
SPEC_TYPES.append(RevisionSpec_ancestor)
794
749
 
795
750
 
796
751
class RevisionSpec_branch(RevisionSpec):
805
760
      branch:/path/to/branch
806
761
    """
807
762
    prefix = 'branch:'
808
 
    dwim_catchable_exceptions = (errors.NotBranchError,)
809
763
 
810
764
    def _match_on(self, branch, revs):
811
765
        from bzrlib.branch import Branch
840
794
            raise errors.NoCommits(other_branch)
841
795
        return other_branch.repository.revision_tree(last_revision)
842
796
 
 
797
SPEC_TYPES.append(RevisionSpec_branch)
843
798
 
844
799
 
845
800
class RevisionSpec_submit(RevisionSpec_ancestor):
884
839
            self._get_submit_location(context_branch))
885
840
 
886
841
 
887
 
# The order in which we want to DWIM a revision spec without any prefix.
888
 
# revno is always tried first and isn't listed here, this is used by
889
 
# RevisionSpec_dwim._match_on
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
 
    ]
896
 
 
897
 
 
898
 
revspec_registry = registry.Registry()
899
 
def _register_revspec(revspec):
900
 
    revspec_registry.register(revspec.prefix, revspec)
901
 
 
902
 
_register_revspec(RevisionSpec_revno)
903
 
_register_revspec(RevisionSpec_revid)
904
 
_register_revspec(RevisionSpec_last)
905
 
_register_revspec(RevisionSpec_before)
906
 
_register_revspec(RevisionSpec_tag)
907
 
_register_revspec(RevisionSpec_date)
908
 
_register_revspec(RevisionSpec_ancestor)
909
 
_register_revspec(RevisionSpec_branch)
910
 
_register_revspec(RevisionSpec_submit)
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", [])
 
842
SPEC_TYPES.append(RevisionSpec_submit)