~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/log.py

  • Committer: Aaron Bentley
  • Date: 2006-11-10 01:55:55 UTC
  • mto: This revision was merged to the branch mainline in revision 2127.
  • Revision ID: aaron.bentley@utoronto.ca-20061110015555-f48202744b630209
Ignore html docs (both kinds)

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
1
# Copyright (C) 2005 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
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
18
 
 
19
"""Code to show logs of changes.
 
20
 
 
21
Various flavors of log can be produced:
 
22
 
 
23
* for one file, or the whole tree, and (not done yet) for
 
24
  files in a given directory
 
25
 
 
26
* in "verbose" mode with a description of what changed from one
 
27
  version to the next
 
28
 
 
29
* with file-ids and revision-ids shown
 
30
 
 
31
Logs are actually written out through an abstract LogFormatter
 
32
interface, which allows for different preferred formats.  Plugins can
 
33
register formats too.
 
34
 
 
35
Logs can be produced in either forward (oldest->newest) or reverse
 
36
(newest->oldest) order.
 
37
 
 
38
Logs can be filtered to show only revisions matching a particular
 
39
search string, or within a particular range of revisions.  The range
 
40
can be given as date/times, which are reduced to revisions before
 
41
calling in here.
 
42
 
 
43
In verbose mode we show a summary of what changed in each particular
 
44
revision.  Note that this is the delta for changes in that revision
 
45
relative to its mainline parent, not the delta relative to the last
 
46
logged revision.  So for example if you ask for a verbose log of
 
47
changes touching hello.c you will get a list of those revisions also
 
48
listing other things that were changed in the same revision, but not
 
49
all the changes since the previous revision that touched hello.c.
 
50
"""
 
51
 
 
52
# TODO: option to show delta summaries for merged-in revisions
 
53
 
 
54
from itertools import izip
 
55
import re
 
56
 
 
57
from bzrlib import symbol_versioning
 
58
import bzrlib.errors as errors
 
59
from bzrlib.symbol_versioning import deprecated_method, zero_eleven
 
60
from bzrlib.trace import mutter
 
61
from bzrlib.tsort import merge_sort
 
62
 
19
63
 
20
64
def find_touching_revisions(branch, file_id):
21
65
    """Yield a description of revisions which affect the file_id.
25
69
    This is the list of revisions where the file is either added,
26
70
    modified, renamed or deleted.
27
71
 
28
 
    Revisions are returned in chronological order.
29
 
 
30
72
    TODO: Perhaps some way to limit this to only particular revisions,
31
 
    or to traverse a non-branch set of revisions?
32
 
 
33
 
    TODO: If a directory is given, then by default look for all
34
 
    changes under that directory.
 
73
    or to traverse a non-mainline set of revisions?
35
74
    """
36
75
    last_ie = None
37
76
    last_path = None
38
77
    revno = 1
39
78
    for revision_id in branch.revision_history():
40
 
        this_inv = branch.get_revision_inventory(revision_id)
 
79
        this_inv = branch.repository.get_revision_inventory(revision_id)
41
80
        if file_id in this_inv:
42
81
            this_ie = this_inv[file_id]
43
82
            this_path = this_inv.id2path(file_id)
66
105
        revno += 1
67
106
 
68
107
 
 
108
 
 
109
def _enumerate_history(branch):
 
110
    rh = []
 
111
    revno = 1
 
112
    for rev_id in branch.revision_history():
 
113
        rh.append((revno, rev_id))
 
114
        revno += 1
 
115
    return rh
 
116
 
 
117
 
69
118
def show_log(branch,
70
 
             filename=None,
71
 
             show_timezone='original',
 
119
             lf,
 
120
             specific_fileid=None,
72
121
             verbose=False,
73
 
             show_ids=False,
74
 
             to_file=None):
 
122
             direction='reverse',
 
123
             start_revision=None,
 
124
             end_revision=None,
 
125
             search=None):
75
126
    """Write out human-readable log of commits to this branch.
76
127
 
77
 
    filename
 
128
    lf
 
129
        LogFormatter object to show the output.
 
130
 
 
131
    specific_fileid
78
132
        If true, list only the commits affecting the specified
79
133
        file, rather than all commits.
80
134
 
81
 
    show_timezone
82
 
        'original' (committer's timezone),
83
 
        'utc' (universal time), or
84
 
        'local' (local user's timezone)
85
 
 
86
135
    verbose
87
136
        If true show added/changed/deleted/renamed files.
88
137
 
89
 
    show_ids
90
 
        If true, show revision and file ids.
91
 
 
92
 
    to_file
93
 
        File to send log to; by default stdout.
94
 
    """
