← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/log.py

  • Committer: John Arbash Meinel
  • Date: 2006-12-20 16:55:18 UTC
  • mto: This revision was merged to the branch mainline in revision 2205.
  • Revision ID: john@arbash-meinel.com-20061220165518-32ly6wupiitpuupr
'bzr missing -v' was showing adds as deletes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/log.py
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
28
28
 
29
29
* with file-ids and revision-ids shown
30
30
 
31
 
* from last to first or (not anymore) from first to last;
32
 
  the default is "reversed" because it shows the likely most
33
 
  relevant and interesting information first
34
 
 
35
 
* (not yet) in XML format
 
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.
36
50
"""
37
51
 
38
 
 
39
 
from trace import mutter
 
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
 
40
63
 
41
64
def find_touching_revisions(branch, file_id):
42
65
    """Yield a description of revisions which affect the file_id.
53
76
    last_path = None
54
77
    revno = 1
55
78
    for revision_id in branch.revision_history():
56
 
        this_inv = branch.get_revision_inventory(revision_id)
 
79
        this_inv = branch.repository.get_revision_inventory(revision_id)
57
80
        if file_id in this_inv:
58
81
            this_ie = this_inv[file_id]
59
82
            this_path = this_inv.id2path(file_id)
83
106
 
84
107
 
85
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
 
86
118
def show_log(branch,
 
119
             lf,
87
120
             specific_fileid=None,
88
 
             show_timezone='original',
89
121
             verbose=False,
90
 
             show_ids=False,
91
 
             to_file=None,
92
122
             direction='reverse',
93
123
             start_revision=None,
94
 
             end_revision=None):
 
124
             end_revision=None,
 
125
             search=None):
95
126
    """Write out human-readable log of commits to this branch.
96
127
 
 
128
    lf
 
129
        LogFormatter object to show the output.
 
130
 
97
131
    specific_fileid
98
132
        If true, list only the commits affecting the specified
99
133
        file, rather than all commits.
100
134
 
101
 
    show_timezone
102
 
        'original' (committer's timezone),
103
 
        'utc' (universal time), or
104
 
        'local' (local user's timezone)
105
 
 
106
135
    verbose
107
136
        If true show added/changed/deleted/renamed files.
108
137
 
109
 
    show_ids
110
 
        If true, show revision and file ids.
111
 
 
112
 
    to_file
113
 
        File to send log to; by default stdout.
114
 
 
115
138
    direction
116
139
        'reverse' (default) is latest to earliest;
117
140
        'forward' is earliest to latest.
122
145
    end_revision
123
146
        If not None, only show revisions <= end_revision
124
147
    """
125
 
    from osutils import format_date
126
 
    from errors import BzrCheckError
127
 
    from textui import show_status
 
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
128
168
 
 
169
    if not isinstance(lf, LogFormatter):
 
170
        warn("not a LogFormatter instance: %r" % lf)
129
171
 
130
172
    if specific_fileid:
131
 
        mutter('get log for file_id %r' % specific_fileid)
132
 
 
133
 
    if to_file == None:
 
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:
134
499
        import sys
135
 
        to_file = sys.stdout
136
 
 
137
 
    which_revs = branch.enum_history(direction)
138
 
 
139
 
    if not (verbose or specific_fileid):
140
 
        # no need to know what changed between revisions
141
 
        with_deltas = deltas_for_log_dummy(branch, which_revs)
142
 
    elif direction == 'reverse':
143
 
        with_deltas = deltas_for_log_reverse(branch, which_revs)
144
 
    else:        
145
 
        raise NotImplementedError("sorry, verbose forward logs not done yet")
146
 
 
147
 
    for revno, rev, delta in with_deltas:
148
 
        if specific_fileid:
149
 
            if not delta.touches_file_id(specific_fileid):
150
 
                continue
151
 
 
152
 
        if start_revision is not None and revno < start_revision:
153
 
            continue
154
 
 
155
 
        if end_revision is not None and revno > end_revision:
156
 
            continue
157
 
        
158
 
        if not verbose:
159
 
            # although we calculated it, throw it away without display
160
 
            delta = None
161
 
            
162
 
        show_one_log(revno, rev, delta, show_ids, to_file, show_timezone)
163
 
 
164
 
 
165
 
 
166
 
def deltas_for_log_dummy(branch, which_revs):
167
 
    for revno, revision_id in which_revs:
168
 
        yield revno, branch.get_revision(revision_id), None
169
 
 
170
 
 
171
 
def deltas_for_log_reverse(branch, which_revs):
172
 
    """Compute deltas for display in reverse log.
173
 
 
174
 
    Given a sequence of (revno, revision_id) pairs, return
175
 
    (revno, rev, delta).
176
 
 
177
 
    The delta is from the given revision to the next one in the
178
 
    sequence, which makes sense if the log is being displayed from
179
 
    newest to oldest.
180
 
    """
181
 
    from tree import EmptyTree
182
 
    from diff import compare_trees
183
 
    
184
 
    last_revno = last_revision_id = last_tree = None
185
 
    for revno, revision_id in which_revs:
186
 
        this_tree = branch.revision_tree(revision_id)
187
 
        this_revision = branch.get_revision(revision_id)
188
 
        
189
 
        if last_revno:
190
 
            yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
191
 
 
192
 
        last_revno = revno
193
 
        last_revision = this_revision
194
 
        last_tree = this_tree
195
 
 
196
 
    if last_revno:
197
 
        this_tree = EmptyTree()
198
 
        yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
199
 
 
200
 
 
201
 
 
202
 
def junk():
203
 
    precursor = None
204
 
    if verbose:
205
 
        from tree import EmptyTree
206
 
        prev_tree = EmptyTree()
207
 
    for revno, revision_id in which_revs:
208
 
        precursor = revision_id
209
 
 
210
 
    if revision_id != rev.revision_id:
211
 
        raise BzrCheckError("retrieved wrong revision: %r"
212
 
                            % (revision_id, rev.revision_id))
213
 
 
214
 
    if verbose:
215
 
        this_tree = branch.revision_tree(revision_id)
216
 
        delta = compare_trees(prev_tree, this_tree, want_unchanged=False)
217
 
        prev_tree = this_tree
218
 
    else:
219
 
        delta = None    
220
 
 
221
 
 
222
 
 
223
 
def show_one_log(revno, rev, delta, show_ids, to_file, show_timezone):
224
 
    from osutils import format_date
225
 
    
226
 
    print >>to_file,  '-' * 60
227
 
    print >>to_file,  'revno:', revno
228
 
    if show_ids:
229
 
        print >>to_file,  'revision-id:', rev.revision_id
230
 
    print >>to_file,  'committer:', rev.committer
231
 
    print >>to_file,  'timestamp: %s' % (format_date(rev.timestamp, rev.timezone or 0,
232
 
                                         show_timezone))
233
 
 
234
 
    print >>to_file,  'message:'
235
 
    if not rev.message:
236
 
        print >>to_file,  '  (no message)'
237
 
    else:
238
 
        for l in rev.message.split('\n'):
239
 
            print >>to_file,  '  ' + l
240
 
 
241
 
    if delta != None:
242
 
        delta.show(to_file, show_ids)
 
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)
 
543