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

  • Committer: Jelmer Vernooij
  • Date: 2017-09-01 07:15:43 UTC
  • mfrom: (6770.3.2 py3_test_cleanup)
  • Revision ID: jelmer@jelmer.uk-20170901071543-1t83321xkog9qrxh
Merge lp:~gz/brz/py3_test_cleanup

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/diff.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd.
 
1
# Copyright (C) 2005-2014 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
 
17
19
import difflib
18
20
import os
19
21
import re
20
22
import string
21
23
import sys
22
24
 
23
 
from bzrlib.lazy_import import lazy_import
 
25
from .lazy_import import lazy_import
24
26
lazy_import(globals(), """
25
27
import errno
26
28
import subprocess
27
29
import tempfile
28
 
import time
29
30
 
30
 
from bzrlib import (
31
 
    branch as _mod_branch,
32
 
    bzrdir,
 
31
from breezy import (
 
32
    cleanup,
33
33
    cmdline,
34
 
    cleanup,
 
34
    controldir,
35
35
    errors,
36
36
    osutils,
37
37
    patiencediff,
40
40
    views,
41
41
    )
42
42
 
43
 
from bzrlib.workingtree import WorkingTree
 
43
from breezy.workingtree import WorkingTree
 
44
from breezy.i18n import gettext
44
45
""")
45
46
 
46
 
from bzrlib.registry import (
 
47
from .registry import (
47
48
    Registry,
48
49
    )
49
 
from bzrlib.symbol_versioning import (
50
 
    deprecated_function,
51
 
    deprecated_in,
52
 
    )
53
 
from bzrlib.trace import mutter, note, warning
54
 
 
 
50
from .trace import mutter, note, warning
 
51
from .tree import FileTimestampUnavailable
 
52
 
 
53
 
 
54
DEFAULT_CONTEXT_AMOUNT = 3
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'):
 
78
                  path_encoding='utf8', context_lines=DEFAULT_CONTEXT_AMOUNT):
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),
103
 
                      tofile=new_filename.encode(path_encoding),
104
 
                      sequencematcher=sequence_matcher)
 
102
                      fromfile=old_filename.encode(path_encoding, 'replace'),
 
103
                      tofile=new_filename.encode(path_encoding, 'replace'),
 
104
                      n=context_lines, 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 externall diff process, and return the child handle.
 
124
    """Spawn the external 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, e:
 
152
    except OSError as 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
 
159
193
 
160
194
def external_diff(old_filename, oldlines, new_filename, newlines, to_file,
161
195
                  diff_opts):
163
197
    # make sure our own output is properly ordered before the diff
164
198
    to_file.flush()
165
199
 
166
 
    oldtmp_fd, old_abspath = tempfile.mkstemp(prefix='bzr-diff-old-')
167
 
    newtmp_fd, new_abspath = tempfile.mkstemp(prefix='bzr-diff-new-')
 
200
    oldtmp_fd, old_abspath = tempfile.mkstemp(prefix='brz-diff-old-')
 
201
    newtmp_fd, new_abspath = tempfile.mkstemp(prefix='brz-diff-new-')
168
202
    oldtmpf = os.fdopen(oldtmp_fd, 'wb')
169
203
    newtmpf = os.fdopen(newtmp_fd, 'wb')
170
204
 
197
231
                   '--binary',
198
232
                  ]
199
233
 
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')
 
234
        diff_opts = default_style_unified(diff_opts)
220
235
 
221
236
        if diff_opts:
222
237
            diffcmd.extend(diff_opts)
267
282
                msg = 'exit code %d' % rc
268
283
 
269
284
            raise errors.BzrError('external diff failed with %s; command: %r'
270
 
                                  % (rc, diffcmd))
 
285
                                  % (msg, diffcmd))
271
286
 
272
287
 
273
288
    finally:
274
289
        oldtmpf.close()                 # and delete
275
290
        newtmpf.close()
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
 
    
 
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
 
325
305
 
326
306
def get_trees_and_branches_to_diff_locked(
327
307
    path_list, revision_specs, old_url, new_url, add_cleanup, apply_view=True):
394
374
    if old_url is None:
395
375
        old_url = default_location
396
376
    working_tree, branch, relpath = \
397
 
        bzrdir.BzrDir.open_containing_tree_or_branch(old_url)
 
377
        controldir.ControlDir.open_containing_tree_or_branch(old_url)
398
378
    lock_tree_or_branch(working_tree, branch)
399
379
    if consider_relpath and relpath != '':
400
380
        if working_tree is not None and apply_view:
408
388
        new_url = default_location
409
389
    if new_url != old_url:
410
390
        working_tree, branch, relpath = \
411
 
            bzrdir.BzrDir.open_containing_tree_or_branch(new_url)
 
391
            controldir.ControlDir.open_containing_tree_or_branch(new_url)
412
392
        lock_tree_or_branch(working_tree, branch)
413
393
        if consider_relpath and relpath != '':
414
394
            if working_tree is not None and apply_view:
420
400
 
421
401
    # Get the specific files (all files is None, no files is [])
422
402
    if make_paths_wt_relative and working_tree is not None:
423
 
        try:
424
 
            from bzrlib.builtins import safe_relpath_files
425
 
            other_paths = safe_relpath_files(working_tree, other_paths,
 
403
        other_paths = working_tree.safe_relpath_files(
 
404
            other_paths,
426
405
            apply_view=apply_view)
427
 
        except errors.FileInWrongBranch:
428
 
            raise errors.BzrCommandError("Files are in different branches")
429
406
    specific_files.extend(other_paths)
430
407
    if len(specific_files) == 0:
431
408
        specific_files = None
435
412
            if view_files:
436
413
                specific_files = view_files
437
414
                view_str = views.view_display_str(view_files)
438
 
                note("*** Ignoring files outside view. View is %s" % view_str)
 
415
                note(gettext("*** Ignoring files outside view. View is %s") % view_str)
439
416
 
440
417
    # Get extra trees that ought to be searched for file-ids
441
418
    extra_trees = None
442
419
    if working_tree is not None and working_tree not in (old_tree, new_tree):
443
420
        extra_trees = (working_tree,)
444
 
    return old_tree, new_tree, old_branch, new_branch, specific_files, extra_trees
 
421
    return (old_tree, new_tree, old_branch, new_branch,
 
422
            specific_files, extra_trees)
445
423
 
446
424
 
447
425
def _get_tree_to_diff(spec, tree=None, branch=None, basis_is_default=True):
464
442
                    extra_trees=None,
465
443
                    path_encoding='utf8',
466
444
                    using=None,
467
 
                    format_cls=None):
 
445
                    format_cls=None,
 
446
                    context=DEFAULT_CONTEXT_AMOUNT):
468
447
    """Show in text form the changes from one tree to another.
