← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/revisionspec.py

  • Committer: Robert Collins
  • Date: 2005-10-19 11:54:59 UTC
  • mfrom: (1464.1.1)
  • Revision ID: robertc@robertcollins.net-20051019115459-a850274afcf87734
merge from Martin, via newformat, and teach sftp about urlescaped paths

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/revisionspec.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
2
 
#
 
1
# Copyright (C) 2005 Canonical Ltd
 
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
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
#
 
7
 
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
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
 
from __future__ import absolute_import
18
 
 
19
 
 
20
 
from bzrlib.lazy_import import lazy_import
21
 
lazy_import(globals(), """
22
 
import bisect
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
 
23
18
import datetime
24
 
 
25
 
from bzrlib import (
26
 
    branch as _mod_branch,
27
 
    osutils,
28
 
    revision,
29
 
    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
 
    trace,
40
 
    )
41
 
 
 
19
import re
 
20
from bzrlib.errors import BzrError, NoSuchRevision, NoCommits
 
21
 
 
22
_marker = []
42
23
 
43
24
class RevisionInfo(object):
44
 
    """The results of applying a revision specification to a branch."""
45
 
 
46
 
    help_txt = """The results of applying a revision specification to a branch.
 
25
    """The results of applying a revision specification to a branch.
47
26
 
48
27
    An instance has two useful attributes: revno, and rev_id.
49
28
 
57
36
    or treat the result as a tuple.
58
37
    """
59
38
 
60
 
    def __init__(self, branch, revno=None, rev_id=None):
 
39
    def __init__(self, branch, revno, rev_id=_marker):
61
40
        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:
 
41
        self.revno = revno
 
42
        if rev_id is _marker:
66
43
            # 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
 
44
            if self.revno is None:
 
45
                self.rev_id = None
 
46
            else:
 
47
                self.rev_id = branch.get_rev_id(self.revno)
 
48
        else:
 
49
            self.rev_id = rev_id
78
50
 
79
51
    def __nonzero__(self):
 
52
        # first the easy ones...
80
53
        if self.rev_id is None:
81
54
            return False
 
55
        if self.revno is not None:
 
56
            return True
82
57
        # TODO: otherwise, it should depend on how I was built -
83
58
        # if it's in_history(branch), then check revision_history(),
84
59
        # if it's in_store(branch), do the check below
85
 
        return self.branch.repository.has_revision(self.rev_id)
 
60
        return self.branch.revision_store.has_id(self.rev_id)
86
61
 
87
62
    def __len__(self):
88
63
        return 2
93
68
        raise IndexError(index)
94
69
 
95
70
    def get(self):
96
 
        return self.branch.repository.get_revision(self.rev_id)
 
71
        return self.branch.get_revision(self.rev_id)
97
72
 
98
73
    def __eq__(self, other):
99
74
        if type(other) not in (tuple, list, type(self)):
106
81
        return '<bzrlib.revisionspec.RevisionInfo object %s, %s for %r>' % (
107
82
            self.revno, self.rev_id, self.branch)
108
83
 
109
 
    @staticmethod
110
 
    def from_revision_id(branch, revision_id, revs=symbol_versioning.DEPRECATED_PARAMETER):
111
 
        """Construct a RevisionInfo given just the id.
112
 
 
113
 
        Use this if you don't know or care what the revno is.
114
 
        """
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)
121
 
 
 
84
# classes in this list should have a "prefix" attribute, against which
 
85
# string specs are matched
 
86
SPEC_TYPES = []
122
87
 
123
88
class RevisionSpec(object):
124
 
    """A parsed revision specification."""
125
 
 
126
 
    help_txt = """A parsed revision specification.
127
 
 
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.
 
89
    """A parsed revision specification.
 
90
 
 
91
    A revision specification can be an integer, in which case it is
 
92
    assumed to be a revno (though this will translate negative values
 
93
    into positive ones); or it can be a string, in which case it is
 
94
    parsed for something like 'date:' or 'revid:' etc.
132
95
 
133
96
    Revision specs are an UI element, and they have been moved out
134
97
    of the branch class to leave "back-end" classes unaware of such
140
103
    """
141
104
 
142
105
    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
 
    """
153
 
 
154
 
    @staticmethod
155
 
    def from_string(spec):
156
 
        """Parse a revision spec string into a RevisionSpec object.
157
 
 
158
 
        :param spec: A string specified by the user
159
 
        :return: A RevisionSpec object that understands how to parse the
160
 
            supplied notation.
 
106
 
 
107
    def __new__(cls, spec, foo=_marker):
 
108
        """Parse a revision specifier.
