← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/revisionspec.py

  • Committer: Launchpad Translations on behalf of bzr-core
  • Date: 2012-05-29 04:30:47 UTC
  • mto: (6581.1.1 trunk)
  • mto: This revision was merged to the branch mainline in revision 6582.
  • Revision ID: launchpad_translations_on_behalf_of_bzr-core-20120529043047-mmj2hkq63ke8kl81
Launchpad automatic translations update.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/revisionspec.py
1
 
# Copyright (C) 2005 Canonical Ltd
 
1
# Copyright (C) 2005-2010 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
 
 
17
 
 
 
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
18
23
import datetime
19
 
import re
20
 
import bisect
21
 
from bzrlib.errors import BzrError, NoSuchRevision, NoCommits
22
 
 
23
 
_marker = []
 
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
 
24
42
 
25
43
class RevisionInfo(object):
26
 
    """The results of applying a revision specification to a branch.
 
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.
27
47
 
28
48
    An instance has two useful attributes: revno, and rev_id.
29
49
 
37
57
    or treat the result as a tuple.
38
58
    """
39
59
 
40
 
    def __init__(self, branch, revno, rev_id=_marker):
 
60
    def __init__(self, branch, revno=None, rev_id=None):
41
61
        self.branch = branch
42
 
        self.revno = revno
43
 
        if rev_id is _marker:
 
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:
44
66
            # allow caller to be lazy
45
 
            if self.revno is None:
46
 
                self.rev_id = None
47
 
            else:
48
 
                self.rev_id = branch.get_rev_id(self.revno)
49
 
        else:
50
 
            self.rev_id = rev_id
 
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
51
78
 
52
79
    def __nonzero__(self):
53
 
        # first the easy ones...
54
80
        if self.rev_id is None:
55
81
            return False
56
 
        if self.revno is not None:
57
 
            return True
58
82
        # TODO: otherwise, it should depend on how I was built -
59
83
        # if it's in_history(branch), then check revision_history(),
60
84
        # if it's in_store(branch), do the check below
82
106
        return '<bzrlib.revisionspec.RevisionInfo object %s, %s for %r>' % (
83
107
            self.revno, self.rev_id, self.branch)
84
108
 
85
 
# classes in this list should have a "prefix" attribute, against which
86
 
# string specs are matched
87
 
SPEC_TYPES = []
 
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
 
88
122
 
89
123
class RevisionSpec(object):
90
 
    """A parsed revision specification.
91
 
 
92
 
    A revision specification can be an integer, in which case it is
93
 
    assumed to be a revno (though this will translate negative values
94
 
    into positive ones); or it can be a string, in which case it is
95
 
    parsed for something like 'date:' or 'revid:' etc.
 
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.
96
132
 
97
133
    Revision specs are an UI element, and they have been moved out
98
134
    of the branch class to leave "back-end" classes unaware of such
104
140
    """
105
141
 
106
142
    prefix = None
107
 
 
108
 
    def __new__(cls, spec, foo=_marker):
109
 
        """Parse a revision specifier.
 
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.
110
161
        """
 
162
        if not isinstance(spec, (type(None), basestring)):
 
163
            raise TypeError('error')
 
164
 
111
165
        if spec is None:
112
 
            return object.__new__(RevisionSpec, spec)
113
 
 
114
 
        try:
115
 
            spec = int(spec)
116
 
        except ValueError:
117
 
            pass
118
 
 
119
 
        if isinstance(spec, int):
120
 
            return object.__new__(RevisionSpec_int, spec)
121
 
        elif isinstance(spec, basestring):
122
 
            for spectype in SPEC_TYPES:
123
 
                if spec.startswith(spectype.prefix):
124
 
                    return object.__new__(spectype, spec)
125
 
            else:
126
 
                raise BzrError('No namespace registered for string: %r' %
127
 
                               spec)
 
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)
128
173
        else:
129
 
            raise TypeError('Unhandled revision type %s' % spec)