469
448
 
470
449
    :param to_file: The output stream.
471
 
    :param specific_files:Include only changes to these files - None for all
 
450
    :param specific_files: Include only changes to these files - None for all
472
451
        changes.
473
452
    :param external_diff_options: If set, use an external GNU diff and pass 
474
453
        these options.
477
456
        otherwise is supposed to be utf8
478
457
    :param format_cls: Formatter class (DiffTree subclass)
479
458
    """
 
459
    if context is None:
 
460
        context = DEFAULT_CONTEXT_AMOUNT
480
461
    if format_cls is None:
481
462
        format_cls = DiffTree
482
 
    old_tree.lock_read()
483
 
    try:
 
463
    with old_tree.lock_read():
484
464
        if extra_trees is not None:
485
465
            for tree in extra_trees:
486
466
                tree.lock_read()
489
469
            differ = format_cls.from_trees_options(old_tree, new_tree, to_file,
490
470
                                                   path_encoding,
491
471
                                                   external_diff_options,
492
 
                                                   old_label, new_label, using)
 
472
                                                   old_label, new_label, using,
 
473
                                                   context_lines=context)
493
474
            return differ.show_diff(specific_files, extra_trees)
494
475
        finally:
495
476
            new_tree.unlock()
496
477
            if extra_trees is not None:
497
478
                for tree in extra_trees:
498
479
                    tree.unlock()
499
 
    finally:
500
 
        old_tree.unlock()
501
480
 
502
481
 
503
482
def _patch_header_date(tree, file_id, path):
504
483
    """Returns a timestamp suitable for use in a patch header."""
505
484
    try:
506
485
        mtime = tree.get_file_mtime(file_id, path)
507
 
    except errors.FileTimestampUnavailable:
 
486
    except FileTimestampUnavailable:
508
487
        mtime = 0
509
488
    return timestamp.format_patch_date(mtime)
510
489
 
653
632
    # or removed in a diff.
654
633
    EPOCH_DATE = '1970-01-01 00:00:00 +0000'
655
634
 
656
 
    def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8',
657
 
                 old_label='', new_label='', text_differ=internal_diff):
 
635
    def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8', 
 
636
                 old_label='', new_label='', text_differ=internal_diff, 
 
637
                 context_lines=DEFAULT_CONTEXT_AMOUNT):
658
638
        DiffPath.__init__(self, old_tree, new_tree, to_file, path_encoding)
659
639
        self.text_differ = text_differ
660
640
        self.old_label = old_label
661
641
        self.new_label = new_label
662
642
        self.path_encoding = path_encoding
 
643
        self.context_lines = context_lines
663
644
 
664
645
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
665
646
        """Compare two files in unified diff format