95
 
    from osutils import format_date
96
 
    from errors import BzrCheckError
97
 
    from diff import compare_inventories
98
 
    from textui import show_status
99
 
    from inventory import Inventory
100
 
 
101
 
    if to_file == None:
 
138
    direction
 
139
        'reverse' (default) is latest to earliest;
 
140
        'forward' is earliest to latest.
 
141
 
 
142
    start_revision
 
143
        If not None, only show revisions >= start_revision
 
144
 
 
145
    end_revision
 
146
        If not None, only show revisions <= end_revision
 
147
    """
 
148
    branch.lock_read()
 
149
    try:
 
150
        _show_log(branch, lf, specific_fileid, verbose, direction,
 
151
                  start_revision, end_revision, search)
 
152
    finally:
 
153
        branch.unlock()
 
154
    
 
155
def _show_log(branch,
 
156
             lf,
 
157
             specific_fileid=None,
 
158
             verbose=False,
 
159
             direction='reverse',
 
160
             start_revision=None,
 
161
             end_revision=None,
 
162
             search=None):
 
163
    """Worker function for show_log - see show_log."""
 
164
    from bzrlib.osutils import format_date
 
165
    from bzrlib.errors import BzrCheckError
 
166
    
 
167
    from warnings import warn
 
168
 
 
169
    if not isinstance(lf, LogFormatter):
 
170
        warn("not a LogFormatter instance: %r" % lf)
 
171
 
 
172
    if specific_fileid:
 
173
        mutter('get log for file_id %r', specific_fileid)
 
174
 
 
175
    if search is not None:
 
176
        import re
 
177
        searchRE = re.compile(search, re.IGNORECASE)
 
178
    else:
 
179
        searchRE = None
 
180
 
 
181
    which_revs = _enumerate_history(branch)
 
182
    
 
183
    if start_revision is None:
 
184
        start_revision = 1
 
185
    else:
 
186
        branch.check_real_revno(start_revision)
 
187
    
 
188
    if end_revision is None:
 
189
        end_revision = len(which_revs)
 
190
    else:
 
191
        branch.check_real_revno(end_revision)
 
192
 
 
193
    # list indexes are 0-based; revisions are 1-based
 
194
    cut_revs = which_revs[(start_revision-1):(end_revision)]
 
195
    if not cut_revs:
 
196
        return
 
197
 
 
198
    # convert the revision history to a dictionary:
 
199
    rev_nos = dict((k, v) for v, k in cut_revs)
 
200
 
 
201
    # override the mainline to look like the revision history.
 
202
    mainline_revs = [revision_id for index, revision_id in cut_revs]
 
203
    if cut_revs[0][0] == 1:
 
204
        mainline_revs.insert(0, None)
 
205
    else:
 
206
        mainline_revs.insert(0, which_revs[start_revision-2][1])
 
207
    # how should we show merged revisions ?
 
208
    # old api: show_merge. New api: show_merge_revno
 
209
    show_merge_revno = getattr(lf, 'show_merge_revno', None)
 
210
    show_merge = getattr(lf, 'show_merge', None)
 
211
    if show_merge is None and show_merge_revno is None:
 
212
        # no merged-revno support
 
213
        include_merges = False
 
214
    else:
 
215
        include_merges = True
 
216
    if show_merge is not None and show_merge_revno is None:
 
217
        # tell developers to update their code
 
218
        symbol_versioning.warn('LogFormatters should provide show_merge_revno '
 
219
            'instead of show_merge since bzr 0.11.',
 
220
            DeprecationWarning, stacklevel=3)
 
221
    view_revisions = list(get_view_revisions(mainline_revs, rev_nos, branch,
 
222
                          direction, include_merges=include_merges))
 
223
 
 
224
    def iter_revisions():
 
225
        # r = revision, n = revno, d = merge depth
 
226
        revision_ids = [r for r, n, d in view_revisions]
 
227
        zeros = set(r for r, n, d in view_revisions if d == 0)
 
228
        num = 9
 
229
        repository = branch.repository
 
230
        while revision_ids:
 
231
            cur_deltas = {}
 
232
            revisions = repository.get_revisions(revision_ids[:num])
 
233
            if verbose or specific_fileid:
 
234
                delta_revisions = [r for r in revisions if
 
235
                                   r.revision_id in zeros]
 
236
                deltas = repository.get_deltas_for_revisions(delta_revisions)
 
237
                cur_deltas = dict(izip((r.revision_id for r in 
 
238
                                        delta_revisions), deltas))
 
239
            for revision in revisions:
 
240
                # The delta value will be None unless
 
241
                # 1. verbose or specific_fileid is specified, and
 
242
                # 2. the revision is a mainline revision
 
243
                yield revision, cur_deltas.get(revision.revision_id)
 
244
            revision_ids  = revision_ids[num:]
 
245
            num = int(num * 1.5)
 
246
            
 
247
    # now we just print all the revisions
 
248
    for ((rev_id, revno, merge_depth), (rev, delta)) in \
 
249
         izip(view_revisions, iter_revisions()):
 
250
 
 
251
        if searchRE:
 
252
            if not searchRE.search(rev.message):
 
253
                continue
 
254
 
 
255
        if merge_depth == 0:
 
256
            # a mainline revision.
 
257
                
 
258
            if specific_fileid:
 
259
                if not delta.touches_file_id(specific_fileid):
 
260
                    continue
 
261
    
 
262
            if not verbose:
 
263
                # although we calculated it, throw it away without display
 
264
                delta = None
 
265
 
 
266
            lf.show(revno, rev, delta)
 
267
        else:
 
268
            if show_merge_revno is None:
 
269
                lf.show_merge(rev, merge_depth)
 
270
            else:
 
271
                lf.show_merge_revno(rev, merge_depth, revno)
 
272
 
 
273
 
 
274
def get_view_revisions(mainline_revs, rev_nos, branch, direction,
 
275
                       include_merges=True):
 
276
    """Produce an iterator of revisions to show
 