161
109
        """
162
 
        if not isinstance(spec, (type(None), basestring)):
163
 
            raise TypeError('error')
164
 
 
165
110
        if spec is None:
166
 
            return RevisionSpec(None, _internal=True)
167
 
        match = revspec_registry.get_prefix(spec)
168
 
        if match is not None:
169
 
            spectype, specsuffix = match
170
 
            trace.mutter('Returning RevisionSpec %s for %s',
171
 
                         spectype.__name__, spec)
172
 
            return spectype(spec, _internal=True)
 
111
            return object.__new__(RevisionSpec, spec)
 
112
 
 
113
        try:
 
114
            spec = int(spec)
 
115
        except ValueError:
 
116
            pass
 
117
 
 
118
        if isinstance(spec, int):
 
119
            return object.__new__(RevisionSpec_int, spec)
 
120
        elif isinstance(spec, basestring):
 
121
            for spectype in SPEC_TYPES:
 
122
                if spec.startswith(spectype.prefix):
 
123
                    return object.__new__(spectype, spec)
 
124
            else:
 
125
                raise BzrError('No namespace registered for string: %r' %
 
126
                               spec)
173
127
        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)
177
 
 
178
 
    def __init__(self, spec, _internal=False):
179
 
        """Create a RevisionSpec referring to the Null revision.
180
 
 
181
 
        :param spec: The original spec supplied by the user
182
 
        :param _internal: Used to ensure that RevisionSpec is not being
183
 
            called directly. Only from RevisionSpec.from_string()
184
 
        """
185
 
        if not _internal:
186
 
            symbol_versioning.warn('Creating a RevisionSpec directly has'
187
 
                                   ' been deprecated in version 0.11. Use'
188
 
                                   ' RevisionSpec.from_string()'
189
 
                                   ' instead.',
190
 
                                   DeprecationWarning, stacklevel=2)
191
 
        self.user_spec = spec
 
128
            raise TypeError('Unhandled revision type %s' % spec)
 
129
 
 
130
    def __init__(self, spec):
192
131
        if self.prefix and spec.startswith(self.prefix):
193
132
            spec = spec[len(self.prefix):]
194
133
        self.spec = spec
195
134
 
196
135
    def _match_on(self, branch, revs):
197
 
        trace.mutter('Returning RevisionSpec._match_on: None')
198
 
        return RevisionInfo(branch, None, None)
 
136
        return RevisionInfo(branch, 0, None)
199
137
 
200
138
    def _match_on_and_check(self, branch, revs):
201
139
        info = self._match_on(branch, revs)
202
140
        if info:
203
141
            return info
204
 
        elif info == (None, None):
205
 
            # special case - nothing supplied
 
142
        elif info == (0, None):
 
143
            # special case - the empty tree
206
144
            return info
207
145
        elif self.prefix:
208
 
            raise errors.InvalidRevisionSpec(self.user_spec, branch)
 
146
            raise NoSuchRevision(branch, self.prefix + str(self.spec))
209
147
        else:
210
 
            raise errors.InvalidRevisionSpec(self.spec, branch)
 
148
            raise NoSuchRevision(branch, str(self.spec))
211
149
 
212
150
    def in_history(self, branch):
213
 
        if branch:
214
 
            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()
227
 
            else:
228
 
                revs = None
229
 
        else:
230
 
            # this should never trigger.
231
 
            # TODO: make it a deprecated code path. RBC 20060928
232
 
            revs = None
 
151
        revs = branch.revision_history()
233
152
        return self._match_on_and_check(branch, revs)
234
153
 
235
154
        # FIXME: in_history is somewhat broken,
241
160
    # will do what you expect.
242
161
    in_store = in_history
243
162
    in_branch = in_store
244
 
 
245
 
    def as_revision_id(self, context_branch):
246
 
        """Return just the revision_id for this revisions spec.
247
 
 
248
 
        Some revision specs require a context_branch to be able to determine
249
 
        their value. Not all specs will make use of it.
250
 
        """
251
 
        return self._as_revision_id(context_branch)
252
 
 
253
 
    def _as_revision_id(self, context_branch):
254
 
        """Implementation of as_revision_id()
255
 
 
256
 
        Classes should override this function to provide appropriate
257
 
        functionality. The default is to just call '.in_history().rev_id'
258
 
        """
259
 
        return self.in_history(context_branch).rev_id
260
 
 
261
 
    def as_tree(self, context_branch):
262
 
        """Return the tree object for this revisions spec.
263
 
 
264
 
        Some revision specs require a context_branch to be able to determine
265
 
        the revision id and access the repository. Not all specs will make
266
 
        use of it.
267
 
        """
268
 
        return self._as_tree(context_branch)
269
 
 
270
 
    def _as_tree(self, context_branch):
271
 
        """Implementation of as_tree().
272
 
 
273
 
        Classes should override this function to provide appropriate
274
 
        functionality. The default is to just call '.as_revision_id()'
275
 
        and get the revision tree from context_branch's repository.