706
687
        """
707
688
        def _get_text(tree, file_id, path):
708
689
            if file_id is not None:
709
 
                return tree.get_file(file_id, path).readlines()
 
690
                return tree.get_file_lines(file_id, path)
710
691
            else:
711
692
                return []
712
693
        try:
713
694
            from_text = _get_text(self.old_tree, from_file_id, from_path)
714
695
            to_text = _get_text(self.new_tree, to_file_id, to_path)
715
696
            self.text_differ(from_label, from_text, to_label, to_text,
716
 
                             self.to_file)
 
697
                             self.to_file, path_encoding=self.path_encoding,
 
698
                             context_lines=self.context_lines)
717
699
        except errors.BinaryFile:
718
700
            self.to_file.write(
719
701
                  ("Binary files %s and %s differ\n" %
720
 
                  (from_label, to_label)).encode(self.path_encoding))
 
702
                  (from_label, to_label)).encode(self.path_encoding,'replace'))
721
703
        return self.CHANGED
722
704
 
723
705
 
727
709
                 path_encoding='utf-8'):
728
710
        DiffPath.__init__(self, old_tree, new_tree, to_file, path_encoding)
729
711
        self.command_template = command_template
730
 
        self._root = osutils.mkdtemp(prefix='bzr-diff-')
 
712
        self._root = osutils.mkdtemp(prefix='brz-diff-')
731
713
 
732
714
    @classmethod
733
715
    def from_string(klass, command_string, old_tree, new_tree, to_file,
739
721
                     path_encoding)
740
722
 
741
723
    @classmethod
742
 
    def make_from_diff_tree(klass, command_string):
 
724
    def make_from_diff_tree(klass, command_string, external_diff_options=None):
743
725
        def from_diff_tree(diff_tree):
744
 
            return klass.from_string(command_string, diff_tree.old_tree,
 
726
            full_command_string = [command_string]
 
727
            if external_diff_options is not None:
 
728
                full_command_string += ' ' + external_diff_options
 
729
            return klass.from_string(full_command_string, diff_tree.old_tree,
745
730
                                     diff_tree.new_tree, diff_tree.to_file)
746
731
        return from_diff_tree
747
732
 
748
733
    def _get_command(self, old_path, new_path):
749
734
        my_map = {'old_path': old_path, 'new_path': new_path}
750
 
        return [AtTemplate(t).substitute(my_map) for t in
751
 
                self.command_template]
 
735
        command = [AtTemplate(t).substitute(my_map) for t in
 
736
                   self.command_template]
 
737
        if sys.platform == 'win32': # Popen doesn't accept unicode on win32
 
738
            command_encoded = []
 
739
            for c in command:
 
740
                if isinstance(c, unicode):
 
741
                    command_encoded.append(c.encode('mbcs'))
 
742
                else:
 
743
                    command_encoded.append(c)
 
744
            return command_encoded
 
745
        else:
 
746
            return command
752
747
 
753
748
    def _execute(self, old_path, new_path):
754
749
        command = self._get_command(old_path, new_path)
755
750
        try:
756
751
            proc = subprocess.Popen(command, stdout=subprocess.PIPE,
757
752
                                    cwd=self._root)
758
 
        except OSError, e:
 
753
        except OSError as e:
759
754
            if e.errno == errno.ENOENT:
760
755
                raise errors.ExecutableMissing(command[0])
761
756
            else:
769
764
            return False
770
765
        try:
771
766
            os.symlink(tree.abspath(''), osutils.pathjoin(self._root, prefix))
772
 
        except OSError, e:
 
767
        except OSError as e:
773
768
            if e.errno != errno.EEXIST:
774
769
                raise
775
770
        return True
776
771
 
 
772
    @staticmethod
 
773
    def _fenc():
 
774
        """Returns safe encoding for passing file path to diff tool"""
 
775
        if sys.platform == 'win32':
 
776
            return 'mbcs'
 
777
        else:
 
778
            # Don't fallback to 'utf-8' because subprocess may not be able to
 
779
            # handle utf-8 correctly when locale is not utf-8.
 
780
            return sys.getfilesystemencoding() or 'ascii'
 
781
 
 
782
    def _is_safepath(self, path):
 
783
        """Return true if `path` may be able to pass to subprocess."""
 
784
        fenc = self._fenc()
 
785
        try:
 
786
            return path == path.encode(fenc).decode(fenc)
 
787
        except UnicodeError:
 
788
            return False
 
789
 
 
790
    def _safe_filename(self, prefix, relpath):
 
791
        """Replace unsafe character in `relpath` then join `self._root`,
 