277
    :return: an iterator of (revision_id, revno, merge_depth)
 
278
    (if there is no revno for a revision, None is supplied)
 
279
    """
 
280
    if include_merges is False:
 
281
        revision_ids = mainline_revs[1:]
 
282
        if direction == 'reverse':
 
283
            revision_ids.reverse()
 
284
        for revision_id in revision_ids:
 
285
            yield revision_id, str(rev_nos[revision_id]), 0
 
286
        return
 
287
    merge_sorted_revisions = merge_sort(
 
288
        branch.repository.get_revision_graph(mainline_revs[-1]),
 
289
        mainline_revs[-1],
 
290
        mainline_revs,
 
291
        generate_revno=True)
 
292
 
 
293
    if direction == 'forward':
 
294
        # forward means oldest first.
 
295
        merge_sorted_revisions = reverse_by_depth(merge_sorted_revisions)
 
296
    elif direction != 'reverse':
 
297
        raise ValueError('invalid direction %r' % direction)
 
298
 
 
299
    revision_history = branch.revision_history()
 
300
 
 
301
    for sequence, rev_id, merge_depth, revno, end_of_merge in merge_sorted_revisions:
 
302
        yield rev_id, '.'.join(map(str, revno)), merge_depth
 
303
 
 
304
 
 
305
def reverse_by_depth(merge_sorted_revisions, _depth=0):
 
306
    """Reverse revisions by depth.
 
307
 
 
308
    Revisions with a different depth are sorted as a group with the previous
 
309
    revision of that depth.  There may be no topological justification for this,
 
310
    but it looks much nicer.
 