130
 
 
131
 
    def __init__(self, spec):
 
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
132
192
        if self.prefix and spec.startswith(self.prefix):
133
193
            spec = spec[len(self.prefix):]
134
194
        self.spec = spec
135
195
 
136
196
    def _match_on(self, branch, revs):
137
 
        return RevisionInfo(branch, 0, None)
 
197
        trace.mutter('Returning RevisionSpec._match_on: None')
 
198
        return RevisionInfo(branch, None, None)
138
199
 
139
200
    def _match_on_and_check(self, branch, revs):
140
201
        info = self._match_on(branch, revs)
141
202
        if info:
142
203
            return info
143
 
        elif info == (0, None):
144
 
            # special case - the empty tree
 
204
        elif info == (None, None):
 
205
            # special case - nothing supplied
145
206
            return info
146
207
        elif self.prefix:
147
 
            raise NoSuchRevision(branch, self.prefix + str(self.spec))
 
208
            raise errors.InvalidRevisionSpec(self.user_spec, branch)
148
209
        else:
149
 
            raise NoSuchRevision(branch, str(self.spec))
 
210
            raise errors.InvalidRevisionSpec(self.spec, branch)
150
211
 
151
212
    def in_history(self, branch):
152
213
        if branch:
153
 
            revs = branch.revision_history()
 
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
154
229
        else:
 
230
            # this should never trigger.
 
231
            # TODO: make it a deprecated code path. RBC 20060928
155
232
            revs = None
156
233
        return self._match_on_and_check(branch, revs)
157
234
 
164
241
    # will do what you expect.
165
242
    in_store = in_history
166
243
    in_branch = in_store
167
 
        
 
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
 
168
280
    def __repr__(self):
169
281
        # this is mostly for helping with testing
170
 
        return '<%s %s%s>' % (self.__class__.__name__,
171
 
                              self.prefix or '',
172
 
                              self.spec)
173
 
    
 
282
        return '<%s %s>' % (self.__class__.__name__,
 
283
                              self.user_spec)
 
284
 
174
285
    def needs_branch(self):
175
286
        """Whether this revision spec needs a branch.
176
287
 
178
289
        """
179
290
        return True
180
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
 
298
 
 
299
 
181
300
# private API
182
301
 
183
 
class RevisionSpec_int(RevisionSpec):
184
 
    """Spec is a number.  Special case."""
185
 
    def __init__(self, spec):
186
 
        self.spec = int(spec)
 
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)
187
323
 
188
324
    def _match_on(self, branch, revs):
189
 
        if self.spec < 0:
190
 
            revno = len(revs) + self.spec + 1
191
 
        else:
192
 
            revno = self.spec
193
 
        rev_id = branch.get_rev_id(revno, revs)
194
 
        return RevisionInfo(branch, revno, rev_id)
 
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))
195
371
 
196
372
 
197
373
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
    """
198
394
    prefix = 'revno:'
199
395
 
200
396
    def _match_on(self, branch, revs):
201
397
        """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):
202
468
        if self.spec.find(':') == -1:
203
 
            try:
204
 
                return RevisionInfo(branch, int(self.spec))
205
 
            except ValueError:
206
 
                return RevisionInfo(branch, None)
 
469
            return None
207
470
        else:
208
 
            from branch import Branch
209
 
            revname = self.spec[self.spec.find(':')+1:]
210
 
            other_branch = Branch.open_containing(revname)[0]
211
 
            try:
212
 
                revno = int(self.spec[:self.spec.find(':')])
213
 
            except ValueError:
214
 
                return RevisionInfo(other_branch, None)
215
 
            revid = other_branch.get_rev_id(revno)
216
 
            return RevisionInfo(other_branch, revno)
217
 
        
218
 
    def needs_branch(self):
219
 
        return self.spec.find(':') == -1
220
 
 
221
 
SPEC_TYPES.append(RevisionSpec_revno)
222
 
 
223
 
 
224
 
