/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/log.py

  • Committer: Andrew Bennetts
  • Date: 2008-03-27 06:10:18 UTC
  • mfrom: (3309 +trunk)
  • mto: This revision was merged to the branch mainline in revision 3320.
  • Revision ID: andrew.bennetts@canonical.com-20080327061018-dxztpxyv6yoeg3am
Merge from bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/log.py
63
63
    config,
64
64
    lazy_regex,
65
65
    registry,
66
 
    symbol_versioning,
67
66
    )
68
67
from bzrlib.errors import (
69
68
    BzrCommandError,
79
78
from bzrlib.revisionspec import (
80
79
    RevisionInfo,
81
80
    )
82
 
from bzrlib.symbol_versioning import (
83
 
    deprecated_method,
84
 
    zero_seventeen,
85
 
    )
86
81
from bzrlib.trace import mutter
87
82
from bzrlib.tsort import (
88
83
    merge_sort,
193
188
    finally:
194
189
        branch.unlock()
195
190
 
 
191
 
196
192
def _show_log(branch,
197
193
             lf,
198
194
             specific_fileid=None,
208
204
 
209
205
    if specific_fileid:
210
206
        mutter('get log for file_id %r', specific_fileid)
211
 
 
 
207
    generate_merge_revisions = getattr(lf, 'supports_merge_revisions', False)
 
208
    allow_single_merge_revision = getattr(lf,
 
209
        'supports_single_merge_revision', False)
 
210
    view_revisions = calculate_view_revisions(branch, start_revision,
 
211
                                              end_revision, direction,
 
212
                                              specific_fileid,
 
213
                                              generate_merge_revisions,
 
214
                                              allow_single_merge_revision)
212
215
    if search is not None:
213
216
        searchRE = re.compile(search, re.IGNORECASE)
214
217
    else:
215
218
        searchRE = None
216
219
 
 
220
    rev_tag_dict = {}
 
221
    generate_tags = getattr(lf, 'supports_tags', False)
 
222
    if generate_tags:
 
223
        if branch.supports_tags():
 
224
            rev_tag_dict = branch.tags.get_reverse_tag_dict()
 
225
 
 
226
    generate_delta = verbose and getattr(lf, 'supports_delta', False)
 
227
 
 
228
    # now we just print all the revisions
 
229
    log_count = 0
 
230
    for (rev_id, revno, merge_depth), rev, delta in _iter_revisions(
 
231
        branch.repository, view_revisions, generate_delta):
 
232
        if searchRE:
 
233
            if not searchRE.search(rev.message):
 
234
                continue
 
235
 
 
236
        lr = LogRevision(rev, revno, merge_depth, delta,
 
237
                         rev_tag_dict.get(rev_id))
 
238
        lf.log_revision(lr)
 
239
        if limit:
 
240
            log_count += 1
 
241
            if log_count >= limit:
 
242
                break
 
243
 
 
244
 
 
245
def calculate_view_revisions(branch, start_revision, end_revision, direction,
 
246
                             specific_fileid, generate_merge_revisions,
 
247
                             allow_single_merge_revision):
 
248
    if (not generate_merge_revisions and start_revision is end_revision is
 
249
        None and direction == 'reverse' and specific_fileid is None):
 
250
        return _linear_view_revisions(branch)
 
251
 
217
252
    mainline_revs, rev_nos, start_rev_id, end_rev_id = \
218
253
        _get_mainline_revs(branch, start_revision, end_revision)
219
254
    if not mainline_revs:
220
 
        return
 
255
        return []
221
256
 
222
257
    if direction == 'reverse':
223
258
        start_rev_id, end_rev_id = end_rev_id, start_rev_id
224
 
        
225
 
    legacy_lf = getattr(lf, 'log_revision', None) is None
226
 
    if legacy_lf:
227
 
        # pre-0.17 formatters use show for mainline revisions.
228
 
        # how should we show merged revisions ?
229
 
        #   pre-0.11 api: show_merge
230
 
        #   0.11-0.16 api: show_merge_revno
231
 
        show_merge_revno = getattr(lf, 'show_merge_revno', None)
232
 
        show_merge = getattr(lf, 'show_merge', None)
233
 
        if show_merge is None and show_merge_revno is None:
234
 
            # no merged-revno support
235
 
            generate_merge_revisions = False
236
 
        else:
237
 
            generate_merge_revisions = True
238
 
        # tell developers to update their code
239
 
        symbol_versioning.warn('LogFormatters should provide log_revision '
240
 
            'instead of show and show_merge_revno since bzr 0.17.',
241
 
            DeprecationWarning, stacklevel=3)
242
 
    else:
243
 
        generate_merge_revisions = getattr(lf, 'supports_merge_revisions', 
244
 
                                           False)
 
259
 
245
260
    generate_single_revision = False
246
261
    if ((not generate_merge_revisions)
247
262
        and ((start_rev_id and (start_rev_id not in rev_nos))
248
263
            or (end_rev_id and (end_rev_id not in rev_nos)))):
249
264
        generate_single_revision = ((start_rev_id == end_rev_id)
250
 
            and getattr(lf, 'supports_single_merge_revision', False))
 
265
            and allow_single_merge_revision)
251
266
        if not generate_single_revision:
252
267
            raise BzrCommandError('Selected log formatter only supports '
253
268
                'mainline revisions.')
271
286
        min_depth = min([d for r,n,d in view_revisions])
272
287
        if min_depth != 0:
273
288
            view_revisions = [(r,n,d-min_depth) for r,n,d in view_revisions]
274
 
        
275
 
    rev_tag_dict = {}
276
 
    generate_tags = getattr(lf, 'supports_tags', False)
277
 
    if generate_tags:
278
 
        if branch.supports_tags():
279
 
            rev_tag_dict = branch.tags.get_reverse_tag_dict()
280
 
 
281
 
    generate_delta = verbose and getattr(lf, 'supports_delta', False)
282
 
 
283
 
    def iter_revisions():
 
289
    return view_revisions
 
290
 
 
291
 
 
292
def _linear_view_revisions(branch):
 
293
    start_revno, start_revision_id = branch.last_revision_info()
 
294
    repo = branch.repository
 
295
    revision_ids = repo.iter_reverse_revision_history(start_revision_id)
 
296
    for num, revision_id in enumerate(revision_ids):
 
297
        yield revision_id, str(start_revno - num), 0
 
298
 
 
299
 
 
300
def _iter_revisions(repository, view_revisions, generate_delta):
 
301
    num = 9
 
302
    view_revisions = iter(view_revisions)
 
303
    while True:
 
304
        cur_view_revisions = [d for x, d in zip(range(num), view_revisions)]
 
305
        if len(cur_view_revisions) == 0:
 
306
            break
 
307
        cur_deltas = {}
284
308
        # r = revision, n = revno, d = merge depth
285
 
        revision_ids = [r for r, n, d in view_revisions]
286
 
        num = 9
287
 
        repository = branch.repository
288
 
        while revision_ids:
289
 
            cur_deltas = {}
290
 
            revisions = repository.get_revisions(revision_ids[:num])
291
 
            if generate_delta:
292
 
                deltas = repository.get_deltas_for_revisions(revisions)
293
 
                cur_deltas = dict(izip((r.revision_id for r in revisions),
294
 
                                       deltas))
295
 
            for revision in revisions:
296
 
                yield revision, cur_deltas.get(revision.revision_id)
297
 
            revision_ids  = revision_ids[num:]
298
 
            num = min(int(num * 1.5), 200)
299
 
 
300
 
    # now we just print all the revisions
301
 
    log_count = 0
302
 
    for ((rev_id, revno, merge_depth), (rev, delta)) in \
303
 
         izip(view_revisions, iter_revisions()):
304
 
 
305
 
        if searchRE:
306
 
            if not searchRE.search(rev.message):
307
 
                continue
308
 
 
309
 
        if not legacy_lf:
310
 
            lr = LogRevision(rev, revno, merge_depth, delta,
311
 
                             rev_tag_dict.get(rev_id))
312
 
            lf.log_revision(lr)
313
 
        else:
314
 
            # support for legacy (pre-0.17) LogFormatters
315
 
            if merge_depth == 0:
316
 
                if generate_tags:
317
 
                    lf.show(revno, rev, delta, rev_tag_dict.get(rev_id))
318
 
                else:
319
 
                    lf.show(revno, rev, delta)
320
 
            else:
321
 
                if show_merge_revno is None:
322
 
                    lf.show_merge(rev, merge_depth)
323
 
                else:
324
 
                    if generate_tags:
325
 
                        lf.show_merge_revno(rev, merge_depth, revno,
326
 
                                            rev_tag_dict.get(rev_id))
327
 
                    else:
328
 
                        lf.show_merge_revno(rev, merge_depth, revno)
329
 
        if limit:
330
 
            log_count += 1
331
 
            if log_count >= limit:
332
 
                break
 
309
        revision_ids = [r for (r, n, d) in cur_view_revisions]
 
310
        revisions = repository.get_revisions(revision_ids)
 
311
        if generate_delta:
 
312
            deltas = repository.get_deltas_for_revisions(revisions)
 
313
            cur_deltas = dict(izip((r.revision_id for r in revisions),
 
314
                                   deltas))
 
315
        for view_data, revision in izip(cur_view_revisions, revisions):
 
316
            yield view_data, revision, cur_deltas.get(revision.revision_id)
 
317
        num = min(int(num * 1.5), 200)
333
318
 
334
319
 
335
320
def _get_mainline_revs(branch, start_revision, end_revision):
616
601
#        """
617
602
#        raise NotImplementedError('not implemented in abstract base')
618
603
 
619
 
    @deprecated_method(zero_seventeen)
620
 
    def show(self, revno, rev, delta):
621
 
        raise NotImplementedError('not implemented in abstract base')
622
 
 
623
604
    def short_committer(self, rev):
624
605
        name, address = config.parse_username(rev.committer)
625
606
        if name:
639
620
    supports_delta = True
640
621
    supports_tags = True
641
622
 
642
 
    @deprecated_method(zero_seventeen)
643
 
    def show(self, revno, rev, delta, tags=None):
644
 
        lr = LogRevision(rev, revno, 0, delta, tags)
645
 
        return self.log_revision(lr)
646
 
 
647
 
    @deprecated_method(zero_seventeen)
648
 
    def show_merge_revno(self, rev, merge_depth, revno, tags=None):
649
 
        """Show a merged revision rev, with merge_depth and a revno."""
650
 
        lr = LogRevision(rev, revno, merge_depth, tags=tags)
651
 
        return self.log_revision(lr)
652
 
 
653
623
    def log_revision(self, revision):
654
624
        """Log a revision, either merged or not."""
655
625
        indent = '    ' * revision.merge_depth
660
630
        if revision.tags:
661
631
            to_file.write(indent + 'tags: %s\n' % (', '.join(revision.tags)))
662
632
        if self.show_ids:
663
 
            to_file.write(indent + 'revision-id:' + revision.rev.revision_id)
 
633
            to_file.write(indent + 'revision-id: ' + revision.rev.revision_id)
664
634
            to_file.write('\n')
665
635
            for parent_id in revision.rev.parent_ids:
666
636
                to_file.write(indent + 'parent: %s\n' % (parent_id,))
695
665
    supports_delta = True
696
666
    supports_single_merge_revision = True
697
667
 
698
 
    @deprecated_method(zero_seventeen)
699
 
    def show(self, revno, rev, delta):
700
 
        lr = LogRevision(rev, revno, 0, delta)
701
 
        return self.log_revision(lr)
702
 
 
703
668
    def log_revision(self, revision):
704
669
        to_file = self.to_file
705
670
        date_str = format_date(revision.rev.timestamp,
755
720
        else:
756
721
            return rev.message
757
722
 
758
 
    @deprecated_method(zero_seventeen)
759
 
    def show(self, revno, rev, delta):
760
 
        self.to_file.write(self.log_string(revno, rev, terminal_width()-1))
761
 
        self.to_file.write('\n')
762
 
 
763
723
    def log_revision(self, revision):
764
724
        self.to_file.write(self.log_string(revision.revno, revision.rev,
765
725
                                              self._max_chars))