/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/diff.py

  • Committer: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/diff.py
1
 
# Copyright (C) 2005-2014 Canonical Ltd.
 
1
# Copyright (C) 2005-2010 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
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
from __future__ import absolute_import
18
 
 
19
17
import difflib
20
18
import os
21
19
import re
22
20
import string
23
21
import sys
24
22
 
25
 
from .lazy_import import lazy_import
 
23
from bzrlib.lazy_import import lazy_import
26
24
lazy_import(globals(), """
27
25
import errno
28
26
import subprocess
29
27
import tempfile
 
28
import time
30
29
 
31
 
from breezy import (
 
30
from bzrlib import (
 
31
    branch as _mod_branch,
 
32
    bzrdir,
 
33
    cmdline,
32
34
    cleanup,
33
 
    cmdline,
34
 
    controldir,
35
35
    errors,
36
36
    osutils,
37
37
    patiencediff,
40
40
    views,
41
41
    )
42
42
 
43
 
from breezy.workingtree import WorkingTree
44
 
from breezy.i18n import gettext
 
43
from bzrlib.workingtree import WorkingTree
45
44
""")
46
45
 
47
 
from .registry import (
 
46
from bzrlib.registry import (
48
47
    Registry,
49
48
    )
50
 
from .trace import mutter, note, warning
51
 
from .tree import FileTimestampUnavailable
52
 
 
53
 
 
54
 
DEFAULT_CONTEXT_AMOUNT = 3
 
49
from bzrlib.symbol_versioning import (
 
50
    deprecated_function,
 
51
    deprecated_in,
 
52
    )
 
53
from bzrlib.trace import mutter, note, warning
 
54
 
55
55
 
56
56
class AtTemplate(string.Template):
57
57
    """Templating class that uses @ instead of $."""
75
75
 
76
76
def internal_diff(old_filename, oldlines, new_filename, newlines, to_file,
77
77
                  allow_binary=False, sequence_matcher=None,
78
 
                  path_encoding='utf8', context_lines=DEFAULT_CONTEXT_AMOUNT):
 
78
                  path_encoding='utf8'):
79
79
    # FIXME: difflib is wrong if there is no trailing newline.
80
80
    # The syntax used by patch seems to be "\ No newline at
81
81
    # end of file" following the last diff line from that
99
99
    if sequence_matcher is None:
100
100
        sequence_matcher = patiencediff.PatienceSequenceMatcher
101
101
    ud = patiencediff.unified_diff(oldlines, newlines,
102
 
                      fromfile=old_filename.encode(path_encoding, 'replace'),
103
 
                      tofile=new_filename.encode(path_encoding, 'replace'),
104
 
                      n=context_lines, sequencematcher=sequence_matcher)
 
102
                      fromfile=old_filename.encode(path_encoding),
 
103
                      tofile=new_filename.encode(path_encoding),
 
104
                      sequencematcher=sequence_matcher)
105
105
 
106
106
    ud = list(ud)
107
107
    if len(ud) == 0: # Identical contents, nothing to do
121
121
 
122
122
 
123
123
def _spawn_external_diff(diffcmd, capture_errors=True):
124
 
    """Spawn the external diff process, and return the child handle.
 
124
    """Spawn the externall diff process, and return the child handle.
125
125
 
126
126
    :param diffcmd: The command list to spawn
127
127
    :param capture_errors: Capture stderr as well as setting LANG=C
149
149
                                stdout=subprocess.PIPE,
150
150
                                stderr=stderr,
151
151
                                env=env)
152
 
    except OSError as e:
 
152
    except OSError, e:
153
153
        if e.errno == errno.ENOENT:
154
154
            raise errors.NoDiff(str(e))
155
155
        raise
156
156
 
157
157
    return pipe
158
158
 
159
 
# diff style options as of GNU diff v3.2
160
 
style_option_list = ['-c', '-C', '--context',
161
 
                     '-e', '--ed',
162
 
                     '-f', '--forward-ed',
163
 
                     '-q', '--brief',
164
 
                     '--normal',
165
 
                     '-n', '--rcs',
166
 
                     '-u', '-U', '--unified',
167
 
                     '-y', '--side-by-side',
168
 
                     '-D', '--ifdef']
