← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/diff.py

  • Committer: Aaron Bentley
  • Date: 2012-07-19 16:57:16 UTC
  • mto: This revision was merged to the branch mainline in revision 6540.
  • Revision ID: aaron@aaronbentley.com-20120719165716-b4iupzkb17b9l9wx
Avoid branch write lock to preserve VFS call count.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/diff.py
1
 
# Copyright (C) 2004, 2005, 2006 Canonical Ltd.
 
1
# Copyright (C) 2005-2011 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
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
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
from __future__ import absolute_import
16
18
 
17
19
import difflib
18
20
import os
19
21
import re
20
 
import shutil
 
22
import string
21
23
import sys
22
24
 
23
25
from bzrlib.lazy_import import lazy_import
25
27
import errno
26
28
import subprocess
27
29
import tempfile
28
 
import time
29
30
 
30
31
from bzrlib import (
31
 
    branch as _mod_branch,
32
 
    bzrdir,
33
 
    commands,
 
32
    cleanup,
 
33
    cmdline,
 
34
    controldir,
34
35
    errors,
35
36
    osutils,
36
37
    patiencediff,
37
38
    textfile,
38
39
    timestamp,
 
40
    views,
39
41
    )
 
42
 
 
43
from bzrlib.workingtree import WorkingTree
 
44
from bzrlib.i18n import gettext
40
45
""")
41
46
 
42
 
from bzrlib.symbol_versioning import (
43
 
        deprecated_function,
44
 
        one_three
45
 
        )
46
 
from bzrlib.trace import mutter, warning
 
47
from bzrlib.registry import (
 
48
    Registry,
 
49
    )
 
50
from bzrlib.trace import mutter, note, warning
 
51
 
 
52
 
 
53
class AtTemplate(string.Template):
 
54
    """Templating class that uses @ instead of $."""
 
55
 
 
56
    delimiter = '@'
47
57
 
48
58
 
49
59
# TODO: Rather than building a changeset object, we should probably
78
88
    # both sequences are empty.
79
89
    if not oldlines and not newlines:
80
90
        return
81
 
    
 
91
 
82
92
    if allow_binary is False:
83
93
        textfile.check_text_lines(oldlines)
84
94
        textfile.check_text_lines(newlines)
86
96
    if sequence_matcher is None:
87
97
        sequence_matcher = patiencediff.PatienceSequenceMatcher
88
98
    ud = patiencediff.unified_diff(oldlines, newlines,
89
 
                      fromfile=old_filename.encode(path_encoding),
90
 
                      tofile=new_filename.encode(path_encoding),
 
99
                      fromfile=old_filename.encode(path_encoding, 'replace'),
 
100
                      tofile=new_filename.encode(path_encoding, 'replace'),
91
101
                      sequencematcher=sequence_matcher)
92
102
 
93
103
    ud = list(ud)
99
109
        ud[2] = ud[2].replace('-1,0', '-0,0')
100
110
    elif not newlines:
101
111
        ud[2] = ud[2].replace('+1,0', '+0,0')
102
 
    # work around for difflib emitting random spaces after the label
103
 
    ud[0] = ud[0][:-2] + '\n'
104
 
    ud[1] = ud[1][:-2] + '\n'
105
112
 
106
113
    for line in ud:
107
114
        to_file.write(line)
174
181
 
175
182
        if not diff_opts:
176
183
            diff_opts = []
 
184
        if sys.platform == 'win32':
 
185
            # Popen doesn't do the proper encoding for external commands
 
186
            # Since we are dealing with an ANSI api, use mbcs encoding
 
187
            old_filename = old_filename.encode('mbcs')
 
188
            new_filename = new_filename.encode('mbcs')
177
189
        diffcmd = ['diff',
178
190
                   '--label', old_filename,
179
191
                   old_abspath,
202
214
            break
203
215
        else:
204
216
            diffcmd.append('-u')
205
 
                  
 
217
 
206
218
        if diff_opts:
207
219
            diffcmd.extend(diff_opts)
208
220
 
209
221
        pipe = _spawn_external_diff(diffcmd, capture_errors=True)
210
222
        out,err = pipe.communicate()
211
223
        rc = pipe.returncode
212
 
        
 
224
 
213
225
        # internal_diff() adds a trailing newline, add one here for consistency
214
226
        out += '\n'
215
227
        if rc == 2:
250
262
                msg = 'signal %d' % (-rc)
251
263
            else:
252
264
                msg = 'exit code %d' % rc
253
 
                
254
 
            raise errors.BzrError('external diff failed with %s; command: %r' 
 
265
 
 
266
            raise errors.BzrError('external diff failed with %s; command: %r'
255
267
                                  % (rc, diffcmd))
256
268
 
257
269
 
275
287
                        new_abspath, e)
276
288
 
277
289
 
278
 
def _get_trees_to_diff(path_list, revision_specs, old_url, new_url):
 
290
def get_trees_and_branches_to_diff_locked(
 
291
    path_list, revision_specs, old_url, new_url, add_cleanup, apply_view=True):
279
292
    """Get the trees and specific files to diff given a list of paths.