311
    """
 
312
    zd_revisions = []
 
313
    for val in merge_sorted_revisions:
 
314
        if val[2] == _depth:
 
315
            zd_revisions.append([val])
 
316
        else:
 
317
            assert val[2] > _depth
 
318
            zd_revisions[-1].append(val)
 
319
    for revisions in zd_revisions:
 
320
        if len(revisions) > 1:
 
321
            revisions[1:] = reverse_by_depth(revisions[1:], _depth + 1)
 
322
    zd_revisions.reverse()
 
323
    result = []
 
324
    for chunk in zd_revisions:
 
325
        result.extend(chunk)
 
326
    return result
 
327
 
 
328
 
 
329
class LogFormatter(object):
 
330
    """Abstract class to display log messages."""
 
331
 
 
332
    def __init__(self, to_file, show_ids=False, show_timezone='original'):
 
333
        self.to_file = to_file
 
334
        self.show_ids = show_ids
 
335
        self.show_timezone = show_timezone
 
336
 
 
337
    def show(self, revno, rev, delta):
 
338
        raise NotImplementedError('not implemented in abstract base')
 
339
 
 
340
    def short_committer(self, rev):
 
341
        return re.sub('<.*@.*>', '', rev.committer).strip(' ')
 
342
    
 
343
    
 
344
class LongLogFormatter(LogFormatter):
 
345
    def show(self, revno, rev, delta):
 
346
        return self._show_helper(revno=revno, rev=rev, delta=delta)
 
347
 
 
348
    @deprecated_method(zero_eleven)
 
349
    def show_merge(self, rev, merge_depth):
 
350
        return self._show_helper(rev=rev, indent='    '*merge_depth, merged=True, delta=None)
 
351
 
 
352
    def show_merge_revno(self, rev, merge_depth, revno):
 
353
        """Show a merged revision rev, with merge_depth and a revno."""
 
354
        return self._show_helper(rev=rev, revno=revno,
 
355
            indent='    '*merge_depth, merged=True, delta=None)
 
356
 
 
357
    def _show_helper(self, rev=None, revno=None, indent='', merged=False, delta=None):
 
358
        """Show a revision, either merged or not."""
 
359
        from bzrlib.osutils import format_date
 
360
        to_file = self.to_file
 
361
        print >>to_file,  indent+'-' * 60
 
362
        if revno is not None:
 
363
            print >>to_file,  indent+'revno:', revno
 
364
        if merged:
 
365
            print >>to_file,  indent+'merged:', rev.revision_id
 
366
        elif self.show_ids:
 
367
            print >>to_file,  indent+'revision-id:', rev.revision_id
 
368
        if self.show_ids:
 
369
            for parent_id in rev.parent_ids:
 
370
                print >>to_file, indent+'parent:', parent_id
 
371
        print >>to_file,  indent+'committer:', rev.committer
 
372
        try:
 
373
            print >>to_file, indent+'branch nick: %s' % \
 
374
                rev.properties['branch-nick']
 
375
        except KeyError:
 
376
            pass
 
377
        date_str = format_date(rev.timestamp,
 
378
                               rev.timezone or 0,
 
379
                               self.show_timezone)
 
380
        print >>to_file,  indent+'timestamp: %s' % date_str
 
381
 
 
382
        print >>to_file,  indent+'message:'
 
383
        if not rev.message:
 
384
            print >>to_file,  indent+'  (no message)'
 
385
        else:
 
386
            message = rev.message.rstrip('\r\n')
 
387
            for l in message.split('\n'):
 
388
                print >>to_file,  indent+'  ' + l
 
389
        if delta is not None:
 
390
            delta.show(to_file, self.show_ids)
 
391
 
 
392
 
 
393
class ShortLogFormatter(LogFormatter):
 
394
    def show(self, revno, rev, delta):
 
395
        from bzrlib.osutils import format_date
 
396
 
 
397
        to_file = self.to_file
 
398
        date_str = format_date(rev.timestamp, rev.timezone or 0,
 
399
                            self.show_timezone)
 
400
        print >>to_file, "%5s %s\t%s" % (revno, self.short_committer(rev),
 
401
                format_date(rev.timestamp, rev.timezone or 0,
 
402
                            self.show_timezone, date_fmt="%Y-%m-%d",
 
403
                           show_offset=False))
 
404
        if self.show_ids:
 
405
            print >>to_file,  '      revision-id:', rev.revision_id
 
406
        if not rev.message:
 
407
            print >>to_file,  '      (no message)'
 
408
        else:
 
409
            message = rev.message.rstrip('\r\n')
 
410
            for l in message.split('\n'):
 
411
                print >>to_file,  '      ' + l
 
412
 
 
413
        # TODO: Why not show the modified files in a shorter form as
 
414
        # well? rewrap them single lines of appropriate length
 
415
        if delta is not None:
 
416
            delta.show(to_file, self.show_ids)
 
417
        print >>to_file, ''
 
418
 
 
419
 
 
420
class LineLogFormatter(LogFormatter):
 
421
    def truncate(self, str, max_len):
 
422
        if len(str) <= max_len:
 
423
            return str
 
424
        return str[:max_len-3]+'...'
 
425
 
 
426
    def date_string(self, rev):
 
427
        from bzrlib.osutils import format_date
 
428
        return format_date(rev.timestamp, rev.timezone or 0, 
 
429
                           self.show_timezone, date_fmt="%Y-%m-%d",
 
430
                           show_offset=False)
 
431
 
 
432
    def message(self, rev):
 
433
        if not rev.message:
 
434
            return '(no message)'
 
435
        else:
 
436
            return rev.message
 
437
 
 
438
    def show(self, revno, rev, delta):
 
439
        from bzrlib.osutils import terminal_width
 
440
        print >> self.to_file, self.log_string(revno, rev, terminal_width()-1)
 
441
 
 
442
    def log_string(self, revno, rev, max_chars):
 
443
        """Format log info into one string. Truncate tail of string
 