169
 
 
170
 
def default_style_unified(diff_opts):
171
 
    """Default to unified diff style if alternative not specified in diff_opts.
172
 
 
173
 
        diff only allows one style to be specified; they don't override.
174
 
        Note that some of these take optargs, and the optargs can be
175
 
        directly appended to the options.
176
 
        This is only an approximate parser; it doesn't properly understand
177
 
        the grammar.
178
 
 
179
 
    :param diff_opts: List of options for external (GNU) diff.
180
 
    :return: List of options with default style=='unified'.
181
 
    """
182
 
    for s in style_option_list:
183
 
        for j in diff_opts:
184
 
            if j.startswith(s):
185
 
                break
186
 
        else:
187
 
            continue
188
 
        break
189
 
    else:
190
 
        diff_opts.append('-u')
191
 
    return diff_opts
192
 
 
193
159
 
194
160
def external_diff(old_filename, oldlines, new_filename, newlines, to_file,
195
161
                  diff_opts):
197
163
    # make sure our own output is properly ordered before the diff
198
164
    to_file.flush()
199
165
 
200
 
    oldtmp_fd, old_abspath = tempfile.mkstemp(prefix='brz-diff-old-')
201
 
    newtmp_fd, new_abspath = tempfile.mkstemp(prefix='brz-diff-new-')
 
166
    oldtmp_fd, old_abspath = tempfile.mkstemp(prefix='bzr-diff-old-')
 
167
    newtmp_fd, new_abspath = tempfile.mkstemp(prefix='bzr-diff-new-')
202
168
    oldtmpf = os.fdopen(oldtmp_fd, 'wb')
203
169
    newtmpf = os.fdopen(newtmp_fd, 'wb')
204
170
 
231
197
                   '--binary',
232
198
                  ]
233
199
 
234
 
        diff_opts = default_style_unified(diff_opts)
 
200
        # diff only allows one style to be specified; they don't override.
 
201
        # note that some of these take optargs, and the optargs can be
 
202
        # directly appended to the options.
 
203
        # this is only an approximate parser; it doesn't properly understand
 
204
        # the grammar.
 
205
        for s in ['-c', '-u', '-C', '-U',
 
206
                  '-e', '--ed',
 
207
                  '-q', '--brief',
 
208
                  '--normal',
 
209
                  '-n', '--rcs',
 
210
                  '-y', '--side-by-side',
 
211
                  '-D', '--ifdef']:
 
212
            for j in diff_opts:
 
213
                if j.startswith(s):
 
214
                    break
 
215
            else:
 
216
                continue
 
217
            break
 
218
        else:
 
219
            diffcmd.append('-u')
235
220
 
236
221
        if diff_opts:
237
222
            diffcmd.extend(diff_opts)
282
267
                msg = 'exit code %d' % rc
283
268
 
284
269
            raise errors.BzrError('external diff failed with %s; command: %r'
285
 
                                  % (msg, diffcmd))
 
270
                                  % (rc, diffcmd))
286
271
 
287
272
 
288
273
    finally:
289
274
        oldtmpf.close()                 # and delete
290
275
        newtmpf.close()
291
 
 
292
 
        def cleanup(path):
293
 
            # Warn in case the file couldn't be deleted (in case windows still
294
 
            # holds the file open, but not if the files have already been
295
 
            # deleted)
296
 
            try:
297
 
                os.remove(path)
298
 
            except OSError as e:
299
 
                if e.errno not in (errno.ENOENT,):
300
 
                    warning('Failed to delete temporary file: %s %s', path, e)
301
 
 
302
 
        cleanup(old_abspath)
303
 
        cleanup(new_abspath)
304
 
 
 
276
        # Clean up. Warn in case the files couldn't be deleted
 
277
        # (in case windows still holds the file open, but not
 
278
        # if the files have already been deleted)
 
279
        try:
 
280
            os.remove(old_abspath)
 
281
        except OSError, e:
 
282
            if e.errno not in (errno.ENOENT,):
 
283
                warning('Failed to delete temporary file: %s %s',
 
284
                        old_abspath, e)
 