280
293
 
281
294
    This method works out the trees to be diff'ed and the files of
292
305
    :param new_url:
293
306
        The url of the new branch or tree. If None, the tree to use is
294
307
        taken from the first path, if any, or the current working tree.
 
308
    :param add_cleanup:
 
309
        a callable like Command.add_cleanup.  get_trees_and_branches_to_diff
 
310
        will register cleanups that must be run to unlock the trees, etc.
 
311
    :param apply_view:
 
312
        if True and a view is set, apply the view or check that the paths
 
313
        are within it
295
314
    :returns:
296
 
        a tuple of (old_tree, new_tree, specific_files, extra_trees) where
297
 
        extra_trees is a sequence of additional trees to search in for
298
 
        file-ids.
 
315
        a tuple of (old_tree, new_tree, old_branch, new_branch,
 
316
        specific_files, extra_trees) where extra_trees is a sequence of
 
317
        additional trees to search in for file-ids.  The trees and branches
 
318
        will be read-locked until the cleanups registered via the add_cleanup
 
319
        param are run.
299
320
    """
300
321
    # Get the old and new revision specs
301
322
    old_revision_spec = None
324
345
        default_location = path_list[0]
325
346
        other_paths = path_list[1:]
326
347
 
 
348
    def lock_tree_or_branch(wt, br):
 
349
        if wt is not None:
 
350
            wt.lock_read()
 
351
            add_cleanup(wt.unlock)
 
352
        elif br is not None:
 
353
            br.lock_read()
 
354
            add_cleanup(br.unlock)
 
355
 
327
356
    # Get the old location
328
357
    specific_files = []
329
358
    if old_url is None:
330
359
        old_url = default_location
331
360
    working_tree, branch, relpath = \
332
 
        bzrdir.BzrDir.open_containing_tree_or_branch(old_url)
 
361
        controldir.ControlDir.open_containing_tree_or_branch(old_url)
 
362
    lock_tree_or_branch(working_tree, branch)
333
363
    if consider_relpath and relpath != '':
 
364
        if working_tree is not None and apply_view:
 
365
            views.check_path_in_view(working_tree, relpath)
334
366
        specific_files.append(relpath)
335
367
    old_tree = _get_tree_to_diff(old_revision_spec, working_tree, branch)
 
368
    old_branch = branch
336
369
 
337
370
    # Get the new location
338
371
    if new_url is None:
339
372
        new_url = default_location
340
373
    if new_url != old_url:
341
374
        working_tree, branch, relpath = \
342
 
            bzrdir.BzrDir.open_containing_tree_or_branch(new_url)
 
375
            controldir.ControlDir.open_containing_tree_or_branch(new_url)
 
376
        lock_tree_or_branch(working_tree, branch)
343
377
        if consider_relpath and relpath != '':
 
378
            if working_tree is not None and apply_view:
 
379
                views.check_path_in_view(working_tree, relpath)
344
380
            specific_files.append(relpath)
345
381
    new_tree = _get_tree_to_diff(new_revision_spec, working_tree, branch,
346
382
        basis_is_default=working_tree is None)
 
383
    new_branch = branch
347
384
 
348
385
    # Get the specific files (all files is None, no files is [])
349
386
    if make_paths_wt_relative and working_tree is not None:
350
 
        other_paths = _relative_paths_in_tree(working_tree, other_paths)
 
387
        other_paths = working_tree.safe_relpath_files(
 
388
            other_paths,
 
389
            apply_view=apply_view)
351
390
    specific_files.extend(other_paths)
352
391
    if len(specific_files) == 0:
353
392
        specific_files = None
 
393
        if (working_tree is not None and working_tree.supports_views()
 
394
            and apply_view):
 
395
            view_files = working_tree.views.lookup_view()
 
396
            if view_files:
 
397
                specific_files = view_files
 
398
                view_str = views.view_display_str(view_files)
 
399
                note(gettext("*** Ignoring files outside view. View is %s") % view_str)
354
400
 
355
401
    # Get extra trees that ought to be searched for file-ids
356
402
    extra_trees = None
357
403
    if working_tree is not None and working_tree not in (old_tree, new_tree):
358
404
        extra_trees = (working_tree,)
359
 
    return old_tree, new_tree, specific_files, extra_trees
 
405
    return (old_tree, new_tree, old_branch, new_branch,
 
406
            specific_files, extra_trees)
360
407
 
361
408
 
362
409
def _get_tree_to_diff(spec, tree=None, branch=None, basis_is_default=True):
370
417
                return branch.basis_tree()
371
418
        else:
372
419
            return tree
373
 
    if not spec.needs_branch():
374
 
        branch = _mod_branch.Branch.open(spec.get_branch())
375
 
    revision_id = spec.as_revision_id(branch)
376
 
    return branch.repository.revision_tree(revision_id)
377
 
 
378
 
 
379
 
def _relative_paths_in_tree(tree, paths):
380
 
    """Get the relative paths within a working tree.