class RevisionSpec_revid(RevisionSpec):
 
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
 
225
497
    prefix = 'revid:'
226
498
 
227
 
    def _match_on(self, branch, revs):
228
 
        try:
229
 
            return RevisionInfo(branch, revs.index(self.spec) + 1, self.spec)
230
 
        except ValueError:
231
 
            return RevisionInfo(branch, None, self.spec)
 
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)
232
504
 
233
 
SPEC_TYPES.append(RevisionSpec_revid)
234
505
 
235
506
 
236
507
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
    """
237
519
 
238
520
    prefix = 'last:'
239
521
 
240
522
    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
 
241
534
        try:
242
535
            offset = int(self.spec)
243
 
        except ValueError:
244
 
            return RevisionInfo(branch, None)
245
 
        else:
246
 
            if offset <= 0:
247
 
                raise BzrError('You must supply a positive value for --revision last:XXX')
248
 
            return RevisionInfo(branch, len(revs) - offset + 1)
249
 
 
250
 
SPEC_TYPES.append(RevisionSpec_last)
 
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
 
251
556
 
252
557
 
253
558
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
    """
254
579
 
255
580
    prefix = 'before:'
256
 
    
 
581
 
257
582
    def _match_on(self, branch, revs):
258
 
        r = RevisionSpec(self.spec)._match_on(branch, revs)
259
 
        if (r.revno is None) or (r.revno == 0):
260
 
            return r
261
 
        return RevisionInfo(branch, r.revno - 1)
262
 
 
263
 
SPEC_TYPES.append(RevisionSpec_before)
 
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
 
264
625
 
265
626
 
266
627
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
 
267
635
    prefix = 'tag:'
 
636
    dwim_catchable_exceptions = (errors.NoSuchTag, errors.TagsNotSupported)
268
637
 
269
638
    def _match_on(self, branch, revs):
270
 
        raise BzrError('tag: namespace registered, but not implemented.')
271
 
 
272
 
SPEC_TYPES.append(RevisionSpec_tag)
273
 
 
274
 
 
275
 
class RevisionSpec_revs:
276
 
    def __init__(self, revs, branch):
277
 
        self.revs = 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):
278
654
        self.branch = branch
 
655
 
279
656
    def __getitem__(self, index):
280
 
        r = self.branch.repository.get_revision(self.revs[index])
 
657
        """Get the date of the index'd item"""
 
658
        r = self.branch.repository.get_revision(self.branch.get_rev_id(index))
281
659
        # TODO: Handle timezone.
282
660
        return datetime.datetime.fromtimestamp(r.timestamp)
 
661
 
283
662
    def __len__(self):
284
 
        return len(self.revs)
 
663
        return self.branch.revno()
285
664
 
286
665
 
287
666
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
    """
288
686
    prefix = 'date:'
289
 
    _date_re = re.compile(
 
687
    _date_regex = lazy_regex.lazy_compile(
290
688
            r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
291
689
            r'(,|T)?\s*'
292
690
            r'(?P<time>(?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d))?)?'
293
691
        )
294
692
 
295
693
    def _match_on(self, branch, revs):
296
 
        """
297
 
        Spec for date revisions:
 
694
        """Spec for date revisions:
298
695
          date:value
299
696
          value can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
300
697
          matches the first entry after a given date (either at midnight or
301
698
          at a specified time).
302
 
 
303
 
          So the proper way of saying 'give me all entries for today' is:
304
 
              -r date:yesterday..date:today
305
699
        """
 
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
306
703
        today = datetime.datetime.fromordinal(datetime.date.today().toordinal())
307
704
        if self.spec.lower() == 'yesterday':
308
705
            dt = today - datetime.timedelta(days=1)
311
708
        elif self.spec.lower() == 'tomorrow':
312
709
            dt = today + datetime.timedelta(days=1)
313
710
        else:
314
 
            m = self._date_re.match(self.spec)
 