276
 
        """
277
 
        revision_id = self.as_revision_id(context_branch)
278
 
        return context_branch.repository.revision_tree(revision_id)
279
 
 
 
163
        
280
164
    def __repr__(self):
281
165
        # this is mostly for helping with testing
282
 
        return '<%s %s>' % (self.__class__.__name__,
283
 
                              self.user_spec)
284
 
 
285
 
    def needs_branch(self):
286
 
        """Whether this revision spec needs a branch.
287
 
 
288
 
        Set this to False the branch argument of _match_on is not used.
289
 
        """
290
 
        return True
291
 
 
292
 
    def get_branch(self):
293
 
        """When the revision specifier contains a branch location, return it.
294
 
 
295
 
        Otherwise, return None.
296
 
        """
297
 
        return None
 
166
        return '<%s %s%s>' % (self.__class__.__name__,
 
167
                              self.prefix or '',
 
168
                              self.spec)
298
169
 
299
170
 
300
171
# private API
301
172
 
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)
 
173
class RevisionSpec_int(RevisionSpec):
 
174
    """Spec is a number.  Special case."""
 
175
    def __init__(self, spec):
 
176
        self.spec = int(spec)
323
177
 
324
178
    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))
 
179
        if self.spec < 0:
 
180
            revno = len(revs) + self.spec + 1
 
181
        else:
 
182
            revno = self.spec
 
183
        rev_id = branch.get_rev_id(revno, revs)
 
184
        return RevisionInfo(branch, revno, rev_id)
371
185
 
372
186
 
373
187
class RevisionSpec_revno(RevisionSpec):
374
 
    """Selects a revision using a number."""
375
 
 
376
 
    help_txt = """Selects a revision using a number.
377
 
 
378
 
    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.
383
 
    Examples::
384
 
 
385
 
      revno:1                   -> return the first revision of this branch
386
 
      revno:3:/path/to/branch   -> return the 3rd revision of
387
 
                                   the branch '/path/to/branch'
388
 
      revno:-1                  -> The last revision in a branch.
389
 
      -2:http://other/branch    -> The second to last revision in the
390
 
                                   remote branch.
391
 
      -1000000                  -> Most likely the first revision, unless
392
 
                                   your history is very long.
393
 
    """
394
188
    prefix = 'revno:'
395
189
 
396
190
    def _match_on(self, branch, revs):
397
191
        """Lookup a revision by revision number"""
398
 
        branch, revno, revision_id = self._lookup(branch)
399
 
        return RevisionInfo(branch, revno, revision_id)
400
 
 
401
 
    def _lookup(self, branch):
402
 
        loc = self.spec.find(':')
403
 
        if loc == -1:
404
 
            revno_spec = self.spec
405
 
            branch_spec = None
406
 
        else:
407
 
            revno_spec = self.spec[:loc]
408
 
            branch_spec = self.spec[loc+1:]
409
 
 
410
 
        if revno_spec == '':
411
 
            if not branch_spec:
412
 
                raise errors.InvalidRevisionSpec(self.user_spec,
413
 
                        branch, 'cannot have an empty revno and no branch')
414
 
            revno = None
415
 
        else:
416
 
            try:
417
 
                revno = int(revno_spec)
418
 
                dotted = False
419
 
            except ValueError:
420
 
                # dotted decimal. This arguably should not be here
421
 
                # but the from_string method is a little primitive
422
 
                # right now - RBC 20060928
423
 
                try:
424
 
                    match_revno = tuple((int(number) for number in revno_spec.split('.')))
425
 
                except ValueError, e:
426
 
                    raise errors.InvalidRevisionSpec(self.user_spec, branch, e)
427
 
 
428
 
                dotted = True
429
 
 
430
 
        if branch_spec:
431
 
            # the user has overriden the branch to look in.
432
 
            branch = _mod_branch.Branch.open(branch_spec)
433
 
 
434
 
        if dotted:
435
 
            try:
436
 
                revision_id = branch.dotted_revno_to_revision_id(match_revno,
437
 
                    _cache_reverse=True)
438
 
            except errors.NoSuchRevision:
439
 
                raise errors.InvalidRevisionSpec(self.user_spec, branch)
440
 
            else:
441
 
                # there is no traditional 'revno' for dotted-decimal revnos.
442
 
                # so for API compatibility we return None.
443
 
                return branch, None, revision_id
444
 
        else:
445
 
            last_revno, last_revision_id = branch.last_revision_info()
446
 
            if revno < 0:
447
 
                # if get_rev_id supported negative revnos, there would not be a
448
 
                # need for this special case.
449
 
                if (-revno) >= last_revno:
450
 
                    revno = 1
451
 
                else:
452
 
                    revno = last_revno + revno + 1
453
 
            try:
454
 
                revision_id = branch.get_rev_id(revno)
455
 
            except errors.NoSuchRevision:
456
 
                raise errors.InvalidRevisionSpec(self.user_spec, branch)
457
 
        return branch, revno, revision_id
458
 
 
459
 
    def _as_revision_id(self, context_branch):
460
 
        # We would have the revno here, but we don't really care
461
 
        branch, revno, revision_id = self._lookup(context_branch)
462
 
        return revision_id
463
 
 
464
 
    def needs_branch(self):
465
 
        return self.spec.find(':') == -1
466
 
 
467
 
    def get_branch(self):
468
 
        if self.spec.find(':') == -1:
469
 
            return None
470
 
        else:
471
 
            return self.spec[self.spec.find(':')+1:]
472
 
 
473
 
# Old compatibility
474
 
RevisionSpec_int = RevisionSpec_revno
475
 
 
476
 
 
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):
485
 
    """Selects a revision using the revision id."""
486
 
 
487
 
    help_txt = """Selects a revision using the revision id.