381
 
 
382
 
    Each path may be either an absolute path or a path relative to the
383
 
    current working directory.
384
 
    """
385
 
    result = []
386
 
    for filename in paths:
387
 
        try:
388
 
            result.append(tree.relpath(osutils.dereference_path(filename)))
389
 
        except errors.PathNotChild:
390
 
            raise errors.BzrCommandError("Files are in different branches")
391
 
    return result
 
420
    return spec.as_tree(branch)
392
421
 
393
422
 
394
423
def show_diff_trees(old_tree, new_tree, to_file, specific_files=None,
396
425
                    old_label='a/', new_label='b/',
397
426
                    extra_trees=None,
398
427
                    path_encoding='utf8',
399
 
                    using=None):
 
428
                    using=None,
 
429
                    format_cls=None):
400
430
    """Show in text form the changes from one tree to another.
401
431
 
402
 
    to_file
403
 
        The output stream.
404
 
 
405
 
    specific_files
406
 
        Include only changes to these files - None for all changes.
407
 
 
408
 
    external_diff_options
409
 
        If set, use an external GNU diff and pass these options.
410
 
 
411
 
    extra_trees
412
 
        If set, more Trees to use for looking up file ids
413
 
 
414
 
    path_encoding
415
 
        If set, the path will be encoded as specified, otherwise is supposed
416
 
        to be utf8
 
432
    :param to_file: The output stream.
 
433
    :param specific_files: Include only changes to these files - None for all
 
434
        changes.
 
435
    :param external_diff_options: If set, use an external GNU diff and pass 
 
436
        these options.
 
437
    :param extra_trees: If set, more Trees to use for looking up file ids
 
438
    :param path_encoding: If set, the path will be encoded as specified, 
 
439
        otherwise is supposed to be utf8
 
440
    :param format_cls: Formatter class (DiffTree subclass)