711
            m = self._date_regex.match(self.spec)
315
712
            if not m or (not m.group('date') and not m.group('time')):
316
 
                raise BzrError('Invalid revision date %r' % self.spec)
317
 
 
318
 
            if m.group('date'):
319
 
                year, month, day = int(m.group('year')), int(m.group('month')), int(m.group('day'))
320
 
            else:
321
 
                year, month, day = today.year, today.month, today.day
322
 
            if m.group('time'):
323
 
                hour = int(m.group('hour'))
324
 
                minute = int(m.group('minute'))
325
 
                if m.group('second'):
326
 
                    second = int(m.group('second'))
327
 
                else:
328
 
                    second = 0
329
 
            else:
330
 
                hour, minute, second = 0,0,0
 
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')
331
738
 
332
739
            dt = datetime.datetime(year=year, month=month, day=day,
333
740
                    hour=hour, minute=minute, second=second)
334
741
        branch.lock_read()
335
742
        try:
336
 
            rev = bisect.bisect(RevisionSpec_revs(revs, branch), dt)
 
743
            rev = bisect.bisect(_RevListToTimestamps(branch), dt, 1)
337
744
        finally:
338
745
            branch.unlock()
339
 
        if rev == len(revs):
340
 
            return RevisionInfo(branch, None)
341
 
        else:
342
 
            return RevisionInfo(branch, rev + 1)
 
746
        if rev == branch.revno():
 
747
            raise errors.InvalidRevisionSpec(self.user_spec, branch)
 
748
        return RevisionInfo(branch, rev)
343
749
 
344
 
SPEC_TYPES.append(RevisionSpec_date)
345
750
 
346
751
 
347
752
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
    """
348
772
    prefix = 'ancestor:'
349
773
 
350
774
    def _match_on(self, branch, revs):
351
 
        from branch import Branch
352
 
        from revision import common_ancestor, MultipleRevisionSources
353
 
        other_branch = Branch.open_containing(self.spec)[0]
354
 
        revision_a = branch.last_revision()
355
 
        revision_b = other_branch.last_revision()
356
 
        for r, b in ((revision_a, branch), (revision_b, other_branch)):
357
 
            if r is None:
358
 
                raise NoCommits(b)
359
 
        revision_source = MultipleRevisionSources(branch.repository,
360
 
                                                  other_branch.repository)
361
 
        rev_id = common_ancestor(revision_a, revision_b, revision_source)
 
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()
362
792
        try:
363
 
            revno = branch.revision_id_to_revno(rev_id)
364
 
        except NoSuchRevision:
365
 
            revno = None
366
 
        return RevisionInfo(branch, revno, rev_id)
367
 
        
368
 
SPEC_TYPES.append(RevisionSpec_ancestor)
 
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
 
369
816
 
370
817
class RevisionSpec_branch(RevisionSpec):
371
 
    """A branch: revision specifier.
372
 
 
373
 
    This takes the path to a branch and returns its tip revision id.
 
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
374
827
    """
375
828
    prefix = 'branch:'
 
829
    dwim_catchable_exceptions = (errors.NotBranchError,)
376
830
 
377
831
    def _match_on(self, branch, revs):
378
 
        from branch import Branch
379
 
        other_branch = Branch.open_containing(self.spec)[0]
 
832
        from bzrlib.branch import Branch
 
833
        other_branch = Branch.open(self.spec)
380
834
        revision_b = other_branch.last_revision()
381
 
        if revision_b is None:
382
 
            raise NoCommits(other_branch)
383
 
        # pull in the remote revisions so we can diff
384
 
        branch.fetch(other_branch, revision_b)
385
 
        try:
386
 
            revno = branch.revision_id_to_revno(revision_b)
387
 
        except NoSuchRevision:
388
 
            revno = None
389
 
        return RevisionInfo(branch, revno, revision_b)
390
 
        
391
 
SPEC_TYPES.append(RevisionSpec_branch)
 
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)