285
        try:
 
286
            os.remove(new_abspath)
 
287
        except OSError:
 
288
            if e.errno not in (errno.ENOENT,):
 
289
                warning('Failed to delete temporary file: %s %s',
 
290
                        new_abspath, e)
 
291
 
 
292
 
 
293
@deprecated_function(deprecated_in((2, 2, 0)))
 
294
def get_trees_and_branches_to_diff(path_list, revision_specs, old_url, new_url,
 
295
                                   apply_view=True):
 
296
    """Get the trees and specific files to diff given a list of paths.
 
297
 
 
298
    This method works out the trees to be diff'ed and the files of
 
299
    interest within those trees.
 
300
 
 
301
    :param path_list:
 
302
        the list of arguments passed to the diff command
 
303
    :param revision_specs:
 
304
        Zero, one or two RevisionSpecs from the diff command line,
 
305
        saying what revisions to compare.
 
306
    :param old_url:
 
307
        The url of the old branch or tree. If None, the tree to use is
 
308
        taken from the first path, if any, or the current working tree.
 
309
    :param new_url:
 
310
        The url of the new branch or tree. If None, the tree to use is
 
311
        taken from the first path, if any, or the current working tree.
 
312
    :param apply_view:
 
313
        if True and a view is set, apply the view or check that the paths
 
314
        are within it
 
315
    :returns:
 
316
        a tuple of (old_tree, new_tree, old_branch, new_branch,
 
317
        specific_files, extra_trees) where extra_trees is a sequence of
 
318
        additional trees to search in for file-ids.  The trees and branches
 
319
        are not locked.
 
320
    """
 
321
    op = cleanup.OperationWithCleanups(get_trees_and_branches_to_diff_locked)
 
322
    return op.run_simple(path_list, revision_specs, old_url, new_url,
 
323
            op.add_cleanup, apply_view=apply_view)
 
324
    
305
325
 
306
326
def get_trees_and_branches_to_diff_locked(
307
327
    path_list, revision_specs, old_url, new_url, add_cleanup, apply_view=True):
374
394
    if old_url is None:
375
395
        old_url = default_location
376
396
    working_tree, branch, relpath = \
377
 
        controldir.ControlDir.open_containing_tree_or_branch(old_url)
 
397
        bzrdir.BzrDir.open_containing_tree_or_branch(old_url)
378
398
    lock_tree_or_branch(working_tree, branch)
379
399
    if consider_relpath and relpath != '':
380
400
        if working_tree is not None and apply_view:
388
408
        new_url = default_location
389
409
    if new_url != old_url:
390
410
        working_tree, branch, relpath = \
391
 
            controldir.ControlDir.open_containing_tree_or_branch(new_url)
 
411
            bzrdir.BzrDir.open_containing_tree_or_branch(new_url)
392
412
        lock_tree_or_branch(working_tree, branch)
393
413
        if consider_relpath and relpath != '':
394
414
            if working_tree is not None and apply_view:
400
420
 
401
421
    # Get the specific files (all files is None, no files is [])
402
422
    if make_paths_wt_relative and working_tree is not None:
403
 
        other_paths = working_tree.safe_relpath_files(
404
 
            other_paths,
 
423
        try:
 
424
            from bzrlib.builtins import safe_relpath_files
 
425
            other_paths = safe_relpath_files(working_tree, other_paths,
405
426
            apply_view=apply_view)
 
427
        except errors.FileInWrongBranch:
 
428
            raise errors.BzrCommandError("Files are in different branches")
406
429
    specific_files.extend(other_paths)
407
430
    if len(specific_files) == 0:
408
431
        specific_files = None
412
435
            if view_files:
413
436
                specific_files = view_files
414
437
                view_str = views.view_display_str(view_files)
415
 
                note(gettext("*** Ignoring files outside view. View is %s") % view_str)
 
438
                note("*** Ignoring files outside view. View is %s" % view_str)
416
439
 
417
440
    # Get extra trees that ought to be searched for file-ids
418
441
    extra_trees = None
419
442
    if working_tree is not None and working_tree not in (old_tree, new_tree):
420
443
        extra_trees = (working_tree,)
421
 
    return (old_tree, new_tree, old_branch, new_branch,
422
 
            specific_files, extra_trees)
 
444
    return old_tree, new_tree, old_branch, new_branch, specific_files, extra_trees
423
445
 
424
446
 
425
447
def _get_tree_to_diff(spec, tree=None, branch=None, basis_is_default=True):
442
464
                    extra_trees=None,
443
465
                    path_encoding='utf8',
444
466
                    using=None,
445
 
                    format_cls=None,
446
 
                    context=DEFAULT_CONTEXT_AMOUNT):
 