417
441
    """
 
442
    if format_cls is None:
 
443
        format_cls = DiffTree
418
444
    old_tree.lock_read()
419
445
    try:
420
446
        if extra_trees is not None:
422
448
                tree.lock_read()
423
449
        new_tree.lock_read()
424
450
        try:
425
 
            differ = DiffTree.from_trees_options(old_tree, new_tree, to_file,
426
 
                                                 path_encoding,
427
 
                                                 external_diff_options,
428
 
                                                 old_label, new_label, using)
 
451
            differ = format_cls.from_trees_options(old_tree, new_tree, to_file,
 
452
                                                   path_encoding,
 
453
                                                   external_diff_options,
 
454
                                                   old_label, new_label, using)
429
455
            return differ.show_diff(specific_files, extra_trees)
430
456
        finally:
431
457
            new_tree.unlock()
438
464
 
439
465
def _patch_header_date(tree, file_id, path):
440
466
    """Returns a timestamp suitable for use in a patch header."""
441
 
    mtime = tree.get_file_mtime(file_id, path)
 
467
    try:
 
468
        mtime = tree.get_file_mtime(file_id, path)
 
469
    except errors.FileTimestampUnavailable:
 
470
        mtime = 0
442
471
    return timestamp.format_patch_date(mtime)
443
472
 
444
473
 
445
 
def _raise_if_nonexistent(paths, old_tree, new_tree):
446
 
    """Complain if paths are not in either inventory or tree.
447
 
 
448
 
    It's OK with the files exist in either tree's inventory, or 
449
 
    if they exist in the tree but are not versioned.
450
 
    
451
 
    This can be used by operations such as bzr status that can accept
452
 
    unknown or ignored files.
453
 
    """
454
 
    mutter("check paths: %r", paths)
455
 
    if not paths:
456
 
        return
457
 
    s = old_tree.filter_unversioned_files(paths)
458
 
    s = new_tree.filter_unversioned_files(s)
459
 
    s = [path for path in s if not new_tree.has_filename(path)]
460
 
    if s:
461
 
        raise errors.PathsDoNotExist(sorted(s))
462
 
 
463
 
 
464
 
@deprecated_function(one_three)
465
 
def get_prop_change(meta_modified):
466
 
    if meta_modified:
467
 
        return " (properties changed)"
468
 
    else:
469
 
        return  ""
470
 
 
471
474
def get_executable_change(old_is_x, new_is_x):
472
475
    descr = { True:"+x", False:"-x", None:"??" }
473
476
    if old_is_x != new_is_x:
648
651
            return self.CANNOT_DIFF
649
652
        from_label = '%s%s\t%s' % (self.old_label, old_path, old_date)
650
653
        to_label = '%s%s\t%s' % (self.new_label, new_path, new_date)
651
 
        return self.diff_text(from_file_id, to_file_id, from_label, to_label)
 
654
        return self.diff_text(from_file_id, to_file_id, from_label, to_label,
 
655
            old_path, new_path)
652
656
 
653
 
    def diff_text(self, from_file_id, to_file_id, from_label, to_label):
 
657
    def diff_text(self, from_file_id, to_file_id, from_label, to_label,
 
658
        from_path=None, to_path=None):
654
659
        """Diff the content of given files in two trees
655
660
 
656
661
        :param from_file_id: The id of the file in the from tree.  If None,
658
663
        :param to_file_id: The id of the file in the to tree.  This may refer
659
664
            to a different file from from_file_id.  If None,
660
665
            the file is not present in the to tree.
 
666
        :param from_path: The path in the from tree or None if unknown.
 
667
        :param to_path: The path in the to tree or None if unknown.
