~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/revisionspec.py

  • Committer: Aaron Bentley
  • Date: 2007-12-12 15:17:13 UTC
  • mto: This revision was merged to the branch mainline in revision 3113.
  • Revision ID: abentley@panoramicfeedback.com-20071212151713-ox5n8rlx8m3nsspy
Add support for reconfiguring repositories into branches or trees

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005 Canonical Ltd
2
 
 
 
1
# Copyright (C) 2005, 2006, 2007 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
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
 
 
18
import bisect
18
19
import datetime
19
20
import re
20
 
from bzrlib.errors import BzrError, NoSuchRevision, NoCommits
 
21
 
 
22
from bzrlib import (
 
23
    errors,
 
24
    osutils,
 
25
    revision,
 
26
    symbol_versioning,
 
27
    trace,
 
28
    tsort,
 
29
    )
 
30
 
21
31
 
22
32
_marker = []
23
33
 
 
34
 
24
35
class RevisionInfo(object):
25
 
    """The results of applying a revision specification to a branch.
 
36
    """The results of applying a revision specification to a branch."""
 
37
 
 
38
    help_txt = """The results of applying a revision specification to a branch.
26
39
 
27
40
    An instance has two useful attributes: revno, and rev_id.
28
41
 
57
70
        # TODO: otherwise, it should depend on how I was built -
58
71
        # if it's in_history(branch), then check revision_history(),
59
72
        # if it's in_store(branch), do the check below
60
 
        return self.branch.revision_store.has_id(self.rev_id)
 
73
        return self.branch.repository.has_revision(self.rev_id)
61
74
 
62
75
    def __len__(self):
63
76
        return 2
68
81
        raise IndexError(index)
69
82
 
70
83
    def get(self):
71
 
        return self.branch.get_revision(self.rev_id)
 
84
        return self.branch.repository.get_revision(self.rev_id)
72
85
 
73
86
    def __eq__(self, other):
74
87
        if type(other) not in (tuple, list, type(self)):
81
94
        return '<bzrlib.revisionspec.RevisionInfo object %s, %s for %r>' % (
82
95
            self.revno, self.rev_id, self.branch)
83
96
 
 
97
    @staticmethod
 
98
    def from_revision_id(branch, revision_id, revs):
 
99
        """Construct a RevisionInfo given just the id.
 
100
 
 
101
        Use this if you don't know or care what the revno is.
 
102
        """
 
103
        try:
 
104
            revno = revs.index(revision_id) + 1
 
105
        except ValueError:
 
106
            revno = None
 
107
        return RevisionInfo(branch, revno, revision_id)
 
108
 
 
109
 
84
110
# classes in this list should have a "prefix" attribute, against which
85
111
# string specs are matched
86
112
SPEC_TYPES = []
 
113
_revno_regex = None
 
114
 
87
115
 
88
116
class RevisionSpec(object):
89
 
    """A parsed revision specification.
 
117
    """A parsed revision specification."""
 
118
 
 
119
    help_txt = """A parsed revision specification.
90
120
 
91
121
    A revision specification can be an integer, in which case it is