467
                    format_cls=None):
447
468
    """Show in text form the changes from one tree to another.
448
469
 
449
470
    :param to_file: The output stream.
450
 
    :param specific_files: Include only changes to these files - None for all
 
471
    :param specific_files:Include only changes to these files - None for all
451
472
        changes.
452
473
    :param external_diff_options: If set, use an external GNU diff and pass 
453
474
        these options.
456
477
        otherwise is supposed to be utf8
457
478
    :param format_cls: Formatter class (DiffTree subclass)
458
479
    """
459
 
    if context is None:
460
 
        context = DEFAULT_CONTEXT_AMOUNT
461
480
    if format_cls is None:
462
481
        format_cls = DiffTree
463
482
    old_tree.lock_read()
470
489
            differ = format_cls.from_trees_options(old_tree, new_tree, to_file,
471
490
                                                   path_encoding,
472
491
                                                   external_diff_options,
473
 
                                                   old_label, new_label, using,
474
 
                                                   context_lines=context)
 
492
                                                   old_label, new_label, using)
475
493
            return differ.show_diff(specific_files, extra_trees)
476
494
        finally:
477
495
            new_tree.unlock()
486
504
    """Returns a timestamp suitable for use in a patch header."""
487
505
    try:
488
506
        mtime = tree.get_file_mtime(file_id, path)
489
 
    except FileTimestampUnavailable:
 
507
    except errors.FileTimestampUnavailable:
490
508
        mtime = 0
491
509
    return timestamp.format_patch_date(mtime)
492
510
 
635
653
    # or removed in a diff.
636
654
    EPOCH_DATE = '1970-01-01 00:00:00 +0000'
637
655
 
638
 
    def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8', 
639
 
                 old_label='', new_label='', text_differ=internal_diff, 
640
 
                 context_lines=DEFAULT_CONTEXT_AMOUNT):
 
656
    def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8',
 
657
                 old_label='', new_label='', text_differ=internal_diff):
641
658
        DiffPath.__init__(self, old_tree, new_tree, to_file, path_encoding)
642
659
        self.text_differ = text_differ
643
660
        self.old_label = old_label
644
661
        self.new_label = new_label
645
662
        self.path_encoding = path_encoding
646
 
        self.context_lines = context_lines
647
663
 
648
664
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
649
665
        """Compare two files in unified diff format
690
706
        """
691
707
        def _get_text(tree, file_id, path):
692
708
            if file_id is not None:
693
 
                return tree.get_file_lines(file_id, path)
 
709
                return tree.get_file(file_id, path).readlines()
694
710
            else:
695
711
                return []
696
712
        try:
697
713
            from_text = _get_text(self.old_tree, from_file_id, from_path)
698
714
            to_text = _get_text(self.new_tree, to_file_id, to_path)
699
715
            self.text_differ(from_label, from_text, to_label, to_text,
700
 
                             self.to_file, path_encoding=self.path_encoding,
701
 
                             context_lines=self.context_lines)
 
716
                             self.to_file)
702
717
        except errors.BinaryFile:
703
718
            self.to_file.write(
704
719
                  ("Binary files %s and %s differ\n" %
705
 
                  (from_label, to_label)).encode(self.path_encoding,'replace'))
 
720
                  (from_label, to_label)).encode(self.path_encoding))
706
721
        return self.CHANGED
707
722
 
708
723
 
712
727
                 path_encoding='utf-8'):
713
728
        DiffPath.__init__(self, old_tree, new_tree, to_file, path_encoding)
714
729
        self.command_template = command_template