661
668
        """
662
 
        def _get_text(tree, file_id):
 
669
        def _get_text(tree, file_id, path):
663
670
            if file_id is not None:
664
 
                return tree.get_file(file_id).readlines()
 
671
                return tree.get_file_lines(file_id, path)
665
672
            else:
666
673
                return []
667
674
        try:
668
 
            from_text = _get_text(self.old_tree, from_file_id)
669
 
            to_text = _get_text(self.new_tree, to_file_id)
 
675
            from_text = _get_text(self.old_tree, from_file_id, from_path)
 
676
            to_text = _get_text(self.new_tree, to_file_id, to_path)
670
677
            self.text_differ(from_label, from_text, to_label, to_text,
671
 
                             self.to_file)
 
678
                             self.to_file, path_encoding=self.path_encoding)
672
679
        except errors.BinaryFile:
673
680
            self.to_file.write(
674
681
                  ("Binary files %s and %s differ\n" %
675
 
                  (from_label, to_label)).encode(self.path_encoding))
 
682
                  (from_label, to_label)).encode(self.path_encoding,'replace'))
676
683
        return self.CHANGED
677
684
 
678
685
 
682
689
                 path_encoding='utf-8'):
683
690
        DiffPath.__init__(self, old_tree, new_tree, to_file, path_encoding)
684
691
        self.command_template = command_template
685
 
        self._root = tempfile.mkdtemp(prefix='bzr-diff-')
 
692
        self._root = osutils.mkdtemp(prefix='bzr-diff-')
686
693
 
687
694
    @classmethod
688
695
    def from_string(klass, command_string, old_tree, new_tree, to_file,
689
696
                    path_encoding='utf-8'):
690
 
        command_template = commands.shlex_split_unicode(command_string)
691
 
        command_template.extend(['%(old_path)s', '%(new_path)s'])
 
697
        command_template = cmdline.split(command_string)
 
698
        if '@' not in command_string:
 
699
            command_template.extend(['@old_path', '@new_path'])
692
700
        return klass(command_template, old_tree, new_tree, to_file,
693
701
                     path_encoding)
694
702
 
695
703
    @classmethod
696
 
    def make_from_diff_tree(klass, command_string):
 
704
    def make_from_diff_tree(klass, command_string, external_diff_options=None):
697
705
        def from_diff_tree(diff_tree):
698
 
            return klass.from_string(command_string, diff_tree.old_tree,
 
706
            full_command_string = [command_string]
 
707
            if external_diff_options is not None:
 
708
                full_command_string += ' ' + external_diff_options
 
709
            return klass.from_string(full_command_string, diff_tree.old_tree,
699
710
                                     diff_tree.new_tree, diff_tree.to_file)
700
711
        return from_diff_tree
701
712
 
702
713
    def _get_command(self, old_path, new_path):
703
714
        my_map = {'old_path': old_path, 'new_path': new_path}
704
 
        return [t % my_map for t in self.command_template]
 
715
        command = [AtTemplate(t).substitute(my_map) for t in
 
716
                   self.command_template]
 
717
        if sys.platform == 'win32': # Popen doesn't accept unicode on win32
 
718
            command_encoded = []
 
719
            for c in command:
 
720
                if isinstance(c, unicode):
 
721
                    command_encoded.append(c.encode('mbcs'))
 
722
                else:
 
723
                    command_encoded.append(c)
 
724
            return command_encoded
 
725
        else:
 
726
            return command
705
727
 
706
728
    def _execute(self, old_path, new_path):
707
729
        command = self._get_command(old_path, new_path)
717
739
        return proc.wait()
718
740
 
719
741
    def _try_symlink_root(self, tree, prefix):
720
 
        if not (getattr(tree, 'abspath', None) is not None
721
 
                and osutils.has_symlinks()):
 
742
        if (getattr(tree, 'abspath', None) is None
 
743
            or not osutils.host_os_dereferences_symlinks()):
722
744
            return False
723
745
        try:
724
746
            os.symlink(tree.abspath(''), osutils.pathjoin(self._root, prefix))
727
749
                raise
728
750
        return True
729
751
 
730
 
    def _write_file(self, file_id, tree, prefix, relpath):
731
 
        full_path = osutils.pathjoin(self._root, prefix, relpath)
732
 
        if self._try_symlink_root(tree, prefix):
 
752
    @staticmethod
 
753
    def _fenc():
 
754
        """Returns safe encoding for passing file path to diff tool"""
 
755
        if sys.platform == 'win32':
 
756
            return 'mbcs'
 
757
        else:
 
758
            # Don't fallback to 'utf-8' because subprocess may not be able to
 
759
            # handle utf-8 correctly when locale is not utf-8.
 
760
            return sys.getfilesystemencoding() or 'ascii'
 
761
 
 
762
    def _is_safepath(self, path):
 
763
        """Return true if `path` may be able to pass to subprocess."""
 
764
        fenc = self._fenc()
 
765
        try:
 
766
            return path == path.encode(fenc).decode(fenc)
 
767
        except UnicodeError:
 
768
            return False
 
769
 
 
770
    def _safe_filename(self, prefix, relpath):
 
771
        """Replace unsafe character in `relpath` then join `self._root`,
 