488
 
 
489
 
    Supply a specific revision id, that can be used to specify any
490
 
    revision id in the ancestry of the branch.
491
 
    Including merges, and pending merges.
492
 
    Examples::
493
 
 
494
 
      revid:aaaa@bbbb-123456789 -> Select revision 'aaaa@bbbb-123456789'
495
 
    """
496
 
 
 
192
        try:
 
193
            return RevisionInfo(branch, int(self.spec))
 
194
        except ValueError:
 
195
            return RevisionInfo(branch, None)
 
196
 
 
197
SPEC_TYPES.append(RevisionSpec_revno)
 
198
 
 
199
 
 
200
class RevisionSpec_revid(RevisionSpec):
497
201
    prefix = 'revid:'
498
202
 
499
 
    def _as_revision_id(self, context_branch):
500
 
        # self.spec comes straight from parsing the command line arguments,
501
 
        # so we expect it to be a Unicode string. Switch it to the internal
502
 
        # representation.
503
 
        return osutils.safe_revision_id(self.spec, warn=False)
 
203
    def _match_on(self, branch, revs):
 
204
        try:
 
205
            return RevisionInfo(branch, revs.index(self.spec) + 1, self.spec)
 
206
        except ValueError:
 
207
            return RevisionInfo(branch, None)
504
208
 
 
209
SPEC_TYPES.append(RevisionSpec_revid)
505
210
 
506
211
 
507
212
class RevisionSpec_last(RevisionSpec):
508
 
    """Selects the nth revision from the end."""
509
 
 
510
 
    help_txt = """Selects the nth revision from the end.
511
 
 
512
 
    Supply a positive number to get the nth revision from the end.
513
 
    This is the same as supplying negative numbers to the 'revno:' spec.
514
 
    Examples::
515
 
 
516
 
      last:1        -> return the last revision
517
 
      last:3        -> return the revision 2 before the end.
518
 
    """
519
213
 
520
214
    prefix = 'last:'
521
215
 
522
216
    def _match_on(self, branch, revs):
523
 
        revno, revision_id = self._revno_and_revision_id(branch)
524
 
        return RevisionInfo(branch, revno, revision_id)
525
 
 
526
 
    def _revno_and_revision_id(self, context_branch):
527
 
        last_revno, last_revision_id = context_branch.last_revision_info()
528
 
 
529
 
        if self.spec == '':
530
 
            if not last_revno:
531
 
                raise errors.NoCommits(context_branch)
532
 
            return last_revno, last_revision_id
533
 
 
534
217
        try:
535
218
            offset = int(self.spec)
536
 
        except ValueError, e:
537
 
            raise errors.InvalidRevisionSpec(self.user_spec, context_branch, e)
538
 
 
539
 
        if offset <= 0:
540
 
            raise errors.InvalidRevisionSpec(self.user_spec, context_branch,
541
 
                                             'you must supply a positive value')
542
 
 
543
 
        revno = last_revno - offset + 1
544
 
        try:
545
 
            revision_id = context_branch.get_rev_id(revno)
546
 
        except errors.NoSuchRevision:
547
 
            raise errors.InvalidRevisionSpec(self.user_spec, context_branch)
548
 
        return revno, revision_id
549
 
 
550
 
    def _as_revision_id(self, context_branch):
551
 
        # We compute the revno as part of the process, but we don't really care
552
 
        # about it.
553
 
        revno, revision_id = self._revno_and_revision_id(context_branch)
554
 
        return revision_id
555
 
 
 
219
        except ValueError:
 
220
            return RevisionInfo(branch, None)
 
221
        else:
 
222
            if offset <= 0:
 
223
                raise BzrError('You must supply a positive value for --revision last:XXX')
 
224
            return RevisionInfo(branch, len(revs) - offset + 1)
 
225
 
 
226
SPEC_TYPES.append(RevisionSpec_last)
556
227
 
557
228
 
558
229
class RevisionSpec_before(RevisionSpec):
559
 
    """Selects the parent of the revision specified."""
560
 
 
561
 
    help_txt = """Selects the parent of the revision specified.