715
 
        self._root = osutils.mkdtemp(prefix='brz-diff-')
 
730
        self._root = osutils.mkdtemp(prefix='bzr-diff-')
716
731
 
717
732
    @classmethod
718
733
    def from_string(klass, command_string, old_tree, new_tree, to_file,
724
739
                     path_encoding)
725
740
 
726
741
    @classmethod
727
 
    def make_from_diff_tree(klass, command_string, external_diff_options=None):
 
742
    def make_from_diff_tree(klass, command_string):
728
743
        def from_diff_tree(diff_tree):
729
 
            full_command_string = [command_string]
730
 
            if external_diff_options is not None:
731
 
                full_command_string += ' ' + external_diff_options
732
 
            return klass.from_string(full_command_string, diff_tree.old_tree,
 
744
            return klass.from_string(command_string, diff_tree.old_tree,
733
745
                                     diff_tree.new_tree, diff_tree.to_file)
734
746
        return from_diff_tree
735
747
 
736
748
    def _get_command(self, old_path, new_path):
737
749
        my_map = {'old_path': old_path, 'new_path': new_path}
738
 
        command = [AtTemplate(t).substitute(my_map) for t in
739
 
                   self.command_template]
740
 
        if sys.platform == 'win32': # Popen doesn't accept unicode on win32
741
 
            command_encoded = []
742
 
            for c in command:
743
 
                if isinstance(c, unicode):
744
 
                    command_encoded.append(c.encode('mbcs'))
745
 
                else:
746
 
                    command_encoded.append(c)
747
 
            return command_encoded
748
 
        else:
749
 
            return command
 
750
        return [AtTemplate(t).substitute(my_map) for t in
 
751
                self.command_template]
750
752
 
751
753
    def _execute(self, old_path, new_path):
752
754
        command = self._get_command(old_path, new_path)
753
755
        try:
754
756
            proc = subprocess.Popen(command, stdout=subprocess.PIPE,
755
757
                                    cwd=self._root)
756
 
        except OSError as e:
 
758
        except OSError, e:
757
759
            if e.errno == errno.ENOENT:
758
760
                raise errors.ExecutableMissing(command[0])
759
761
            else:
767
769
            return False
768
770
        try:
769
771
            os.symlink(tree.abspath(''), osutils.pathjoin(self._root, prefix))
770
 
        except OSError as e:
 
772
        except OSError, e:
771
773
            if e.errno != errno.EEXIST:
772
774
                raise
773
775
        return True
774
776
 
775
 
    @staticmethod
776
 
    def _fenc():
777
 
        """Returns safe encoding for passing file path to diff tool"""
778
 
        if sys.platform == 'win32':
779
 
            return 'mbcs'
780
 
        else:
781
 
            # Don't fallback to 'utf-8' because subprocess may not be able to
782
 
            # handle utf-8 correctly when locale is not utf-8.
783
 
            return sys.getfilesystemencoding() or 'ascii'
784
 
 
785
 
    def _is_safepath(self, path):
786
 
        """Return true if `path` may be able to pass to subprocess."""
787
 
        fenc = self._fenc()
788
 
        try:
789
 
            return path == path.encode(fenc).decode(fenc)
790
 
        except UnicodeError:
791
 
            return False
792
 
 
793
 
    def _safe_filename(self, prefix, relpath):
794
 
        """Replace unsafe character in `relpath` then join `self._root`,
795
 
        `prefix` and `relpath`."""
796
 
        fenc = self._fenc()
797
 
        # encoded_str.replace('?', '_') may break multibyte char.
798
 
        # So we should encode, decode, then replace(u'?', u'_')
799
 
        relpath_tmp = relpath.encode(fenc, 'replace').decode(fenc, 'replace')
800
 
        relpath_tmp = relpath_tmp.replace(u'?', u'_')
801
 
        return osutils.pathjoin(self._root, prefix, relpath_tmp)
802
 
 
803
777
    def _write_file(self, file_id, tree, prefix, relpath, force_temp=False,
804
778
                    allow_write=False):
805
779
        if not force_temp and isinstance(tree, WorkingTree):
806
 
            full_path = tree.abspath(tree.id2path(file_id))
807
 
            if self._is_safepath(full_path):
808
 
                return full_path
809
 
 
810
 
        full_path = self._safe_filename(prefix, relpath)
 
780
            return tree.abspath(tree.id2path(file_id))
 
781
        
 
782
        full_path = osutils.pathjoin(self._root, prefix, relpath)
811
783
        if not force_temp and self._try_symlink_root(tree, prefix):
812
784
            return full_path
813
785
        parent_dir = osutils.dirname(full_path)
814
786
        try:
815
787
            os.makedirs(parent_dir)
816
 
        except OSError as e:
 
788
        except OSError, e:
817
789
            if e.errno != errno.EEXIST:
818
790
                raise
819
791
        source = tree.get_file(file_id, relpath)
827
799
            source.close()
828
800
        try:
829
801
            mtime = tree.get_file_mtime(file_id)
830
 
        except FileTimestampUnavailable:
 
802
        except errors.FileTimestampUnavailable:
831
803
            pass
832
804
        else:
833
805
            os.utime(full_path, (mtime, mtime))
847
819
    def finish(self):
848
820
        try:
849
821
            osutils.rmtree(self._root)
850
 
        except OSError as e:
 
822
        except OSError, e:
851
823
            if e.errno != errno.ENOENT:
852
824
                mutter("The temporary directory \"%s\" was not "
853
825
                        "cleanly removed: %s." % (self._root, e))
870
842
        """
871
843
        old_path = self.old_tree.id2path(file_id)
872
844
        new_path = self.new_tree.id2path(file_id)
873
 
        old_abs_path, new_abs_path = self._prepare_files(
874
 
                                            file_id, old_path, new_path,
875
 
                                            allow_write_new=True,
876
 
                                            force_temp=True)
877
 
        command = self._get_command(old_abs_path, new_abs_path)
 
845
        new_abs_path = self._prepare_files(file_id, old_path, new_path,
 
846
                                           allow_write_new=True,
 
847
                                           force_temp=True)[1]
 
848
        command = self._get_command(osutils.pathjoin('old', old_path),
 
849
                                    osutils.pathjoin('new', new_path))
878
850
        subprocess.call(command, cwd=self._root)
879
 
        new_file = open(new_abs_path, 'rb')
 
851
        new_file = open(new_abs_path, 'r')
880
852
        try:
881
853
            return new_file.read()
882
854
        finally:
928
900
    @classmethod
929
901
    def from_trees_options(klass, old_tree, new_tree, to_file,
930
902
                           path_encoding, external_diff_options, old_label,
931
 
                           new_label, using, context_lines):
 
903
                           new_label, using):
932
904
        """Factory for producing a DiffTree.
933
905
 
934
906
        Designed to accept options used by show_diff_trees.
935
 
 
936
907
        :param old_tree: The tree to show as old in the comparison
937
908
        :param new_tree: The tree to show as new in the comparison
938
909
        :param to_file: File to write comparisons to
944
915
        :param using: Commandline to use to invoke an external diff tool
945
916
        """
946
917
        if using is not None:
947
 
            extra_factories = [DiffFromTool.make_from_diff_tree(using, external_diff_options)]
 
918
            extra_factories = [DiffFromTool.make_from_diff_tree(using)]
948
919
        else:
949
920
            extra_factories = []
950
921
        if external_diff_options:
951
922
            opts = external_diff_options.split()
952
 
            def diff_file(olab, olines, nlab, nlines, to_file, path_encoding=None, context_lines=None):
953
 
                """:param path_encoding: not used but required
954
 
                        to match the signature of internal_diff.
955
 
                """
 
923
            def diff_file(olab, olines, nlab, nlines, to_file):
956
924
                external_diff(olab, olines, nlab, nlines, to_file, opts)
957
925
        else:
958
926
            diff_file = internal_diff
959
927
        diff_text = DiffText(old_tree, new_tree, to_file, path_encoding,
960
 
                             old_label, new_label, diff_file, context_lines=context_lines)
 
928
                             old_label, new_label, diff_file)
961
929
        return klass(old_tree, new_tree, to_file, path_encoding, diff_text,
962
930
                     extra_factories)
963
931