772
        `prefix` and `relpath`."""
 
773
        fenc = self._fenc()
 
774
        # encoded_str.replace('?', '_') may break multibyte char.
 
775
        # So we should encode, decode, then replace(u'?', u'_')
 
776
        relpath_tmp = relpath.encode(fenc, 'replace').decode(fenc, 'replace')
 
777
        relpath_tmp = relpath_tmp.replace(u'?', u'_')
 
778
        return osutils.pathjoin(self._root, prefix, relpath_tmp)
 
779
 
 
780
    def _write_file(self, file_id, tree, prefix, relpath, force_temp=False,
 
781
                    allow_write=False):
 
782
        if not force_temp and isinstance(tree, WorkingTree):
 
783
            full_path = tree.abspath(tree.id2path(file_id))
 
784
            if self._is_safepath(full_path):
 
785
                return full_path
 
786
 
 
787
        full_path = self._safe_filename(prefix, relpath)
 
788
        if not force_temp and self._try_symlink_root(tree, prefix):
733
789
            return full_path
734
790
        parent_dir = osutils.dirname(full_path)
735
791
        try:
746
802
                target.close()
747
803
        finally:
748
804
            source.close()
749
 
        osutils.make_readonly(full_path)
750
 
        mtime = tree.get_file_mtime(file_id)
751
 
        os.utime(full_path, (mtime, mtime))
 
805
        try:
 
806
            mtime = tree.get_file_mtime(file_id)
 
807
        except errors.FileTimestampUnavailable:
 
808
            pass
 
809
        else:
 
810
            os.utime(full_path, (mtime, mtime))
 
811
        if not allow_write:
 
812
            osutils.make_readonly(full_path)
752
813
        return full_path
753
814
 
754
 
    def _prepare_files(self, file_id, old_path, new_path):
 
815
    def _prepare_files(self, file_id, old_path, new_path, force_temp=False,
 
816
                       allow_write_new=False):
755
817
        old_disk_path = self._write_file(file_id, self.old_tree, 'old',
756
 
                                         old_path)
 
818
                                         old_path, force_temp)
757
819
        new_disk_path = self._write_file(file_id, self.new_tree, 'new',
758
 
                                         new_path)
 
820
                                         new_path, force_temp,
 
821
                                         allow_write=allow_write_new)
759
822
        return old_disk_path, new_disk_path
760
823
 
761
824
    def finish(self):
762
 
        osutils.rmtree(self._root)
 
825
        try:
 
826
            osutils.rmtree(self._root)
 
827
        except OSError, e:
 
828
            if e.errno != errno.ENOENT:
 
829
                mutter("The temporary directory \"%s\" was not "
 
830
                        "cleanly removed: %s." % (self._root, e))
763
831
 
764
832
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
765
833
        if (old_kind, new_kind) != ('file', 'file'):
766
834
            return DiffPath.CANNOT_DIFF
767
 
        self._prepare_files(file_id, old_path, new_path)
768
 
        self._execute(osutils.pathjoin('old', old_path),
769
 
                      osutils.pathjoin('new', new_path))
 
835
        (old_disk_path, new_disk_path) = self._prepare_files(
 
836
                                                file_id, old_path, new_path)
 
837
        self._execute(old_disk_path, new_disk_path)
 
838
 
 
839
    def edit_file(self, file_id):
 
840
        """Use this tool to edit a file.
 
841
 
 
842
        A temporary copy will be edited, and the new contents will be
 
843
        returned.
 
844
 
 
845
        :param file_id: The id of the file to edit.
 
846
        :return: The new contents of the file.
 