444
        :param  revno:      revision number (int) or None.
 
445
                            Revision numbers counts from 1.
 
446
        :param  rev:        revision info object
 
447
        :param  max_chars:  maximum length of resulting string
 
448
        :return:            formatted truncated string
 
449
        """
 
450
        out = []
 
451
        if revno:
 
452
            # show revno only when is not None
 
453
            out.append("%s:" % revno)
 
454
        out.append(self.truncate(self.short_committer(rev), 20))
 
455
        out.append(self.date_string(rev))
 
456
        out.append(rev.get_summary())
 
457
        return self.truncate(" ".join(out).rstrip('\n'), max_chars)
 
458
 
 
459
 
 
460
def line_log(rev, max_chars):
 
461
    lf = LineLogFormatter(None)
 
462
    return lf.log_string(None, rev, max_chars)
 
463
 
 
464
FORMATTERS = {
 
465
              'long': LongLogFormatter,
 
466
              'short': ShortLogFormatter,
 
467
              'line': LineLogFormatter,
 
468
              }
 
469
 
 
470
def register_formatter(name, formatter):
 
471
    FORMATTERS[name] = formatter
 
472
 
 
473
def log_formatter(name, *args, **kwargs):
 
474
    """Construct a formatter from arguments.
 
475
 
 
476
    name -- Name of the formatter to construct; currently 'long', 'short' and
 
477
        'line' are supported.
 
478
    """
 
479
    from bzrlib.errors import BzrCommandError
 
480
    try:
 
481
        return FORMATTERS[name](*args, **kwargs)
 
482
    except KeyError:
 
483
        raise BzrCommandError("unknown log formatter: %r" % name)
 
484
 
 
485
def show_one_log(revno, rev, delta, verbose, to_file, show_timezone):
 
486
    # deprecated; for compatibility
 
487
    lf = LongLogFormatter(to_file=to_file, show_timezone=show_timezone)
 
488
    lf.show(revno, rev, delta)
 
489
 
 
490
def show_changed_revisions(branch, old_rh, new_rh, to_file=None, log_format='long'):
 
491
    """Show the change in revision history comparing the old revision history to the new one.
 
492
 
 
493
    :param branch: The branch where the revisions exist
 
494
    :param old_rh: The old revision history
 
495
    :param new_rh: The new revision history
 
496
    :param to_file: A file to write the results to. If None, stdout will be used
 
