← 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: 2007-03-08 04:06:06 UTC
  • mfrom: (2323.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 2442.
  • Revision ID: robertc@robertcollins.net-20070308040606-84gsniv56huiyjt4
Merge bzr.dev.

Show diffs side-by-side

added added

removed removed

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