847
        """
 
848
        old_path = self.old_tree.id2path(file_id)
 
849
        new_path = self.new_tree.id2path(file_id)
 
850
        old_abs_path, new_abs_path = self._prepare_files(
 
851
                                            file_id, old_path, new_path,
 
852
                                            allow_write_new=True,
 
853
                                            force_temp=True)
 
854
        command = self._get_command(old_abs_path, new_abs_path)
 
855
        subprocess.call(command, cwd=self._root)
 
856
        new_file = open(new_abs_path, 'rb')
 
857
        try:
 
858
            return new_file.read()
 
859
        finally:
 
860
            new_file.close()
770
861
 
771
862
 
772
863
class DiffTree(object):
818
909
        """Factory for producing a DiffTree.
819
910
 
820
911
        Designed to accept options used by show_diff_trees.
 
912
 
821
913
        :param old_tree: The tree to show as old in the comparison
822
914
        :param new_tree: The tree to show as new in the comparison
823
915
        :param to_file: File to write comparisons to
829
921
        :param using: Commandline to use to invoke an external diff tool
830
922
        """
831
923
        if using is not None:
832
 
            extra_factories = [DiffFromTool.make_from_diff_tree(using)]
 
924
            extra_factories = [DiffFromTool.make_from_diff_tree(using, external_diff_options)]
833
925
        else:
834
926
            extra_factories = []
835
927
        if external_diff_options:
836
928
            opts = external_diff_options.split()
837
 
            def diff_file(olab, olines, nlab, nlines, to_file):
 
929
            def diff_file(olab, olines, nlab, nlines, to_file, path_encoding=None):
 
930
                """:param path_encoding: not used but required
 
931
                        to match the signature of internal_diff.
 
932
                """
838
933
                external_diff(olab, olines, nlab, nlines, to_file, opts)
839
934
        else:
840
935
            diff_file = internal_diff
846
941
    def show_diff(self, specific_files, extra_trees=None):
847
942
        """Write tree diff to self.to_file
848
943
 
849
 
        :param sepecific_files: the specific files to compare (recursive)
 
944
        :param specific_files: the specific files to compare (recursive)
850
945
        :param extra_trees: extra trees to use for mapping paths to file_ids
851
946
        """
852
947
        try:
874
969
                return path.encode(self.path_encoding, "replace")
875
970
        for (file_id, paths, changed_content, versioned, parent, name, kind,
876
971
             executable) in sorted(iterator, key=changes_key):
877
 
            if parent == (None, None):
 
972
            # The root does not get diffed, and items with no known kind (that
 
973
            # is, missing) in both trees are skipped as well.
 
974
            if parent == (None, None) or kind == (None, None):
878
975
                continue
879
976
            oldpath, newpath = paths
880
977
            oldpath_encoded = get_encoded_path(paths[0])
908
1005
                self.to_file.write("=== modified %s '%s'%s\n" % (kind[0],
909
1006
                                   newpath_encoded, prop_str))
910
1007
            if changed_content:
911
 
                self.diff(file_id, oldpath, newpath)
 
1008
                self._diff(file_id, oldpath, newpath, kind[0], kind[1])
912
1009
                has_changes = 1
913
1010
            if renamed:
914
1011
                has_changes = 1
929
1026
            new_kind = self.new_tree.kind(file_id)
930
1027
        except (errors.NoSuchId, errors.NoSuchFile):
931
1028
            new_kind = None
932
 
 
 
1029
        self._diff(file_id, old_path, new_path, old_kind, new_kind)
 
1030
 
 
1031
 
 
1032
    def _diff(self, file_id, old_path, new_path, old_kind, new_kind):
933
1033
        result = DiffPath._diff_many(self.differs, file_id, old_path,
934
1034
                                       new_path, old_kind, new_kind)
935
1035
        if result is DiffPath.CANNOT_DIFF:
937
1037
            if error_path is None:
938
1038
                error_path = old_path
939
1039
            raise errors.NoDiffFound(error_path)
 
1040
 
 
1041
 
 
1042
format_registry = Registry()
 
1043
format_registry.register('default', DiffTree)