562
 
 
563
 
    Supply any revision spec to return the parent of that revision.  This is
564
 
    mostly useful when inspecting revisions that are not in the revision history
565
 
    of a branch.
566
 
 
567
 
    It is an error to request the parent of the null revision (before:0).
568
 
 
569
 
    Examples::
570
 
 
571
 
      before:1913    -> Return the parent of revno 1913 (revno 1912)
572
 
      before:revid:aaaa@bbbb-1234567890  -> return the parent of revision
573
 
                                            aaaa@bbbb-1234567890
574
 
      bzr diff -r before:1913..1913
575
 
            -> Find the changes between revision 1913 and its parent (1912).
576
 
               (What changes did revision 1913 introduce).
577
 
               This is equivalent to:  bzr diff -c 1913
578
 
    """
579
230
 
580
231
    prefix = 'before:'
581
 
 
 
232
    
582
233
    def _match_on(self, branch, revs):
583
 
        r = RevisionSpec.from_string(self.spec)._match_on(branch, revs)
584
 
        if r.revno == 0:
585
 
            raise errors.InvalidRevisionSpec(self.user_spec, branch,
586
 
                                         'cannot go before the null: revision')
587
 
        if r.revno is None:
588
 
            # We need to use the repository history here
589
 
            rev = branch.repository.get_revision(r.rev_id)
590
 
            if not rev.parent_ids:
591
 
                revision_id = revision.NULL_REVISION
592
 
            else:
593
 
                revision_id = rev.parent_ids[0]
594
 
            revno = None
595
 
        else:
596
 
            revno = r.revno - 1
597
 
            try:
598
 
                revision_id = branch.get_rev_id(revno, revs)
599
 
            except errors.NoSuchRevision:
600
 
                raise errors.InvalidRevisionSpec(self.user_spec,
601
 
                                                 branch)
602
 
        return RevisionInfo(branch, revno, revision_id)
603
 
 
604
 
    def _as_revision_id(self, context_branch):
605
 
        base_revision_id = RevisionSpec.from_string(self.spec)._as_revision_id(context_branch)
606
 
        if base_revision_id == revision.NULL_REVISION:
607
 
            raise errors.InvalidRevisionSpec(self.user_spec, context_branch,
608
 
                                         'cannot go before the null: revision')
609
 
        context_repo = context_branch.repository
610
 
        context_repo.lock_read()
611
 
        try:
612
 
            parent_map = context_repo.get_parent_map([base_revision_id])
613
 
        finally:
614
 
            context_repo.unlock()
615
 
        if base_revision_id not in parent_map:
616
 
            # Ghost, or unknown revision id
617
 
            raise errors.InvalidRevisionSpec(self.user_spec, context_branch,
618
 
                'cannot find the matching revision')
619
 
        parents = parent_map[base_revision_id]
620
 
        if len(parents) < 1:
621
 
            raise errors.InvalidRevisionSpec(self.user_spec, context_branch,
622
 
                'No parents for revision.')
623
 
        return parents[0]
624
 
 
 
234
        r = RevisionSpec(self.spec)._match_on(branch, revs)
 
235
        if (r.revno is None) or (r.revno == 0):
 
236
            return r
 
237
        return RevisionInfo(branch, r.revno - 1)
 
238
 
 
239
SPEC_TYPES.append(RevisionSpec_before)
625
240
 
626
241
 
627
242
class RevisionSpec_tag(RevisionSpec):
628
 
    """Select a revision identified by tag name"""
629
 
 
630
 
    help_txt = """Selects a revision identified by a tag name.
631
 
 
632
 
    Tags are stored in the branch and created by the 'tag' command.
633
 
    """
634
 
 
635
243
    prefix = 'tag:'
636
 
    dwim_catchable_exceptions = (errors.NoSuchTag, errors.TagsNotSupported)
637
244
 
638
245
    def _match_on(self, branch, revs):
639
 
        # Can raise tags not supported, NoSuchTag, etc
640
 
        return RevisionInfo.from_revision_id(branch,
641
 
            branch.tags.lookup_tag(self.spec))
642
 
 
643
 
    def _as_revision_id(self, context_branch):
644
 
        return context_branch.tags.lookup_tag(self.spec)
645
 
 
646
 
 
647
 
 
648
 
class _RevListToTimestamps(object):
649
 
    """This takes a list of revisions, and allows you to bisect by date"""
650
 
 
651
 
    __slots__ = ['branch']
652
 
 
653
 
    def __init__(self, branch):
654
 
        self.branch = branch
655
 
 
656
 
    def __getitem__(self, index):
657
 
        """Get the date of the index'd item"""
