← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/log.py

  • Committer: Martin Pool
  • Date: 2006-11-02 10:20:19 UTC
  • mfrom: (2114 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2119.
  • Revision ID: mbp@sourcefrog.net-20061102102019-9a5a02f485dff6f6
merge bzr.dev and reconcile several changes, also some test fixes

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
49
49
all the changes since the previous revision that touched hello.c.
50
50
"""
51
51
 
52
 
 
 
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
53
58
import bzrlib.errors as errors
54
 
from bzrlib.tree import EmptyTree
55
 
from bzrlib.delta import compare_trees
 
59
from bzrlib.symbol_versioning import deprecated_method, zero_eleven
56
60
from bzrlib.trace import mutter
57
 
import re
 
61
from bzrlib.tsort import merge_sort
58
62
 
59
63
 
60
64
def find_touching_revisions(branch, file_id):
72
76
    last_path = None
73
77
    revno = 1
74
78
    for revision_id in branch.revision_history():
75
 
        this_inv = branch.get_revision_inventory(revision_id)
 
79
        this_inv = branch.repository.get_revision_inventory(revision_id)
76
80
        if file_id in this_inv:
77
81
            this_ie = this_inv[file_id]
78
82
            this_path = this_inv.id2path(file_id)
111
115
    return rh
112
116
 
113
117
 
114
 
def _get_revision_delta(branch, revno):
115
 
    """Return the delta for a mainline revision.
116
 
    
117
 
    This is used to show summaries in verbose logs, and also for finding 
118
 
    revisions which touch a given file."""
119
 
    # XXX: What are we supposed to do when showing a summary for something 
120
 
    # other than a mainline revision.  The delta to it's first parent, or
121
 
    # (more useful) the delta to a nominated other revision.
122
 
    return branch.get_revision_delta(revno)
123
 
 
124
 
 
125
118
def show_log(branch,
126
119
             lf,
127
120
             specific_fileid=None,
170
163
    """Worker function for show_log - see show_log."""
171
164
    from bzrlib.osutils import format_date
172
165
    from bzrlib.errors import BzrCheckError
173
 
    from bzrlib.textui import show_status
174
166
    
175
167
    from warnings import warn
176
168
 
178
170
        warn("not a LogFormatter instance: %r" % lf)
179
171
 
180
172
    if specific_fileid:
181
 
        mutter('get log for file_id %r' % specific_fileid)
 
173
        mutter('get log for file_id %r', specific_fileid)
182
174
 
183
175
    if search is not None:
184
176
        import re
200
192
 
201
193
    # list indexes are 0-based; revisions are 1-based
202
194
    cut_revs = which_revs[(start_revision-1):(end_revision)]
203
 
 
204
 
    if direction == 'reverse':
205
 
        cut_revs.reverse()
206
 
    elif direction == 'forward':
207
 
        pass
208
 
    else:
 
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':
209
297
        raise ValueError('invalid direction %r' % direction)
210
298
 
211
299
    revision_history = branch.revision_history()
212
 
    for revno, rev_id in cut_revs:
213
 
        if verbose or specific_fileid:
214
 
            delta = _get_revision_delta(branch, revno)
215
 
            
216
 
        if specific_fileid:
217
 
            if not delta.touches_file_id(specific_fileid):
218
 
                continue
219
 
 
220
 
        if not verbose:
221
 
            # although we calculated it, throw it away without display
222
 
            delta = None
223
 
 
224
 
        rev = branch.get_revision(rev_id)
225
 
 
226
 
        if searchRE:
227
 
            if not searchRE.search(rev.message):
228
 
                continue
229
 
 
230
 
        lf.show(revno, rev, delta)
231
 
        if hasattr(lf, 'show_merge'):
232
 
            if revno == 1:
233
 
                excludes = set()
234
 
            else:
235
 
                # revno is 1 based, so -2 to get back 1 less.
236
 
                excludes = set(branch.get_ancestry(revision_history[revno - 2]))
237
 
            pending = list(rev.parent_ids)
238
 
            while pending:
239
 
                rev_id = pending.pop()
240
 
                if rev_id in excludes:
241
 
                    continue
242
 
                # prevent showing merged revs twice if they multi-path.
243
 
                excludes.add(rev_id)
244
 
                try:
245
 
                    rev = branch.get_revision(rev_id)
246
 
                except errors.NoSuchRevision:
247
 
                    continue
248
 
                pending.extend(rev.parent_ids)
249
 
                lf.show_merge(rev)
250
 
 
251
 
 
252
 
def deltas_for_log_dummy(branch, which_revs):
253
 
    """Return all the revisions without intermediate deltas.
254
 
 
255
 
    Useful for log commands that won't need the delta information.
256
 
    """
257
 
    
258
 
    for revno, revision_id in which_revs:
259
 
        yield revno, branch.get_revision(revision_id), None
260
 
 
261
 
 
262
 
def deltas_for_log_reverse(branch, which_revs):
263
 
    """Compute deltas for display in latest-to-earliest order.
264
 
 
265
 
    branch
266
 
        Branch to traverse
267
 
 
268
 
    which_revs
269
 
        Sequence of (revno, revision_id) for the subset of history to examine
270
 
 
271
 
    returns 
272
 
        Sequence of (revno, rev, delta)
273
 
 
274
 
    The delta is from the given revision to the next one in the
275
 
    sequence, which makes sense if the log is being displayed from
276
 
    newest to oldest.
277
 
    """
278
 
    last_revno = last_revision_id = last_tree = None
279
 
    for revno, revision_id in which_revs:
280
 
        this_tree = branch.revision_tree(revision_id)
281
 
        this_revision = branch.get_revision(revision_id)
282
 
        
283
 
        if last_revno:
284
 
            yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
285
 
 
286
 
        this_tree = EmptyTree(branch.get_root_id())
287
 
 
288
 
        last_revno = revno
289
 
        last_revision = this_revision
290
 
        last_tree = this_tree
291
 
 
292
 
    if last_revno:
293
 
        if last_revno == 1:
294
 
            this_tree = EmptyTree(branch.get_root_id())
 
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])
295
316
        else:
296
 
            this_revno = last_revno - 1
297
 
            this_revision_id = branch.revision_history()[this_revno]
298
 
            this_tree = branch.revision_tree(this_revision_id)
299
 
        yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
300
 
 
301
 
 
302
 
def deltas_for_log_forward(branch, which_revs):
303
 
    """Compute deltas for display in forward log.
304
 
 
305
 
    Given a sequence of (revno, revision_id) pairs, return
306
 
    (revno, rev, delta).
307
 
 
308
 
    The delta is from the given revision to the next one in the
309
 
    sequence, which makes sense if the log is being displayed from
310
 
    newest to oldest.
311
 
    """
312
 
    last_revno = last_revision_id = last_tree = None
313
 
    prev_tree = EmptyTree(branch.get_root_id())
314
 
 
315
 
    for revno, revision_id in which_revs:
316
 
        this_tree = branch.revision_tree(revision_id)
317
 
        this_revision = branch.get_revision(revision_id)
318
 
 
319
 
        if not last_revno:
320
 
            if revno == 1:
321
 
                last_tree = EmptyTree(branch.get_root_id())
322
 
            else:
323
 
                last_revno = revno - 1
324
 
                last_revision_id = branch.revision_history()[last_revno]
325
 
                last_tree = branch.revision_tree(last_revision_id)
326
 
 
327
 
        yield revno, this_revision, compare_trees(last_tree, this_tree, False)
328
 
 
329
 
        last_revno = revno
330
 
        last_revision = this_revision
331
 
        last_tree = this_tree
 
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
332
327
 
333
328
 
334
329
class LogFormatter(object):
335
330
    """Abstract class to display log messages."""
 
331
 
336
332
    def __init__(self, to_file, show_ids=False, show_timezone='original'):
337
333
        self.to_file = to_file
338
334
        self.show_ids = show_ids
339
335
        self.show_timezone = show_timezone
340
336
 
341
 
 
342
337
    def show(self, revno, rev, delta):
343
338
        raise NotImplementedError('not implemented in abstract base')
344
339
 
 
340
    def short_committer(self, rev):
 
341
        return re.sub('<.*@.*>', '', rev.committer).strip(' ')
 
342
    
345
343
    
346
344
class LongLogFormatter(LogFormatter):
347
345
    def show(self, revno, rev, delta):
348
 
        from osutils import format_date
349
 
 
350
 
        to_file = self.to_file
351
 
 
352
 
        print >>to_file,  '-' * 60
353
 
        print >>to_file,  'revno:', revno
354
 
        if self.show_ids:
355
 
            print >>to_file,  'revision-id:', rev.revision_id
356
 
 
357
 
            for parent_id in rev.parent_ids:
358
 
                print >>to_file, 'parent:', parent_id
359
 
            
360
 
        print >>to_file,  'committer:', rev.committer
361
 
 
362
 
        date_str = format_date(rev.timestamp,
363
 
                               rev.timezone or 0,
364
 
                               self.show_timezone)
365
 
        print >>to_file,  'timestamp: %s' % date_str
366
 
 
367
 
        print >>to_file,  'message:'
368
 
        if not rev.message:
369
 
            print >>to_file,  '  (no message)'
370
 
        else:
371
 
            for l in rev.message.split('\n'):
372
 
                print >>to_file,  '  ' + l
373
 
 
374
 
        if delta != None:
375
 
            delta.show(to_file, self.show_ids)
376
 
 
377
 
    def show_merge(self, rev):
378
 
        from osutils import format_date
379
 
 
380
 
        to_file = self.to_file
381
 
 
382
 
        indent = '    '
383
 
 
 
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
384
361
        print >>to_file,  indent+'-' * 60
385
 
        print >>to_file,  indent+'merged:', rev.revision_id
 
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
386
368
        if self.show_ids:
387
369
            for parent_id in rev.parent_ids:
388
370
                print >>to_file, indent+'parent:', parent_id
389
 
            
390
371
        print >>to_file,  indent+'committer:', rev.committer
391
 
 
 
372
        try:
 
373
            print >>to_file, indent+'branch nick: %s' % \
 
374
                rev.properties['branch-nick']
 
375
        except KeyError:
 
376
            pass
392
377
        date_str = format_date(rev.timestamp,
393
378
                               rev.timezone or 0,
394
379
                               self.show_timezone)
398
383
        if not rev.message:
399
384
            print >>to_file,  indent+'  (no message)'
400
385
        else:
401
 
            for l in rev.message.split('\n'):
 
386
            message = rev.message.rstrip('\r\n')
 
387
            for l in message.split('\n'):
402
388
                print >>to_file,  indent+'  ' + l
 
389
        if delta is not None:
 
390
            delta.show(to_file, self.show_ids)
403
391
 
404
392
 
405
393
class ShortLogFormatter(LogFormatter):
409
397
        to_file = self.to_file
410
398
        date_str = format_date(rev.timestamp, rev.timezone or 0,
411
399
                            self.show_timezone)
412
 
        print >>to_file, "%5d %s\t%s" % (revno, rev.committer,
 
400
        print >>to_file, "%5s %s\t%s" % (revno, self.short_committer(rev),
413
401
                format_date(rev.timestamp, rev.timezone or 0,
414
 
                            self.show_timezone))
 
402
                            self.show_timezone, date_fmt="%Y-%m-%d",
 
403
                           show_offset=False))
415
404
        if self.show_ids:
416
405
            print >>to_file,  '      revision-id:', rev.revision_id
417
406
        if not rev.message:
418
407
            print >>to_file,  '      (no message)'
419
408
        else:
420
 
            for l in rev.message.split('\n'):
 
409
            message = rev.message.rstrip('\r\n')
 
410
            for l in message.split('\n'):
421
411
                print >>to_file,  '      ' + l
422
412
 
423
413
        # TODO: Why not show the modified files in a shorter form as
424
414
        # well? rewrap them single lines of appropriate length
425
 
        if delta != None:
 
415
        if delta is not None:
426
416
            delta.show(to_file, self.show_ids)
427
 
        print
 
417
        print >>to_file, ''
 
418
 
428
419
 
429
420
class LineLogFormatter(LogFormatter):
430
421
    def truncate(self, str, max_len):
444
435
        else:
445
436
            return rev.message
446
437
 
447
 
    def short_committer(self, rev):
448
 
        return re.sub('<.*@.*>', '', rev.committer).strip(' ')
449
 
    
450
438
    def show(self, revno, rev, delta):
451
 
        print >> self.to_file, self.log_string(rev, 79) 
 
439
        from bzrlib.osutils import terminal_width
 
440
        print >> self.to_file, self.log_string(revno, rev, terminal_width()-1)
452
441
 
453
 
    def log_string(self, rev, max_chars):
454
 
        out = [self.truncate(self.short_committer(rev), 20)]
 
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
455
        out.append(self.date_string(rev))
456
 
        out.append(self.message(rev).replace('\n', ' '))
 
456
        out.append(rev.get_summary())
457
457
        return self.truncate(" ".join(out).rstrip('\n'), max_chars)
458
458
 
 
459
 
459
460
def line_log(rev, max_chars):
460
461
    lf = LineLogFormatter(None)
461
 
    return lf.log_string(rev, max_chars)
 
462
    return lf.log_string(None, rev, max_chars)
462
463
 
463
 
FORMATTERS = {'long': LongLogFormatter,
 
464
FORMATTERS = {
 
465
              'long': LongLogFormatter,
464
466
              'short': ShortLogFormatter,
465
467
              'line': LineLogFormatter,
466
468
              }
467
469
 
 
470
def register_formatter(name, formatter):
 
471
    FORMATTERS[name] = formatter
468
472
 
469
473
def log_formatter(name, *args, **kwargs):
470
474
    """Construct a formatter from arguments.
475
479
    from bzrlib.errors import BzrCommandError
476
480
    try:
477
481
        return FORMATTERS[name](*args, **kwargs)
478
 
    except IndexError:
 
482
    except KeyError:
479
483
        raise BzrCommandError("unknown log formatter: %r" % name)
480
484
 
481
485
def show_one_log(revno, rev, delta, verbose, to_file, show_timezone):
482
 
    # deprecated; for compatability
 
486
    # deprecated; for compatibility
483
487
    lf = LongLogFormatter(to_file=to_file, show_timezone=show_timezone)
484
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:
 
499
        import sys
 
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