792
        `prefix` and `relpath`."""
 
793
        fenc = self._fenc()
 
794
        # encoded_str.replace('?', '_') may break multibyte char.
 
795
        # So we should encode, decode, then replace(u'?', u'_')
 
796
        relpath_tmp = relpath.encode(fenc, 'replace').decode(fenc, 'replace')
 
797
        relpath_tmp = relpath_tmp.replace(u'?', u'_')
 
798
        return osutils.pathjoin(self._root, prefix, relpath_tmp)
 
799
 
777
800
    def _write_file(self, file_id, tree, prefix, relpath, force_temp=False,
778
801
                    allow_write=False):
779
802
        if not force_temp and isinstance(tree, WorkingTree):
780
 
            return tree.abspath(tree.id2path(file_id))
781
 
        
782
 
        full_path = osutils.pathjoin(self._root, prefix, relpath)
 
803
            full_path = tree.abspath(tree.id2path(file_id))
 
804
            if self._is_safepath(full_path):
 
805
                return full_path
 
806
 
 
807
        full_path = self._safe_filename(prefix, relpath)
783
808
        if not force_temp and self._try_symlink_root(tree, prefix):
784
809
            return full_path
785
810
        parent_dir = osutils.dirname(full_path)
786
811
        try:
787
812
            os.makedirs(parent_dir)
788
 
        except OSError, e:
 
813
        except OSError as e:
789
814
            if e.errno != errno.EEXIST:
790
815
                raise
791
816
        source = tree.get_file(file_id, relpath)
799
824
            source.close()
800
825
        try:
801
826
            mtime = tree.get_file_mtime(file_id)
802
 
        except errors.FileTimestampUnavailable:
 
827
        except FileTimestampUnavailable:
803
828
            pass
804
829
        else:
805
830
            os.utime(full_path, (mtime, mtime))
819
844
    def finish(self):
820
845
        try:
821
846
            osutils.rmtree(self._root)
822
 
        except OSError, e:
 
847
        except OSError as e:
823
848
            if e.errno != errno.ENOENT:
824
849
                mutter("The temporary directory \"%s\" was not "
825
850
                        "cleanly removed: %s." % (self._root, e))
842
867
        """
843
868
        old_path = self.old_tree.id2path(file_id)
844
869
        new_path = self.new_tree.id2path(file_id)
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))
 
870
        old_abs_path, new_abs_path = self._prepare_files(
 
871
                                            file_id, old_path, new_path,
 
872
                                            allow_write_new=True,
 
873
                                            force_temp=True)
 
874
        command = self._get_command(old_abs_path, new_abs_path)
850
875
        subprocess.call(command, cwd=self._root)
851
 
        new_file = open(new_abs_path, 'r')
 
876
        new_file = open(new_abs_path, 'rb')
852
877
        try:
853
878
            return new_file.read()
854
879
        finally:
900
925
    @classmethod
901
926
    def from_trees_options(klass, old_tree, new_tree, to_file,
902
927
                           path_encoding, external_diff_options, old_label,
903
 
                           new_label, using):
 
928
                           new_label, using, context_lines):
904
929
        """Factory for producing a DiffTree.
905
930
 
906
931
        Designed to accept options used by show_diff_trees.
 
932
 
907
933
        :param old_tree: The tree to show as old in the comparison
908
934
        :param new_tree: The tree to show as new in the comparison
909
935
        :param to_file: File to write comparisons to
915
941
        :param using: Commandline to use to invoke an external diff tool
916
942
        """
917
943
        if using is not None:
918
 
            extra_factories = [DiffFromTool.make_from_diff_tree(using)]
 
944
            extra_factories = [DiffFromTool.make_from_diff_tree(using, external_diff_options)]
919
945
        else:
920
946
            extra_factories = []
921
947
        if external_diff_options:
922
948
            opts = external_diff_options.split()
923
 
            def diff_file(olab, olines, nlab, nlines, to_file):
 
949
            def diff_file(olab, olines, nlab, nlines, to_file, path_encoding=None, context_lines=None):
 
950
                """:param path_encoding: not used but required
 
951
                        to match the signature of internal_diff.
 
952
                """
924
953
                external_diff(olab, olines, nlab, nlines, to_file, opts)
925
954
        else:
926
955
            diff_file = internal_diff
927
956
        diff_text = DiffText(old_tree, new_tree, to_file, path_encoding,
928
 
                             old_label, new_label, diff_file)
 
957
                             old_label, new_label, diff_file, context_lines=context_lines)
929
958
        return klass(old_tree, new_tree, to_file, path_encoding, diff_text,
930
959
                     extra_factories)
931
960