497
    """
 
498
    if to_file is None:
102
499
        import sys
103
 
        to_file = sys.stdout
104
 
 
105
 
    if filename:
106
 
        file_id = branch.read_working_inventory().path2id(filename)
107
 
        def which_revs():
108
 
            for revno, revid, why in find_touching_revisions(branch, file_id):
109
 
                yield revno, revid
110
 
    else:
111
 
        def which_revs():
112
 
            for i, revid in enumerate(branch.revision_history()):
113
 
                yield i+1, revid
114
 
        
115
 
    branch._need_readlock()
116
 
    precursor = None
117
 
    if verbose:
118
 
        prev_inv = Inventory()
119
 
    for revno, revision_id in which_revs():
120
 
        print >>to_file,  '-' * 60
121
 
        print >>to_file,  'revno:', revno
122
 
        rev = branch.get_revision(revision_id)
123
 
        if show_ids:
124
 
            print >>to_file,  'revision-id:', revision_id
125
 
        print >>to_file,  'committer:', rev.committer
126
 
        print >>to_file,  'timestamp: %s' % (format_date(rev.timestamp, rev.timezone or 0,
127
 
                                             show_timezone))
128
 
 
129
 
        if revision_id != rev.revision_id:
130
 
            raise BzrCheckError("retrieved wrong revision: %r"
131
 
                                % (revision_id, rev.revision_id))
132
 
 
133
 
        print >>to_file,  'message:'
134
 
        if not rev.message:
135
 
            print >>to_file,  '  (no message)'
136
 
        else:
137
 
            for l in rev.message.split('\n'):
138
 
                print >>to_file,  '  ' + l
139
 
 
140
 
        # Don't show a list of changed files if we were asked about
141
 
        # one specific file.
142
 
 
143
 
        if verbose and not filename:
144
 
            this_inv = branch.get_inventory(rev.inventory_id)
145
 
            delta = compare_inventories(prev_inv, this_inv)
146
 
 
147
 
            if delta.removed:
148
 
                print >>to_file, 'removed files:'
149
 
                for path, fid in delta.removed:
150
 
                    if show_ids:
151
 
                        print >>to_file, '  %-30s %s' % (path, fid)
152
 
                    else:
153
 
                        print >>to_file, ' ', path
154
 
            if delta.added:
155
 
                print >>to_file, 'added files:'
156
 
                for path, fid in delta.added:
157
 
                    if show_ids:
158
 
                        print >>to_file, '  %-30s %s' % (path, fid)
159
 
                    else:
160
 
                        print >>to_file, '  ' + path
161
 
            if delta.renamed:
162
 
                print >>to_file, 'renamed files:'
163
 
                for oldpath, newpath, fid in delta.renamed:
164
 
                    if show_ids:
165
 
                        print >>to_file, '  %s => %s %s' % (oldpath, newpath, fid)
166
 
                    else:
167
 
                        print >>to_file, '  %s => %s' % (oldpath, newpath)
168
 
            if delta.modified:
169
 
                print >>to_file, 'modified files:'
170
 
                for path, fid in delta.modified:
171
 
                    if show_ids:
172
 
                        print >>to_file, '  %-30s %s' % (path, fid)
173
 
                    else:
174
 
                        print >>to_file, '  ' + path
175
 
 
176
 
            prev_inv = this_inv
177
 
 
178
 
        precursor = revision_id
 
500
        import codecs
 
501
        import bzrlib
 
502
        to_file = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
 
503
    lf = log_formatter(log_format,
 
504
                       show_ids=False,
 
505
                       to_file=to_file,
 
506
                       show_timezone='original')
 
507
 
 
508
    # This is the first index which is different between
 
509
    # old and new
 
510
    base_idx = None
 
511
    for i in xrange(max(len(new_rh),
 
512
                        len(old_rh))):
 
513
        if (len(new_rh) <= i
 
514
            or len(old_rh) <= i
 
515
            or new_rh[i] != old_rh[i]):
 
516
            base_idx = i
 
517
            break
 
518
 
 
519
    if base_idx is None:
 
520
        to_file.write('Nothing seems to have changed\n')
 
521
        return
 
522
    ## TODO: It might be nice to do something like show_log
 
523
    ##       and show the merged entries. But since this is the
 
524
    ##       removed revisions, it shouldn't be as important
 
525
    if base_idx < len(old_rh):
 
526
        to_file.write('*'*60)
 
527
        to_file.write('\nRemoved Revisions:\n')
 
528
        for i in range(base_idx, len(old_rh)):
 
529
            rev = branch.repository.get_revision(old_rh[i])
 
530
            lf.show(i+1, rev, None)
 
531
        to_file.write('*'*60)
 
532
        to_file.write('\n\n')
 
533
    if base_idx < len(new_rh):
 
534
        to_file.write('Added Revisions:\n')
 
535
        show_log(branch,
 
536
                 lf,
 
537
                 None,
 
538
                 verbose=True,
 
539
                 direction='forward',
 
540
                 start_revision=base_idx+1,
 
541
                 end_revision=len(new_rh),
 
542
                 search=None)
179
543