92
122
    assumed to be a revno (though this will translate negative values
104
134
 
105
135
    prefix = None
106
136
 
107
 
    def __new__(cls, spec, foo=_marker):
108
 
        """Parse a revision specifier.
 
137
    def __new__(cls, spec, _internal=False):
 
138
        if _internal:
 
139
            return object.__new__(cls, spec, _internal=_internal)
 
140
 
 
141
        symbol_versioning.warn('Creating a RevisionSpec directly has'
 
142
                               ' been deprecated in version 0.11. Use'
 
143
                               ' RevisionSpec.from_string()'
 
144
                               ' instead.',
 
145
                               DeprecationWarning, stacklevel=2)
 
146
        return RevisionSpec.from_string(spec)
 
147
 
 
148
    @staticmethod
 
149
    def from_string(spec):
 
150
        """Parse a revision spec string into a RevisionSpec object.
 
151
 
 
152
        :param spec: A string specified by the user
 
153
        :return: A RevisionSpec object that understands how to parse the
 
154
            supplied notation.
109
155
        """
 
156
        if not isinstance(spec, (type(None), basestring)):
 
157
            raise TypeError('error')
 
158
 
110
159
        if spec is None:
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)
 
160
            return RevisionSpec(None, _internal=True)
 
161
 
 
162
        assert isinstance(spec, basestring), \
 
163
            "You should only supply strings not %s" % (type(spec),)
 
164
 
 
165
        for spectype in SPEC_TYPES:
 
166
            if spec.startswith(spectype.prefix):
 
167
                trace.mutter('Returning RevisionSpec %s for %s',
 
168
                             spectype.__name__, spec)
 
169
                return spectype(spec, _internal=True)
127
170
        else:
128
 
            raise TypeError('Unhandled revision type %s' % spec)
129
 
 
130
 
    def __init__(self, spec):
 
171
            # RevisionSpec_revno is special cased, because it is the only
 
172
            # one that directly handles plain integers
 
173
            # TODO: This should not be special cased rather it should be
 
174
            # a method invocation on spectype.canparse()
 
175
            global _revno_regex
 
176
            if _revno_regex is None:
 
177
                _revno_regex = re.compile(r'^(?:(\d+(\.\d+)*)|-\d+)(:.*)?$')
 
178
            if _revno_regex.match(spec) is not None:
 
179
                return RevisionSpec_revno(spec, _internal=True)
 
180
 
 
181
            raise errors.NoSuchRevisionSpec(spec)
 
182
 
 
183
    def __init__(self, spec, _internal=False):
 
184
        """Create a RevisionSpec referring to the Null revision.
 
185
 
 
186
        :param spec: The original spec supplied by the user
 
187
        :param _internal: Used to ensure that RevisionSpec is not being
 
188
            called directly. Only from RevisionSpec.from_string()
 
189
        """
 
190
        if not _internal:
 
191
            # XXX: Update this after 0.10 is released
 
192
            symbol_versioning.warn('Creating a RevisionSpec directly has'
 
193
                                   ' been deprecated in version 0.11. Use'
 
194
                                   ' RevisionSpec.from_string()'
 
195
                                   ' instead.',
 
196
                                   DeprecationWarning, stacklevel=2)
 
197
        self.user_spec = spec
131
198
        if self.prefix and spec.startswith(self.prefix):
132
199
            spec = spec[len(self.prefix):]
133
200
        self.spec = spec
134
201
 
135
202
    def _match_on(self, branch, revs):
 
203
        trace.mutter('Returning RevisionSpec._match_on: None')
136
204
        return RevisionInfo(branch, 0, None)
137
205
 
138
206
    def _match_on_and_check(self, branch, revs):
143
211
            # special case - the empty tree
144
212
            return info
145
213
        elif self.prefix:
146
 
            raise NoSuchRevision(branch, self.prefix + str(self.spec))
 
214
            raise errors.InvalidRevisionSpec(self.user_spec, branch)
147
215
        else:
148
 
            raise NoSuchRevision(branch, str(self.spec))
 
216
            raise errors.InvalidRevisionSpec(self.spec, branch)
149
217
 
150
218
    def in_history(self, branch):
151
 
        revs = branch.revision_history()
 
219
        if branch:
 
220
            revs = branch.revision_history()
 
221
        else:
 
222
            # this should never trigger.
 
223
            # TODO: make it a deprecated code path. RBC 20060928
 
224
            revs = None
152
225
        return self._match_on_and_check(branch, revs)
153
226
 
154
227
        # FIXME: in_history is somewhat broken,
163
236
        
164
237
    def __repr__(self):
165
238
        # this is mostly for helping with testing
166
 
        return '<%s %s%s>' % (self.__class__.__name__,
167
 
                              self.prefix or '',
168
 
                              self.spec)
 
239
        return '<%s %s>' % (self.__class__.__name__,
 
240
                              self.user_spec)
 
241
    
 
242
    def needs_branch(self):
 
243
        """Whether this revision spec needs a branch.
 
244
 
 
245
        Set this to False the branch argument of _match_on is not used.
 
246
        """
 
247
        return True
 
248
 
 
249
    def get_branch(self):
 
250
        """When the revision specifier contains a branch location, return it.
 
251
        
 
252
        Otherwise, return None.
 
253
        """
 
254
        return None
169
255
 
170
256
 
171
257
# private API
172
258
 
173
 
class RevisionSpec_int(RevisionSpec):
174
 
    """Spec is a number.  Special case."""
175
 
    def __init__(self, spec):
176
 
        self.spec = int(spec)
177
 
 
178
 
    def _match_on(self, branch, revs):
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)
185
 
 
186
 
 
187
259
class RevisionSpec_revno(RevisionSpec):
 
260
    """Selects a revision using a number."""
 
261
 
 
262
    help_txt = """Selects a revision using a number.
 
263
 
 
264
    Use an integer to specify a revision in the history of the branch.
 
265
    Optionally a branch can be specified. The 'revno:' prefix is optional.
 
266
    A negative number will count from the end of the branch (-1 is the
 
267
    last revision, -2 the previous one). If the negative number is larger
 
268
    than the branch's history, the first revision is returned.
 
269
    Examples::
 
270
 
 
271
      revno:1                   -> return the first revision
 
272
      revno:3:/path/to/branch   -> return the 3rd revision of
 
273
                                   the branch '/path/to/branch'
 
274
      revno:-1                  -> The last revision in a branch.
 
275
      -2:http://other/branch    -> The second to last revision in the
 
276
                                   remote branch.
 
277
      -1000000                  -> Most likely the first revision, unless
 
278
                                   your history is very long.
 
279
    """
188
280
    prefix = 'revno:'
189
281
 
190
282
    def _match_on(self, branch, revs):
191
283
        """Lookup a revision by revision number"""
192
 
        try:
193
 
            return RevisionInfo(branch, int(self.spec))
194
 
        except ValueError:
195
 
            return RevisionInfo(branch, None)
 
284
        loc = self.spec.find(':')
 
285
        if loc == -1:
 
286
            revno_spec = self.spec
 
287
            branch_spec = None
 
288
        else:
 
289
            revno_spec = self.spec[:loc]
 
290
            branch_spec = self.spec[loc+1:]
 
291
 
 
292
        if revno_spec == '':
 
293
            if not branch_spec:
 
294
                raise errors.InvalidRevisionSpec(self.user_spec,
 
295
                        branch, 'cannot have an empty revno and no branch')
 
296
            revno = None
 
297
        else:
 
298
            try:
 
299
                revno = int(revno_spec)
 
300
                dotted = False
 
301
            except ValueError:
 
302
                # dotted decimal. This arguably should not be here
 
303
                # but the from_string method is a little primitive 
 
304
                # right now - RBC 20060928
 
305
                try:
 
306
                    match_revno = tuple((int(number) for number in revno_spec.split('.')))
 
307
                except ValueError, e:
 
308
                    raise errors.InvalidRevisionSpec(self.user_spec, branch, e)
 
309
 
 
310
                dotted = True
 
311
 
 
312
        if branch_spec:
 
313
            # the user has override the branch to look in.
 
314
            # we need to refresh the revision_history map and
 
315
            # the branch object.
 
316
            from bzrlib.branch import Branch
 
317
            branch = Branch.open(branch_spec)
 
318
            # Need to use a new revision history
 
319
            # because we are using a specific branch
 
320
            revs = branch.revision_history()
 
321
 
 
322
        if dotted:
 
323
            branch.lock_read()
 
324
            try:
 
325
                revision_id_to_revno = branch.get_revision_id_to_revno_map()
 
326
                revisions = [revision_id for revision_id, revno
 
327
                             in revision_id_to_revno.iteritems()
 
328
                             if revno == match_revno]
 
329
            finally:
 
330
                branch.unlock()
 
331
            if len(revisions) != 1:
 
332
                return RevisionInfo(branch, None, None)
 
333
            else:
 
334
                # there is no traditional 'revno' for dotted-decimal revnos.
 
335
                # so for  API compatability we return None.
 
336
                return RevisionInfo(branch, None, revisions[0])
 
337
        else:
 
338
            if revno < 0:
 
339
                # if get_rev_id supported negative revnos, there would not be a
 
340
                # need for this special case.
 
341
                if (-revno) >= len(revs):
 
342
                    revno = 1
 
343
                else:
 
344
                    revno = len(revs) + revno + 1
 
345
            try:
 
346
                revision_id = branch.get_rev_id(revno, revs)
 
347
            except errors.NoSuchRevision:
 
348
                raise errors.InvalidRevisionSpec(self.user_spec, branch)
 
349
        return RevisionInfo(branch, revno, revision_id)
 
350
        
 
351
    def needs_branch(self):
 
352
        return self.spec.find(':') == -1
 
353
 
 
354
    def get_branch(self):
 
355
        if self.spec.find(':') == -1:
 
356
            return None
 
357
        else:
 
358
            return self.spec[self.spec.find(':')+1:]
 
359
 
 
360
# Old compatibility 
 
361
RevisionSpec_int = RevisionSpec_revno
196
362
 
197
363
SPEC_TYPES.append(RevisionSpec_revno)
198
364
 
199
365
 
200
366
class RevisionSpec_revid(RevisionSpec):
 
367
    """Selects a revision using the revision id."""
 
368
 
 
369
    help_txt = """Selects a revision using the revision id.
 
370
 
 
371
    Supply a specific revision id, that can be used to specify any
 
372
    revision id in the ancestry of the branch. 
 
373
    Including merges, and pending merges.
 
374
    Examples::
 
375
 
 
376
      revid:aaaa@bbbb-123456789 -> Select revision 'aaaa@bbbb-123456789'
 
377
    """    
201
378
    prefix = 'revid:'
202
379
 
203
380
    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, self.spec)
 
381
        # self.spec comes straight from parsing the command line arguments,
 
382
        # so we expect it to be a Unicode string. Switch it to the internal
 
383
        # representation.
 
384
        revision_id = osutils.safe_revision_id(self.spec, warn=False)
 
385
        return RevisionInfo.from_revision_id(branch, revision_id, revs)
208
386
 
209
387
SPEC_TYPES.append(RevisionSpec_revid)
210
388
 
211
389
 
212
390
class RevisionSpec_last(RevisionSpec):
 
391
    """Selects the nth revision from the end."""
 
392
 
 
393
    help_txt = """Selects the nth revision from the end.
 
394
 
 
395
    Supply a positive number to get the nth revision from the end.
 
396
    This is the same as supplying negative numbers to the 'revno:' spec.
 
397
    Examples::
 
398
 
 
399
      last:1        -> return the last revision
 
400
      last:3        -> return the revision 2 before the end.
 
401
    """    
213
402
 
214
403
    prefix = 'last:'
215
404
 
216
405
    def _match_on(self, branch, revs):
 
406
        if self.spec == '':
 
407
            if not revs:
 
408
                raise errors.NoCommits(branch)
 
409
            return RevisionInfo(branch, len(revs), revs[-1])
 
410
 
217
411
        try:
218
412
            offset = int(self.spec)
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)
 
413
        except ValueError, e:
 
414
            raise errors.InvalidRevisionSpec(self.user_spec, branch, e)
 
415
 
 
416
        if offset <= 0:
 
417
            raise errors.InvalidRevisionSpec(self.user_spec, branch,
 
418
                                             'you must supply a positive value')
 
419
        revno = len(revs) - offset + 1
 
420
        try:
 
421
            revision_id = branch.get_rev_id(revno, revs)
 
422
        except errors.NoSuchRevision:
 
423
            raise errors.InvalidRevisionSpec(self.user_spec, branch)
 
424
        return RevisionInfo(branch, revno, revision_id)
225
425
 
226
426
SPEC_TYPES.append(RevisionSpec_last)
227
427
 
228
428
 
229
429
class RevisionSpec_before(RevisionSpec):
 
430
    """Selects the parent of the revision specified."""
 
431
 
 
432
    help_txt = """Selects the parent of the revision specified.
 
433
 
 
434
    Supply any revision spec to return the parent of that revision.
 
435
    It is an error to request the parent of the null revision (before:0).
 
436
    This is mostly useful when inspecting revisions that are not in the
 
437
    revision history of a branch.
 
438
 
 
439
    Examples::
 
440
 
 
441
      before:1913    -> Return the parent of revno 1913 (revno 1912)
 
442
      before:revid:aaaa@bbbb-1234567890  -> return the parent of revision
 
443
                                            aaaa@bbbb-1234567890
 
444
      bzr diff -r before:revid:aaaa..revid:aaaa
 
445
            -> Find the changes between revision 'aaaa' and its parent.
 
446
               (what changes did 'aaaa' introduce)
 
447
    """
230
448
 
231
449
    prefix = 'before:'
232
450
    
233
451
    def _match_on(self, branch, revs):
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)
 
452
        r = RevisionSpec.from_string(self.spec)._match_on(branch, revs)
 
453
        if r.revno == 0:
 
454
            raise errors.InvalidRevisionSpec(self.user_spec, branch,
 
455
                                         'cannot go before the null: revision')
 
456
        if r.revno is None:
 
457
            # We need to use the repository history here
 
458
            rev = branch.repository.get_revision(r.rev_id)
 
459
            if not rev.parent_ids:
 
460
                revno = 0
 
461
                revision_id = revision.NULL_REVISION
 
462
            else:
 
463
                revision_id = rev.parent_ids[0]
 
464
                try:
 
465
                    revno = revs.index(revision_id) + 1
 
466
                except ValueError:
 
467
                    revno = None
 
468
        else:
 
469
            revno = r.revno - 1
 
470
            try:
 
471
                revision_id = branch.get_rev_id(revno, revs)
 
472
            except errors.NoSuchRevision:
 
473
                raise errors.InvalidRevisionSpec(self.user_spec,
 
474
                                                 branch)
 
475
        return RevisionInfo(branch, revno, revision_id)
238
476
 
239
477
SPEC_TYPES.append(RevisionSpec_before)
240
478
 
241
479
 
242
480
class RevisionSpec_tag(RevisionSpec):
 
481
    """Select a revision identified by tag name"""
 
482
 
 
483
    help_txt = """Selects a revision identified by a tag name.
 
484
 
 
485
    Tags are stored in the branch and created by the 'tag' command.
 
486
    """
 
487
 
243
488
    prefix = 'tag:'
244
489
 
245
490
    def _match_on(self, branch, revs):
246
 
        raise BzrError('tag: namespace registered, but not implemented.')
 
491
        # Can raise tags not supported, NoSuchTag, etc
 
492
        return RevisionInfo.from_revision_id(branch,
 
493
            branch.tags.lookup_tag(self.spec),
 
494
            revs)
247
495
 
248
496
SPEC_TYPES.append(RevisionSpec_tag)
249
497
 
250
498
 
 
499
class _RevListToTimestamps(object):
 
500
    """This takes a list of revisions, and allows you to bisect by date"""
 
501
 
 
502
    __slots__ = ['revs', 'branch']
 
503
 
 
504
    def __init__(self, revs, branch):
 
505
        self.revs = revs
 
506
        self.branch = branch
 
507
 
 
508
    def __getitem__(self, index):
 
509
        """Get the date of the index'd item"""
 
510
        r = self.branch.repository.get_revision(self.revs[index])
 
511
        # TODO: Handle timezone.
 
512
        return datetime.datetime.fromtimestamp(r.timestamp)
 
513
 
 
514
    def __len__(self):
 
515
        return len(self.revs)
 
516
 
 
517
 
251
518
class RevisionSpec_date(RevisionSpec):
 
519
    """Selects a revision on the basis of a datestamp."""
 
520
 
 
521
    help_txt = """Selects a revision on the basis of a datestamp.
 
522
 
 
523
    Supply a datestamp to select the first revision that matches the date.
 
524
    Date can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
 
525
    Matches the first entry after a given date (either at midnight or
 
526
    at a specified time).
 
527
 
 
528
    One way to display all the changes since yesterday would be::
 
529
 
 
530
        bzr log -r date:yesterday..-1
 
531
 
 
532
    Examples::
 
533
 
 
534
      date:yesterday            -> select the first revision since yesterday
 
535
      date:2006-08-14,17:10:14  -> select the first revision after
 
536
                                   August 14th, 2006 at 5:10pm.
 
537
    """    
252
538
    prefix = 'date:'
253
539
    _date_re = re.compile(
254
540
            r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
257
543
        )
258
544
 
259
545
    def _match_on(self, branch, revs):
260
 
        """
261
 
        Spec for date revisions:
 
546
        """Spec for date revisions:
262
547
          date:value
263
548
          value can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
264
549
          matches the first entry after a given date (either at midnight or
265
550
          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
269
551
        """
 
552
        #  XXX: This doesn't actually work
 
553
        #  So the proper way of saying 'give me all entries for today' is:
 
554
        #      -r date:yesterday..date:today
270
555
        today = datetime.datetime.fromordinal(datetime.date.today().toordinal())
271
556
        if self.spec.lower() == 'yesterday':
272
557
            dt = today - datetime.timedelta(days=1)
277
562
        else:
278
563
            m = self._date_re.match(self.spec)
279
564
            if not m or (not m.group('date') and not m.group('time')):
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
 
565
                raise errors.InvalidRevisionSpec(self.user_spec,
 
566
                                                 branch, 'invalid date')
 
567
 
 
568
            try:
 
569
                if m.group('date'):
 
570
                    year = int(m.group('year'))
 
571
                    month = int(m.group('month'))
 
572
                    day = int(m.group('day'))
 
573
                else:
 
574
                    year = today.year
 
575
                    month = today.month
 
576
                    day = today.day
 
577
 
 
578
                if m.group('time'):
 
579
                    hour = int(m.group('hour'))
 
580
                    minute = int(m.group('minute'))
 
581
                    if m.group('second'):
 
582
                        second = int(m.group('second'))
 
583
                    else:
 
584
                        second = 0
 
585
                else:
 
586
                    hour, minute, second = 0,0,0
 
587
            except ValueError:
 
588
                raise errors.InvalidRevisionSpec(self.user_spec,
 
589
                                                 branch, 'invalid date')
295
590
 
296
591
            dt = datetime.datetime(year=year, month=month, day=day,
297
592
                    hour=hour, minute=minute, second=second)
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)
 
593
        branch.lock_read()
 
594
        try:
 
595
            rev = bisect.bisect(_RevListToTimestamps(revs, branch), dt)
 
596
        finally:
 
597
            branch.unlock()
 
598
        if rev == len(revs):
 
599
            return RevisionInfo(branch, None)
 
600
        else:
 
601
            return RevisionInfo(branch, rev + 1)
306
602
 
307
603
SPEC_TYPES.append(RevisionSpec_date)
308
604
 
309
605
 
310
606
class RevisionSpec_ancestor(RevisionSpec):
 
607
    """Selects a common ancestor with a second branch."""
 
608
 
 
609
    help_txt = """Selects a common ancestor with a second branch.
 
610
 
 
611
    Supply the path to a branch to select the common ancestor.
 
612
 
 
613
    The common ancestor is the last revision that existed in both
 
614
    branches. Usually this is the branch point, but it could also be
 
615
    a revision that was merged.
 
616
 
 
617
    This is frequently used with 'diff' to return all of the changes
 
618
    that your branch introduces, while excluding the changes that you
 
619
    have not merged from the remote branch.
 
620
 
 
621
    Examples::
 
622
 
 
623
      ancestor:/path/to/branch
 
624
      $ bzr diff -r ancestor:../../mainline/branch
 
625
    """
311
626
    prefix = 'ancestor:'
312
627
 
313
628
    def _match_on(self, branch, revs):
314
 
        from branch import Branch
315
 
        from revision import common_ancestor, MultipleRevisionSources
316
 
        other_branch = Branch.open_containing(self.spec)[0]
 
629
        trace.mutter('matching ancestor: on: %s, %s', self.spec, branch)
 
630
        return self._find_revision_info(branch, self.spec)
 
631
 
 
632
    @staticmethod
 
633
    def _find_revision_info(branch, other_location):
 
634
        from bzrlib.branch import Branch
 
635
 
 
636
        other_branch = Branch.open(other_location)
317
637
        revision_a = branch.last_revision()
318
638
        revision_b = other_branch.last_revision()
319
639
        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)
 
640
            if r in (None, revision.NULL_REVISION):
 
641
                raise errors.NoCommits(b)
 
642
        branch.lock_read()
 
643
        other_branch.lock_read()
324
644
        try:
325
 
            revno = branch.revision_id_to_revno(rev_id)
326
 
        except NoSuchRevision:
327
 
            revno = None
328
 
        return RevisionInfo(branch, revno, rev_id)
329
 
        
 
645
            revision_source = revision.MultipleRevisionSources(
 
646
                    branch.repository, other_branch.repository)
 
647
            graph = branch.repository.get_graph(other_branch.repository)
 
648
            revision_a = revision.ensure_null(revision_a)
 
649
            revision_b = revision.ensure_null(revision_b)
 
650
            if revision.NULL_REVISION in (revision_a, revision_b):
 
651
                rev_id = revision.NULL_REVISION
 
652
            else:
 
653
                rev_id = graph.find_unique_lca(revision_a, revision_b)
 
654
                if rev_id == revision.NULL_REVISION:
 
655
                    raise errors.NoCommonAncestor(revision_a, revision_b)
 
656
            try:
 
657
                revno = branch.revision_id_to_revno(rev_id)
 
658
            except errors.NoSuchRevision:
 
659
                revno = None
 
660
            return RevisionInfo(branch, revno, rev_id)
 
661
        finally:
 
662
            branch.unlock()
 
663
            other_branch.unlock()
 
664
 
 
665
 
330
666
SPEC_TYPES.append(RevisionSpec_ancestor)
331
667
 
 
668
 
332
669
class RevisionSpec_branch(RevisionSpec):
333
 
    """A branch: revision specifier.
334
 
 
335
 
    This takes the path to a branch and returns its tip revision id.
 
670
    """Selects the last revision of a specified branch."""
 
671
 
 
672
    help_txt = """Selects the last revision of a specified branch.
 
673
 
 
674
    Supply the path to a branch to select its last revision.
 
675
 
 
676
    Examples::
 
677
 
 
678
      branch:/path/to/branch
336
679
    """
337
680
    prefix = 'branch:'
338
681
 
339
682
    def _match_on(self, branch, revs):
340
 
        from branch import Branch
341
 
        from fetch import greedy_fetch
342
 
        other_branch = Branch.open_containing(self.spec)[0]
 
683
        from bzrlib.branch import Branch
 
684
        other_branch = Branch.open(self.spec)
343
685
        revision_b = other_branch.last_revision()
344
 
        if revision_b is None:
345
 
            raise NoCommits(other_branch)
 
686
        if revision_b in (None, revision.NULL_REVISION):
 
687
            raise errors.NoCommits(other_branch)
346
688
        # pull in the remote revisions so we can diff
347
 
        greedy_fetch(branch, other_branch, revision=revision_b)
 
689
        branch.fetch(other_branch, revision_b)
348
690
        try:
349
691
            revno = branch.revision_id_to_revno(revision_b)
350
 
        except NoSuchRevision:
 
692
        except errors.NoSuchRevision:
351
693
            revno = None
352
694
        return RevisionInfo(branch, revno, revision_b)
353
695
        
354
696
SPEC_TYPES.append(RevisionSpec_branch)
 
697
 
 
698
 
 
699
class RevisionSpec_submit(RevisionSpec_ancestor):
 
700
    """Selects a common ancestor with a submit branch."""
 
701
 
 
702
    help_txt = """Selects a common ancestor with the submit branch.
 
703
 
 
704
    Diffing against this shows all the changes that were made in this branch,
 
705
    and is a good predictor of what merge will do.  The submit branch is
 
706
    used by the bundle and merge directive comands.  If no submit branch
 
707
    is specified, the parent branch is used instead.
 
708
 
 
709
    The common ancestor is the last revision that existed in both
 
710
    branches. Usually this is the branch point, but it could also be
 
711
    a revision that was merged.
 
712
 
 
713
    Examples::
 
714
 
 
715
      $ bzr diff -r submit:
 
716
    """
 
717
 
 
718
    prefix = 'submit:'
 
719
 
 
720
    def _match_on(self, branch, revs):
 
721
        trace.mutter('matching ancestor: on: %s, %s', self.spec, branch)
 
722
        submit_location = branch.get_submit_branch()
 
723
        location_type = 'submit branch'
 
724
        if submit_location is None:
 
725
            submit_location = branch.get_parent()
 
726
            location_type = 'parent branch'
 
727
        if submit_location is None:
 
728
            raise errors.NoSubmitBranch(branch)
 
729
        trace.note('Using %s %s', location_type, submit_location)
 
730
        return self._find_revision_info(branch, submit_location)
 
731
 
 
732
 
 
733
SPEC_TYPES.append(RevisionSpec_submit)