658
 
        r = self.branch.repository.get_revision(self.branch.get_rev_id(index))
659
 
        # TODO: Handle timezone.
660
 
        return datetime.datetime.fromtimestamp(r.timestamp)
661
 
 
662
 
    def __len__(self):
663
 
        return self.branch.revno()
 
246
        raise BzrError('tag: namespace registered, but not implemented.')
 
247
 
 
248
SPEC_TYPES.append(RevisionSpec_tag)
664
249
 
665
250
 
666
251
class RevisionSpec_date(RevisionSpec):
667
 
    """Selects a revision on the basis of a datestamp."""
668
 
 
669
 
    help_txt = """Selects a revision on the basis of a datestamp.
670
 
 
671
 
    Supply a datestamp to select the first revision that matches the date.
672
 
    Date can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
673
 
    Matches the first entry after a given date (either at midnight or
674
 
    at a specified time).
675
 
 
676
 
    One way to display all the changes since yesterday would be::
677
 
 
678
 
        bzr log -r date:yesterday..
679
 
 
680
 
    Examples::
681
 
 
682
 
      date:yesterday            -> select the first revision since yesterday
683
 
      date:2006-08-14,17:10:14  -> select the first revision after
684
 
                                   August 14th, 2006 at 5:10pm.
685
 
    """
686
252
    prefix = 'date:'
687
 
    _date_regex = lazy_regex.lazy_compile(
 
253
    _date_re = re.compile(
688
254
            r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
689
255
            r'(,|T)?\s*'
690
256
            r'(?P<time>(?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d))?)?'
691
257
        )
692
258
 
693
259
    def _match_on(self, branch, revs):
694
 
        """Spec for date revisions:
 
260
        """
 
261
        Spec for date revisions:
695
262
          date:value
696
263
          value can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
697
264
          matches the first entry after a given date (either at midnight or
698
265
          at a specified time).
 
266
 
 
267
          So the proper way of saying 'give me all entries for today' is:
 
268
              -r date:today..date:tomorrow
699
269
        """
700
 
        #  XXX: This doesn't actually work
701
 
        #  So the proper way of saying 'give me all entries for today' is:
702
 
        #      -r date:yesterday..date:today
703
270
        today = datetime.datetime.fromordinal(datetime.date.today().toordinal())
704
271
        if self.spec.lower() == 'yesterday':
705
272
            dt = today - datetime.timedelta(days=1)
708
275
        elif self.spec.lower() == 'tomorrow':
709
276
            dt = today + datetime.timedelta(days=1)
710
277
        else:
711
 
            m = self._date_regex.match(self.spec)
 
278
            m = self._date_re.match(self.spec)
712
279
            if not m or (not m.group('date') and not m.group('time')):
713
 
                raise errors.InvalidRevisionSpec(self.user_spec,
714
 
                                                 branch, 'invalid date')
715
 
 
716
 
            try:
717
 
                if m.group('date'):
718
 
                    year = int(m.group('year'))
719
 
                    month = int(m.group('month'))
720
 
                    day = int(m.group('day'))
721
 
                else:
722
 
                    year = today.year
723
 
                    month = today.month
724
 
                    day = today.day
725
 
 
726
 
                if m.group('time'):
727
 
                    hour = int(m.group('hour'))
728
 
                    minute = int(m.group('minute'))
729
 
                    if m.group('second'):
730
 
                        second = int(m.group('second'))
731
 
                    else:
732
 
                        second = 0
733
 
                else:
734
 
                    hour, minute, second = 0,0,0
735
 
            except ValueError:
736
 
                raise errors.InvalidRevisionSpec(self.user_spec,
737
 
                                                 branch, 'invalid date')
 
280
                raise BzrError('Invalid revision date %r' % self.spec)
 
281
 
 
282
            if m.group('date'):
 
283
                year, month, day = int(m.group('year')), int(m.group('month')), int(m.group('day'))
 
284
            else:
 
285
                year, month, day = today.year, today.month, today.day
 
286
            if m.group('time'):
 
287
                hour = int(m.group('hour'))
 
288
                minute = int(m.group('minute'))
 
289
                if m.group('second'):
 
290
                    second = int(m.group('second'))
 
291
                else:
 
292
                    second = 0
 
293
            else:
 
294
                hour, minute, second = 0,0,0
738
295
 
739
296
            dt = datetime.datetime(year=year, month=month, day=day,
740
297
                    hour=hour, minute=minute, second=second)
741
 
        branch.lock_read()
742
 
        try:
743
 
            rev = bisect.bisect(_RevListToTimestamps(branch), dt, 1)
744
 
        finally:
745
 
            branch.unlock()
746
 
        if rev == branch.revno():
747
 
            raise errors.InvalidRevisionSpec(self.user_spec, branch)
748
 
        return RevisionInfo(branch, rev)
 
298
        first = dt
 
299
        for i in range(len(revs)):
 
300
            r = branch.get_revision(revs[i])
 
301
            # TODO: Handle timezone.
 
302
            dt = datetime.datetime.fromtimestamp(r.timestamp)
 
303
            if first <= dt:
 
304
                return RevisionInfo(branch, i+1)
 
305
        return RevisionInfo(branch, None)
749
306
 
 
307
SPEC_TYPES.append(RevisionSpec_date)
750
308
 
751
309
 
752
310
class RevisionSpec_ancestor(RevisionSpec):
753
 
    """Selects a common ancestor with a second branch."""
754
 
 
755
 
    help_txt = """Selects a common ancestor with a second branch.
756
 
 
757
 
    Supply the path to a branch to select the common ancestor.
758
 
 
759
 
    The common ancestor is the last revision that existed in both
760
 
    branches. Usually this is the branch point, but it could also be
761
 
    a revision that was merged.
762
 
 
763
 
    This is frequently used with 'diff' to return all of the changes
764
 
    that your branch introduces, while excluding the changes that you
765
 
    have not merged from the remote branch.
766
 
 
767
 
    Examples::
768
 
 
769
 
      ancestor:/path/to/branch
770
 
      $ bzr diff -r ancestor:../../mainline/branch
771
 
    """
772
311
    prefix = 'ancestor:'
773
312
 
774
313
    def _match_on(self, branch, revs):
775
 
        trace.mutter('matching ancestor: on: %s, %s', self.spec, branch)
776
 
        return self._find_revision_info(branch, self.spec)
777
 
 
778
 
    def _as_revision_id(self, context_branch):
779
 
        return self._find_revision_id(context_branch, self.spec)
780
 
 
781
 
    @staticmethod
782
 
    def _find_revision_info(branch, other_location):
783
 
        revision_id = RevisionSpec_ancestor._find_revision_id(branch,
784
 
                                                              other_location)
785
 
        return RevisionInfo(branch, None, revision_id)
786
 
 
787
 
    @staticmethod
788
 
    def _find_revision_id(branch, other_location):
789
 
        from bzrlib.branch import Branch
790
 
 
791
 
        branch.lock_read()
 
314
        from branch import Branch
 
315
        from revision import common_ancestor, MultipleRevisionSources
 
316
        other_branch = Branch.open_containing(self.spec)[0]
 
317
        revision_a = branch.last_revision()
 
318
        revision_b = other_branch.last_revision()
 
319
        for r, b in ((revision_a, branch), (revision_b, other_branch)):
 
320
            if r is None:
 
321
                raise NoCommits(b)
 
322
        revision_source = MultipleRevisionSources(branch, other_branch)
 
323
        rev_id = common_ancestor(revision_a, revision_b, revision_source)
792
324
        try:
793
 
            revision_a = revision.ensure_null(branch.last_revision())
794
 
            if revision_a == revision.NULL_REVISION:
795
 
                raise errors.NoCommits(branch)
796
 
            if other_location == '':
797
 
                other_location = branch.get_parent()
798
 
            other_branch = Branch.open(other_location)
799
 
            other_branch.lock_read()
800
 
            try:
801
 
                revision_b = revision.ensure_null(other_branch.last_revision())
802
 
                if revision_b == revision.NULL_REVISION:
803
 
                    raise errors.NoCommits(other_branch)
804
 
                graph = branch.repository.get_graph(other_branch.repository)
805
 
                rev_id = graph.find_unique_lca(revision_a, revision_b)
806
 
            finally:
807
 
                other_branch.unlock()
808
 
            if rev_id == revision.NULL_REVISION:
809
 
                raise errors.NoCommonAncestor(revision_a, revision_b)
810
 
            return rev_id
811
 
        finally:
812
 
            branch.unlock()
813
 
 
814
 
 
815
 
 
 
325
            revno = branch.revision_id_to_revno(rev_id)
 
326
        except NoSuchRevision:
 
327
            revno = None
 
328
        return RevisionInfo(branch, revno, rev_id)
 
329
        
 
330
SPEC_TYPES.append(RevisionSpec_ancestor)
816
331
 
817
332
class RevisionSpec_branch(RevisionSpec):
818
 
    """Selects the last revision of a specified branch."""
819
 
 
820
 
    help_txt = """Selects the last revision of a specified branch.
821
 
 
822
 
    Supply the path to a branch to select its last revision.
823
 
 
824
 
    Examples::
825
 
 
826
 
      branch:/path/to/branch
 
333
    """A branch: revision specifier.
 
334
 
 
335
    This takes the path to a branch and returns its tip revision id.
827
336
    """
828
337
    prefix = 'branch:'
829
 
    dwim_catchable_exceptions = (errors.NotBranchError,)
830
338
 
831
339
    def _match_on(self, branch, revs):
832
 
        from bzrlib.branch import Branch
833
 
        other_branch = Branch.open(self.spec)
 
340
        from branch import Branch
 
341
        from fetch import greedy_fetch
 
342
        other_branch = Branch.open_containing(self.spec)[0]
834
343
        revision_b = other_branch.last_revision()
835
 
        if revision_b in (None, revision.NULL_REVISION):
836
 
            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)
846
 
 
847
 
    def _as_revision_id(self, context_branch):
848
 
        from bzrlib.branch import Branch
849
 
        other_branch = Branch.open(self.spec)
850
 
        last_revision = other_branch.last_revision()
851
 
        last_revision = revision.ensure_null(last_revision)
852
 
        context_branch.fetch(other_branch, last_revision)
853
 
        if last_revision == revision.NULL_REVISION:
854
 
            raise errors.NoCommits(other_branch)
855
 
        return last_revision
856
 
 
857
 
    def _as_tree(self, context_branch):
858
 
        from bzrlib.branch import Branch
859
 
        other_branch = Branch.open(self.spec)
860
 
        last_revision = other_branch.last_revision()
861
 
        last_revision = revision.ensure_null(last_revision)
862
 
        if last_revision == revision.NULL_REVISION:
863
 
            raise errors.NoCommits(other_branch)
864
 
        return other_branch.repository.revision_tree(last_revision)
865
 
 
866
 
    def needs_branch(self):
867
 
        return False
868
 
 
869
 
    def get_branch(self):
870
 
        return self.spec
871
 
 
872
 
 
873
 
 
874
 
class RevisionSpec_submit(RevisionSpec_ancestor):
875
 
    """Selects a common ancestor with a submit branch."""
876
 
 
877
 
    help_txt = """Selects a common ancestor with the submit branch.
878
 
 
879
 
    Diffing against this shows all the changes that were made in this branch,
880
 
    and is a good predictor of what merge will do.  The submit branch is
881
 
    used by the bundle and merge directive commands.  If no submit branch
882
 
    is specified, the parent branch is used instead.
883
 
 
884
 
    The common ancestor is the last revision that existed in both
885
 
    branches. Usually this is the branch point, but it could also be
886
 
    a revision that was merged.
887
 
 
888
 
    Examples::
889
 
 
890
 
      $ bzr diff -r submit:
891
 
    """
892
 
 
893
 
    prefix = 'submit:'
894
 
 
895
 
    def _get_submit_location(self, branch):
896
 
        submit_location = branch.get_submit_branch()
897
 
        location_type = 'submit branch'
898
 
        if submit_location is None:
899
 
            submit_location = branch.get_parent()
900
 
            location_type = 'parent branch'
901
 
        if submit_location is None:
902
 
            raise errors.NoSubmitBranch(branch)
903
 
        trace.note(gettext('Using {0} {1}').format(location_type,
904
 
                                                        submit_location))
905
 
        return submit_location
906
 
 
907
 
    def _match_on(self, branch, revs):
908
 
        trace.mutter('matching ancestor: on: %s, %s', self.spec, branch)
909
 
        return self._find_revision_info(branch,
910
 
            self._get_submit_location(branch))
911
 
 
912
 
    def _as_revision_id(self, context_branch):
913
 
        return self._find_revision_id(context_branch,
914
 
            self._get_submit_location(context_branch))
915
 
 
916
 
 
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
 
revspec_registry = registry.Registry()
996
 
def _register_revspec(revspec):
997
 
    revspec_registry.register(revspec.prefix, revspec)
998
 
 
999
 
_register_revspec(RevisionSpec_revno)
1000
 
_register_revspec(RevisionSpec_revid)
1001
 
_register_revspec(RevisionSpec_last)
1002
 
_register_revspec(RevisionSpec_before)
1003
 
_register_revspec(RevisionSpec_tag)
1004
 
_register_revspec(RevisionSpec_date)
1005
 
_register_revspec(RevisionSpec_ancestor)
1006
 
_register_revspec(RevisionSpec_branch)
1007
 
_register_revspec(RevisionSpec_submit)
1008
 
_register_revspec(RevisionSpec_annotate)
1009
 
_register_revspec(RevisionSpec_mainline)
 
344
        if revision_b is None:
 
345
            raise NoCommits(other_branch)
 
346
        # pull in the remote revisions so we can diff
 
347
        greedy_fetch(branch, other_branch, revision=revision_b)
 
348
        try:
 
349
            revno = branch.revision_id_to_revno(revision_b)
 
350
        except NoSuchRevision:
 
351
            revno = None
 
352
        return RevisionInfo(branch, revno, revision_b)
 
353
        
 
354
SPEC_TYPES.append(RevisionSpec_branch)