← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/diff.py

  • Committer: Patch Queue Manager
  • Date: 2016-04-21 04:10:52 UTC
  • mfrom: (6616.1.1 fix-en-user-guide)
  • Revision ID: pqm@pqm.ubuntu.com-20160421041052-clcye7ns1qcl2n7w
(richard-wilbur) Ensure build of English use guide always uses English text
 even when user's locale specifies a different language. (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/diff.py
1
 
# -*- coding: UTF-8 -*-
2
 
 
 
1
# Copyright (C) 2005-2014 Canonical Ltd.
 
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
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
 
 
17
 
from bzrlib.trace import mutter
18
 
from bzrlib.errors import BzrError
19
 
from bzrlib.delta import compare_trees
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
from __future__ import absolute_import
 
18
 
 
19
import difflib
 
20
import os
 
21
import re
 
22
import string
 
23
import sys
 
24
 
 
25
from bzrlib.lazy_import import lazy_import
 
26
lazy_import(globals(), """
 
27
import errno
 
28
import subprocess
 
29
import tempfile
 
30
 
 
31
from bzrlib import (
 
32
    cleanup,
 
33
    cmdline,
 
34
    controldir,
 
35
    errors,
 
36
    osutils,
 
37
    patiencediff,
 
38
    textfile,
 
39
    timestamp,
 
40
    views,
 
41
    )
 
42
 
 
43
from bzrlib.workingtree import WorkingTree
 
44
from bzrlib.i18n import gettext
 
45
""")
 
46
 
 
47
from bzrlib.registry import (
 
48
    Registry,
 
49
    )
 
50
from bzrlib.trace import mutter, note, warning
 
51
 
 
52
DEFAULT_CONTEXT_AMOUNT = 3
 
53
 
 
54
class AtTemplate(string.Template):
 
55
    """Templating class that uses @ instead of $."""
 
56
 
 
57
    delimiter = '@'
 
58
 
20
59
 
21
60
# TODO: Rather than building a changeset object, we should probably
22
61
# invoke callbacks on an object.  That object can either accumulate a
23
62
# list, write them out directly, etc etc.
24
63
 
25
 
def internal_diff(old_label, oldlines, new_label, newlines, to_file):
26
 
    import difflib
27
 
    
 
64
 
 
65
class _PrematchedMatcher(difflib.SequenceMatcher):
 
66
    """Allow SequenceMatcher operations to use predetermined blocks"""
 
67
 
 
68
    def __init__(self, matching_blocks):
 
69
        difflib.SequenceMatcher(self, None, None)
 
70
        self.matching_blocks = matching_blocks
 
71
        self.opcodes = None
 
72
 
 
73
 
 
74
def internal_diff(old_filename, oldlines, new_filename, newlines, to_file,
 
75
                  allow_binary=False, sequence_matcher=None,
 
76
                  path_encoding='utf8', context_lines=DEFAULT_CONTEXT_AMOUNT):
28
77
    # FIXME: difflib is wrong if there is no trailing newline.
29
78
    # The syntax used by patch seems to be "\ No newline at
30
79
    # end of file" following the last diff line from that
41
90
    if not oldlines and not newlines:
42
91
        return
43
92
 
44
 
    ud = difflib.unified_diff(oldlines, newlines,
45
 
                              fromfile=old_label, tofile=new_label)
 
93
    if allow_binary is False:
 
94
        textfile.check_text_lines(oldlines)
 
95
        textfile.check_text_lines(newlines)
 
96
 
 
97
    if sequence_matcher is None:
 
98
        sequence_matcher = patiencediff.PatienceSequenceMatcher
 
99
    ud = patiencediff.unified_diff(oldlines, newlines,
 
100
                      fromfile=old_filename.encode(path_encoding, 'replace'),
 
101
                      tofile=new_filename.encode(path_encoding, 'replace'),
 
102
                      n=context_lines, sequencematcher=sequence_matcher)
46
103
 
47
104
    ud = list(ud)
 
105
    if len(ud) == 0: # Identical contents, nothing to do
 
106
        return
48
107
    # work-around for difflib being too smart for its own good
49
108
    # if /dev/null is "1,0", patch won't recognize it as /dev/null
50
109
    if not oldlines:
51
110
        ud[2] = ud[2].replace('-1,0', '-0,0')
52
111
    elif not newlines:
53
112
        ud[2] = ud[2].replace('+1,0', '+0,0')
54
 
    # work around for difflib emitting random spaces after the label
55
 
    ud[0] = ud[0][:-2] + '\n'
56
 
    ud[1] = ud[1][:-2] + '\n'
57
113
 
58
114
    for line in ud:
59
115
        to_file.write(line)
60
116
        if not line.endswith('\n'):
61
117
            to_file.write("\n\\ No newline at end of file\n")
62
 
    print >>to_file
63
 
 
64
 
 
65
 
def external_diff(old_label, oldlines, new_label, newlines, to_file,
 
118
    to_file.write('\n')
 
119
 
 
120
 
 
121
def _spawn_external_diff(diffcmd, capture_errors=True):
 
122
    """Spawn the external diff process, and return the child handle.
 
123
 
 
124
    :param diffcmd: The command list to spawn
 
125
    :param capture_errors: Capture stderr as well as setting LANG=C
 
126
        and LC_ALL=C. This lets us read and understand the output of diff,
 
127
        and respond to any errors.
 
128
    :return: A Popen object.
 
129
    """
 
130
    if capture_errors:
 
131
        # construct minimal environment
 
132
        env = {}
 
133
        path = os.environ.get('PATH')
 
134
        if path is not None:
 
135
            env['PATH'] = path
 
136
        env['LANGUAGE'] = 'C'   # on win32 only LANGUAGE has effect
 
137
        env['LANG'] = 'C'
 
138
        env['LC_ALL'] = 'C'
 
139
        stderr = subprocess.PIPE
 
140
    else:
 
141
        env = None
 
142
        stderr = None
 
143
 
 
144
    try:
 
145
        pipe = subprocess.Popen(diffcmd,
 
146
                                stdin=subprocess.PIPE,
 
147
                                stdout=subprocess.PIPE,
 
148
                                stderr=stderr,
 
149
                                env=env)
 
150
    except OSError, e:
 
151
        if e.errno == errno.ENOENT:
 
152
            raise errors.NoDiff(str(e))
 
153
        raise
 
154
 
 
155
    return pipe
 
156
 
 
157
# diff style options as of GNU diff v3.2
 
158
style_option_list = ['-c', '-C', '--context',
 
159
                     '-e', '--ed',
 
160
                     '-f', '--forward-ed',
 
161
                     '-q', '--brief',
 
162
                     '--normal',
 
163
                     '-n', '--rcs',
 
164
                     '-u', '-U', '--unified',
 
165
                     '-y', '--side-by-side',
 
166
                     '-D', '--ifdef']
 
167
 
 
168
def default_style_unified(diff_opts):
 
169
    """Default to unified diff style if alternative not specified in diff_opts.
 
170
 
 
171
        diff only allows one style to be specified; they don't override.
 
172
        Note that some of these take optargs, and the optargs can be
 
173
        directly appended to the options.
 
174
        This is only an approximate parser; it doesn't properly understand
 
175
        the grammar.
 
176
 
 
177
    :param diff_opts: List of options for external (GNU) diff.
 
178
    :return: List of options with default style=='unified'.
 
179
    """
 
180
    for s in style_option_list:
 
181
        for j in diff_opts:
 
182
            if j.startswith(s):
 
183
                break
 
184
        else:
 
185
            continue
 
186
        break
 
187
    else:
 
188
        diff_opts.append('-u')
 
189
    return diff_opts
 
190
 
 
191
 
 
192
def external_diff(old_filename, oldlines, new_filename, newlines, to_file,
66
193
                  diff_opts):
67
194
    """Display a diff by calling out to the external diff program."""
68
 
    import sys
69
 
    
70
 
    if to_file != sys.stdout:
71
 
        raise NotImplementedError("sorry, can't send external diff other than to stdout yet",
72
 
                                  to_file)
73
 
 
74
195
    # make sure our own output is properly ordered before the diff
75
196
    to_file.flush()
76
197
 
77
 
    from tempfile import NamedTemporaryFile
78
 
    import os
79
 
 
80
 
    oldtmpf = NamedTemporaryFile()
81
 
    newtmpf = NamedTemporaryFile()
 
198
    oldtmp_fd, old_abspath = tempfile.mkstemp(prefix='bzr-diff-old-')
 
199
    newtmp_fd, new_abspath = tempfile.mkstemp(prefix='bzr-diff-new-')
 
200
    oldtmpf = os.fdopen(oldtmp_fd, 'wb')
 
201
    newtmpf = os.fdopen(newtmp_fd, 'wb')
82
202
 
83
203
    try:
84
204
        # TODO: perhaps a special case for comparing to or from the empty
91
211
        oldtmpf.writelines(oldlines)
92
212
        newtmpf.writelines(newlines)
93
213
 
94
 
        oldtmpf.flush()
95
 
        newtmpf.flush()
 
214
        oldtmpf.close()
 
215
        newtmpf.close()
96
216
 
97
217
        if not diff_opts:
98
218
            diff_opts = []
 
219
        if sys.platform == 'win32':
 
220
            # Popen doesn't do the proper encoding for external commands
 
221
            # Since we are dealing with an ANSI api, use mbcs encoding
 
222
            old_filename = old_filename.encode('mbcs')
 
223
            new_filename = new_filename.encode('mbcs')
99
224
        diffcmd = ['diff',
100
 
                   '--label', old_label,
101
 
                   oldtmpf.name,
102
 
                   '--label', new_label,
103
 
                   newtmpf.name]
104
 
 
105
 
        # diff only allows one style to be specified; they don't override.
106
 
        # note that some of these take optargs, and the optargs can be
107
 
        # directly appended to the options.
108
 
        # this is only an approximate parser; it doesn't properly understand
109
 
        # the grammar.
110
 
        for s in ['-c', '-u', '-C', '-U',
111
 
                  '-e', '--ed',
112
 
                  '-q', '--brief',
113
 
                  '--normal',
114
 
                  '-n', '--rcs',
115
 
                  '-y', '--side-by-side',
116
 
                  '-D', '--ifdef']:
117
 
            for j in diff_opts:
118
 
                if j.startswith(s):
119
 
                    break
120
 
            else:
121
 
                continue
122
 
            break
123
 
        else:
124
 
            diffcmd.append('-u')
125
 
                  
 
225
                   '--label', old_filename,
 
226
                   old_abspath,
 
227
                   '--label', new_filename,
 
228
                   new_abspath,
 
229
                   '--binary',
 
230
                  ]
 
231
 
 
232
        diff_opts = default_style_unified(diff_opts)
 
233
 
126
234
        if diff_opts:
127
235
            diffcmd.extend(diff_opts)
128
236
 
129
 
        rc = os.spawnvp(os.P_WAIT, 'diff', diffcmd)
130
 
        
131
 
        if rc != 0 and rc != 1:
 
237
        pipe = _spawn_external_diff(diffcmd, capture_errors=True)
 
238
        out,err = pipe.communicate()
 
239
        rc = pipe.returncode
 
240
 
 
241
        # internal_diff() adds a trailing newline, add one here for consistency
 
242
        out += '\n'
 
243
        if rc == 2:
 
244
            # 'diff' gives retcode == 2 for all sorts of errors
 
245
            # one of those is 'Binary files differ'.
 
246
            # Bad options could also be the problem.
 
247
            # 'Binary files' is not a real error, so we suppress that error.
 
248
            lang_c_out = out
 
249
 
 
250
            # Since we got here, we want to make sure to give an i18n error
 
251
            pipe = _spawn_external_diff(diffcmd, capture_errors=False)
 
252
            out, err = pipe.communicate()
 
253
 
 
254
            # Write out the new i18n diff response
 
255
            to_file.write(out+'\n')
 
256
            if pipe.returncode != 2:
 
257
                raise errors.BzrError(
 
258
                               'external diff failed with exit code 2'
 
259
                               ' when run with LANG=C and LC_ALL=C,'
 
260
                               ' but not when run natively: %r' % (diffcmd,))
 
261
 
 
262
            first_line = lang_c_out.split('\n', 1)[0]
 
263
            # Starting with diffutils 2.8.4 the word "binary" was dropped.
 
264
            m = re.match('^(binary )?files.*differ$', first_line, re.I)
 
265
            if m is None:
 
266
                raise errors.BzrError('external diff failed with exit code 2;'
 
267
                                      ' command: %r' % (diffcmd,))
 
268
            else:
 
269
                # Binary files differ, just return
 
270
                return
 
271
 
 
272
        # If we got to here, we haven't written out the output of diff
 
273
        # do so now
 
274
        to_file.write(out)
 
275
        if rc not in (0, 1):
132
276
            # returns 1 if files differ; that's OK
133
277
            if rc < 0:
134
278
                msg = 'signal %d' % (-rc)
135
279
            else:
136
280
                msg = 'exit code %d' % rc
137
 
                
138
 
            raise BzrError('external diff failed with %s; command: %r' % (rc, diffcmd))
 
281
 
 
282
            raise errors.BzrError('external diff failed with %s; command: %r'
 
283
                                  % (msg, diffcmd))
 
284
 
 
285
 
139
286
    finally:
140
287
        oldtmpf.close()                 # and delete
141
288
        newtmpf.close()
142
289
 
143
 
def show_diff(b, from_spec, specific_files, external_diff_options=None,
144
 
              revision2=None, output=None):
145
 
    """Shortcut for showing the diff to the working tree.
146
 
 
147
 
    b
148
 
        Branch.
149
 
 
150
 
    revision
151
 
        None for 'basis tree', or otherwise the old revision to compare against.
152
 
    
153
 
    The more general form is show_diff_trees(), where the caller
154
 
    supplies any two trees.
 
290
        def cleanup(path):
 
291
            # Warn in case the file couldn't be deleted (in case windows still
 
292
            # holds the file open, but not if the files have already been
 
293
            # deleted)
 
294
            try:
 
295
                os.remove(path)
 
296
            except OSError, e:
 
297
                if e.errno not in (errno.ENOENT,):
 
298
                    warning('Failed to delete temporary file: %s %s', path, e)
 
299
 
 
300
        cleanup(old_abspath)
 
301
        cleanup(new_abspath)
 
302
 
 
303
 
 
304
def get_trees_and_branches_to_diff_locked(
 
305
    path_list, revision_specs, old_url, new_url, add_cleanup, apply_view=True):
 
306
    """Get the trees and specific files to diff given a list of paths.
 
307
 
 
308
    This method works out the trees to be diff'ed and the files of
 
309
    interest within those trees.
 
310
 
 
311
    :param path_list:
 
312
        the list of arguments passed to the diff command
 
313
    :param revision_specs:
 
314
        Zero, one or two RevisionSpecs from the diff command line,
 
315
        saying what revisions to compare.
 
316
    :param old_url:
 
317
        The url of the old branch or tree. If None, the tree to use is
 
318
        taken from the first path, if any, or the current working tree.
 
319
    :param new_url:
 
320
        The url of the new branch or tree. If None, the tree to use is
 
321
        taken from the first path, if any, or the current working tree.
 
322
    :param add_cleanup:
 
323
        a callable like Command.add_cleanup.  get_trees_and_branches_to_diff
 
324
        will register cleanups that must be run to unlock the trees, etc.
 
325
    :param apply_view:
 
326
        if True and a view is set, apply the view or check that the paths
 
327
        are within it
 
328
    :returns:
 
329
        a tuple of (old_tree, new_tree, old_branch, new_branch,
 
330
        specific_files, extra_trees) where extra_trees is a sequence of
 
331
        additional trees to search in for file-ids.  The trees and branches
 
332
        will be read-locked until the cleanups registered via the add_cleanup
 
333
        param are run.
155
334
    """
156
 
    if output is None:
157
 
        import sys
158
 
        output = sys.stdout
159
 
 
160
 
    if from_spec is None:
161
 
        old_tree = b.basis_tree()
162
 
    else:
163
 
        old_tree = b.revision_tree(from_spec.in_history(b).rev_id)
164
 
 
165
 
    if revision2 is None:
166
 
        new_tree = b.working_tree()
167
 
    else:
168
 
        new_tree = b.revision_tree(revision2.in_history(b).rev_id)
169
 
 
170
 
    show_diff_trees(old_tree, new_tree, output, specific_files,
171
 
                    external_diff_options)
172
 
 
 
335
    # Get the old and new revision specs
 
336
    old_revision_spec = None
 
337
    new_revision_spec = None
 
338
    if revision_specs is not None:
 
339
        if len(revision_specs) > 0:
 
340
            old_revision_spec = revision_specs[0]
 
341
            if old_url is None:
 
342
                old_url = old_revision_spec.get_branch()
 
343
        if len(revision_specs) > 1:
 
344
            new_revision_spec = revision_specs[1]
 
345
            if new_url is None:
 
346
                new_url = new_revision_spec.get_branch()
 
347
 
 
348
    other_paths = []
 
349
    make_paths_wt_relative = True
 
350
    consider_relpath = True
 
351
    if path_list is None or len(path_list) == 0:
 
352
        # If no path is given, the current working tree is used
 
353
        default_location = u'.'
 
354
        consider_relpath = False
 
355
    elif old_url is not None and new_url is not None:
 
356
        other_paths = path_list
 
357
        make_paths_wt_relative = False
 
358
    else:
 
359
        default_location = path_list[0]
 
360
        other_paths = path_list[1:]
 
361
 
 
362
    def lock_tree_or_branch(wt, br):
 
363
        if wt is not None:
 
364
            wt.lock_read()
 
365
            add_cleanup(wt.unlock)
 
366
        elif br is not None:
 
367
            br.lock_read()
 
368
            add_cleanup(br.unlock)
 
369
 
 
370
    # Get the old location
 
371
    specific_files = []
 
372
    if old_url is None:
 
373
        old_url = default_location
 
374
    working_tree, branch, relpath = \
 
375
        controldir.ControlDir.open_containing_tree_or_branch(old_url)
 
376
    lock_tree_or_branch(working_tree, branch)
 
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)
 
380
        specific_files.append(relpath)
 
381
    old_tree = _get_tree_to_diff(old_revision_spec, working_tree, branch)
 
382
    old_branch = branch
 
383
 
 
384
    # Get the new location
 
385
    if new_url is None:
 
386
        new_url = default_location
 
387
    if new_url != old_url:
 
388
        working_tree, branch, relpath = \
 
389
            controldir.ControlDir.open_containing_tree_or_branch(new_url)
 
390
        lock_tree_or_branch(working_tree, branch)
 
391
        if consider_relpath and relpath != '':
 
392
            if working_tree is not None and apply_view:
 
393
                views.check_path_in_view(working_tree, relpath)
 
394
            specific_files.append(relpath)
 
395
    new_tree = _get_tree_to_diff(new_revision_spec, working_tree, branch,
 
396
        basis_is_default=working_tree is None)
 
397
    new_branch = branch
 
398
 
 
399
    # Get the specific files (all files is None, no files is [])
 
400
    if make_paths_wt_relative and working_tree is not None:
 
401
        other_paths = working_tree.safe_relpath_files(
 
402
            other_paths,
 
403
            apply_view=apply_view)
 
404
    specific_files.extend(other_paths)
 
405
    if len(specific_files) == 0:
 
406
        specific_files = None
 
407
        if (working_tree is not None and working_tree.supports_views()
 
408
            and apply_view):
 
409
            view_files = working_tree.views.lookup_view()
 
410
            if view_files:
 
411
                specific_files = view_files
 
412
                view_str = views.view_display_str(view_files)
 
413
                note(gettext("*** Ignoring files outside view. View is %s") % view_str)
 
414
 
 
415
    # Get extra trees that ought to be searched for file-ids
 
416
    extra_trees = None
 
417
    if working_tree is not None and working_tree not in (old_tree, new_tree):
 
418
        extra_trees = (working_tree,)
 
419
    return (old_tree, new_tree, old_branch, new_branch,
 
420
            specific_files, extra_trees)
 
421
 
 
422
 
 
423
def _get_tree_to_diff(spec, tree=None, branch=None, basis_is_default=True):
 
424
    if branch is None and tree is not None:
 
425
        branch = tree.branch
 
426
    if spec is None or spec.spec is None:
 
427
        if basis_is_default:
 
428
            if tree is not None:
 
429
                return tree.basis_tree()
 
430
            else:
 
431
                return branch.basis_tree()
 
432
        else:
 
433
            return tree
 
434
    return spec.as_tree(branch)
173
435
 
174
436
 
175
437
def show_diff_trees(old_tree, new_tree, to_file, specific_files=None,
176
 
                    external_diff_options=None):
 
438
                    external_diff_options=None,
 
439
                    old_label='a/', new_label='b/',
 
440
                    extra_trees=None,
 
441
                    path_encoding='utf8',
 
442
                    using=None,
 
443
                    format_cls=None,
 
444
                    context=DEFAULT_CONTEXT_AMOUNT):
177
445
    """Show in text form the changes from one tree to another.
178
446
 
179
 
    to_files
180
 
        If set, include only changes to these files.
181
 
 
182
 
    external_diff_options
183
 
        If set, use an external GNU diff and pass these options.
184
 
    """
185
 
 
186
 
    # TODO: Options to control putting on a prefix or suffix, perhaps as a format string
187
 
    old_label = ''
188
 
    new_label = ''
189
 
 
190
 
    DEVNULL = '/dev/null'
191
 
    # Windows users, don't panic about this filename -- it is a
192
 
    # special signal to GNU patch that the file should be created or
193
 
    # deleted respectively.
194
 
 
195
 
    # TODO: Generation of pseudo-diffs for added/deleted files could
196
 
    # be usefully made into a much faster special case.
197
 
 
198
 
    if external_diff_options:
199
 
        assert isinstance(external_diff_options, basestring)
200
 
        opts = external_diff_options.split()
201
 
        def diff_file(olab, olines, nlab, nlines, to_file):
202
 
            external_diff(olab, olines, nlab, nlines, to_file, opts)
203
 
    else:
204
 
        diff_file = internal_diff
205
 
    
206
 
 
207
 
    delta = compare_trees(old_tree, new_tree, want_unchanged=False,
208
 
                          specific_files=specific_files)
209
 
 
210
 
    for path, file_id, kind in delta.removed:
211
 
        print >>to_file, '=== removed %s %r' % (kind, path)
212
 
        old_tree.inventory[file_id].diff(diff_file, old_label + path, old_tree,
213
 
                                         DEVNULL, None, None, to_file)
214
 
    for path, file_id, kind in delta.added:
215
 
        print >>to_file, '=== added %s %r' % (kind, path)
216
 
        new_tree.inventory[file_id].diff(diff_file, new_label + path, new_tree,
217
 
                                         DEVNULL, None, None, to_file, 
218
 
                                         reverse=True)
219
 
    for (old_path, new_path, file_id, kind,
220
 
         text_modified, meta_modified) in delta.renamed:
221
 
        prop_str = get_prop_change(meta_modified)
222
 
        print >>to_file, '=== renamed %s %r => %r%s' % (
223
 
                          kind, old_path, new_path, prop_str)
224
 
        _maybe_diff_file_or_symlink(old_label, old_path, old_tree, file_id,
225
 
                                    new_label, new_path, new_tree,
226
 
                                    text_modified, kind, to_file, diff_file)
227
 
    for path, file_id, kind, text_modified, meta_modified in delta.modified:
228
 
        prop_str = get_prop_change(meta_modified)
229
 
        print >>to_file, '=== modified %s %r%s' % (kind, path, prop_str)
230
 
        if text_modified:
231
 
            _maybe_diff_file_or_symlink(old_label, path, old_tree, file_id,
232
 
                                        new_label, path, new_tree,
233
 
                                        True, kind, to_file, diff_file)
234
 
    
235
 
 
236
 
def get_prop_change(meta_modified):
237
 
    if meta_modified:
238
 
        return " (properties changed)"
239
 
    else:
240
 
        return  ""
241
 
 
242
 
 
243
 
def _maybe_diff_file_or_symlink(old_label, old_path, old_tree, file_id,
244
 
                                new_label, new_path, new_tree, text_modified,
245
 
                                kind, to_file, diff_file):
246
 
    if text_modified:
247
 
        new_entry = new_tree.inventory[file_id]
248
 
        old_tree.inventory[file_id].diff(diff_file,
249
 
                                         old_label + old_path, old_tree,
250
 
                                         new_label + new_path, new_entry, 
251
 
                                         new_tree, to_file)
 
447
    :param to_file: The output stream.
 
448
    :param specific_files: Include only changes to these files - None for all
 
449
        changes.
 
450
    :param external_diff_options: If set, use an external GNU diff and pass 
 
451
        these options.
 
452
    :param extra_trees: If set, more Trees to use for looking up file ids
 
453
    :param path_encoding: If set, the path will be encoded as specified, 
 
454
        otherwise is supposed to be utf8
 
455
    :param format_cls: Formatter class (DiffTree subclass)
 
456
    """
 
457
    if context is None:
 
458
        context = DEFAULT_CONTEXT_AMOUNT
 
459
    if format_cls is None:
 
460
        format_cls = DiffTree
 
461
    old_tree.lock_read()
 
462
    try:
 
463
        if extra_trees is not None:
 
464
            for tree in extra_trees:
 
465
                tree.lock_read()
 
466
        new_tree.lock_read()
 
467
        try:
 
468
            differ = format_cls.from_trees_options(old_tree, new_tree, to_file,
 
469
                                                   path_encoding,
 
470
                                                   external_diff_options,
 
471
                                                   old_label, new_label, using,
 
472
                                                   context_lines=context)
 
473
            return differ.show_diff(specific_files, extra_trees)
 
474
        finally:
 
475
            new_tree.unlock()
 
476
            if extra_trees is not None:
 
477
                for tree in extra_trees:
 
478
                    tree.unlock()
 
479
    finally:
 
480
        old_tree.unlock()
 
481
 
 
482
 
 
483
def _patch_header_date(tree, file_id, path):
 
484
    """Returns a timestamp suitable for use in a patch header."""
 
485
    try:
 
486
        mtime = tree.get_file_mtime(file_id, path)
 
487
    except errors.FileTimestampUnavailable:
 
488
        mtime = 0
 
489
    return timestamp.format_patch_date(mtime)
 
490
 
 
491
 
 
492
def get_executable_change(old_is_x, new_is_x):
 
493
    descr = { True:"+x", False:"-x", None:"??" }
 
494
    if old_is_x != new_is_x:
 
495
        return ["%s to %s" % (descr[old_is_x], descr[new_is_x],)]
 
496
    else:
 
497
        return []
 
498
 
 
499
 
 
500
class DiffPath(object):
 
501
    """Base type for command object that compare files"""
 
502
 
 
503
    # The type or contents of the file were unsuitable for diffing
 
504
    CANNOT_DIFF = 'CANNOT_DIFF'
 
505
    # The file has changed in a semantic way
 
506
    CHANGED = 'CHANGED'
 
507
    # The file content may have changed, but there is no semantic change
 
508
    UNCHANGED = 'UNCHANGED'
 
509
 
 
510
    def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8'):
 
511
        """Constructor.
 
512
 
 
513
        :param old_tree: The tree to show as the old tree in the comparison
 
514
        :param new_tree: The tree to show as new in the comparison
 
515
        :param to_file: The file to write comparison data to
 
516
        :param path_encoding: The character encoding to write paths in
 
517
        """
 
518
        self.old_tree = old_tree
 
519
        self.new_tree = new_tree
 
520
        self.to_file = to_file
 
521
        self.path_encoding = path_encoding
 
522
 
 
523
    def finish(self):
 
524
        pass
 
525
 
 
526
    @classmethod
 
527
    def from_diff_tree(klass, diff_tree):
 
528
        return klass(diff_tree.old_tree, diff_tree.new_tree,
 
529
                     diff_tree.to_file, diff_tree.path_encoding)
 
530
 
 
531
    @staticmethod
 
532
    def _diff_many(differs, file_id, old_path, new_path, old_kind, new_kind):
 
533
        for file_differ in differs:
 
534
            result = file_differ.diff(file_id, old_path, new_path, old_kind,
 
535
                                      new_kind)
 
536
            if result is not DiffPath.CANNOT_DIFF:
 
537
                return result
 
538
        else:
 
539
            return DiffPath.CANNOT_DIFF
 
540
 
 
541
 
 
542
class DiffKindChange(object):
 
543
    """Special differ for file kind changes.
 
544
 
 
545
    Represents kind change as deletion + creation.  Uses the other differs
 
546
    to do this.
 
547
    """
 
548
    def __init__(self, differs):
 
549
        self.differs = differs
 
550
 
 
551
    def finish(self):
 
552
        pass
 
553
 
 
554
    @classmethod
 
555
    def from_diff_tree(klass, diff_tree):
 
556
        return klass(diff_tree.differs)
 
557
 
 
558
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
 
559
        """Perform comparison
 
560
 
 
561
        :param file_id: The file_id of the file to compare
 
562
        :param old_path: Path of the file in the old tree
 
563
        :param new_path: Path of the file in the new tree
 
564
        :param old_kind: Old file-kind of the file
 
565
        :param new_kind: New file-kind of the file
 
566
        """
 
567
        if None in (old_kind, new_kind):
 
568
            return DiffPath.CANNOT_DIFF
 
569
        result = DiffPath._diff_many(self.differs, file_id, old_path,
 
570
                                       new_path, old_kind, None)
 
571
        if result is DiffPath.CANNOT_DIFF:
 
572
            return result
 
573
        return DiffPath._diff_many(self.differs, file_id, old_path, new_path,
 
574
                                     None, new_kind)
 
575
 
 
576
 
 
577
class DiffDirectory(DiffPath):
 
578
 
 
579
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
 
580
        """Perform comparison between two directories.  (dummy)
 
581
 
 
582
        """
 
583
        if 'directory' not in (old_kind, new_kind):
 
584
            return self.CANNOT_DIFF
 
585
        if old_kind not in ('directory', None):
 
586
            return self.CANNOT_DIFF
 
587
        if new_kind not in ('directory', None):
 
588
            return self.CANNOT_DIFF
 
589
        return self.CHANGED
 
590
 
 
591
 
 
592
class DiffSymlink(DiffPath):
 
593
 
 
594
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
 
595
        """Perform comparison between two symlinks
 
596
 
 
597
        :param file_id: The file_id of the file to compare
 
598
        :param old_path: Path of the file in the old tree
 
599
        :param new_path: Path of the file in the new tree
 
600
        :param old_kind: Old file-kind of the file
 
601
        :param new_kind: New file-kind of the file
 
602
        """
 
603
        if 'symlink' not in (old_kind, new_kind):
 
604
            return self.CANNOT_DIFF
 
605
        if old_kind == 'symlink':
 
606
            old_target = self.old_tree.get_symlink_target(file_id)
 
607
        elif old_kind is None:
 
608
            old_target = None
 
609
        else:
 
610
            return self.CANNOT_DIFF
 
611
        if new_kind == 'symlink':
 
612
            new_target = self.new_tree.get_symlink_target(file_id)
 
613
        elif new_kind is None:
 
614
            new_target = None
 
615
        else:
 
616
            return self.CANNOT_DIFF
 
617
        return self.diff_symlink(old_target, new_target)
 
618
 
 
619
    def diff_symlink(self, old_target, new_target):
 
620
        if old_target is None:
 
621
            self.to_file.write('=== target is %r\n' % new_target)
 
622
        elif new_target is None:
 
623
            self.to_file.write('=== target was %r\n' % old_target)
 
624
        else:
 
625
            self.to_file.write('=== target changed %r => %r\n' %
 
626
                              (old_target, new_target))
 
627
        return self.CHANGED
 
628
 
 
629
 
 
630
class DiffText(DiffPath):
 
631
 
 
632
    # GNU Patch uses the epoch date to detect files that are being added
 
633
    # or removed in a diff.
 
634
    EPOCH_DATE = '1970-01-01 00:00:00 +0000'
 
635
 
 
636
    def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8', 
 
637
                 old_label='', new_label='', text_differ=internal_diff, 
 
638
                 context_lines=DEFAULT_CONTEXT_AMOUNT):
 
639
        DiffPath.__init__(self, old_tree, new_tree, to_file, path_encoding)
 
640
        self.text_differ = text_differ
 
641
        self.old_label = old_label
 
642
        self.new_label = new_label
 
643
        self.path_encoding = path_encoding
 
644
        self.context_lines = context_lines
 
645
 
 
646
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
 
647
        """Compare two files in unified diff format
 
648
 
 
649
        :param file_id: The file_id of the file to compare
 
650
        :param old_path: Path of the file in the old tree
 
651
        :param new_path: Path of the file in the new tree
 
652
        :param old_kind: Old file-kind of the file
 
653
        :param new_kind: New file-kind of the file
 
654
        """
 
655
        if 'file' not in (old_kind, new_kind):
 
656
            return self.CANNOT_DIFF
 
657
        from_file_id = to_file_id = file_id
 
658
        if old_kind == 'file':
 
659
            old_date = _patch_header_date(self.old_tree, file_id, old_path)
 
660
        elif old_kind is None:
 
661
            old_date = self.EPOCH_DATE
 
662
            from_file_id = None
 
663
        else:
 
664
            return self.CANNOT_DIFF
 
665
        if new_kind == 'file':
 
666
            new_date = _patch_header_date(self.new_tree, file_id, new_path)
 
667
        elif new_kind is None:
 
668
            new_date = self.EPOCH_DATE
 
669
            to_file_id = None
 
670
        else:
 
671
            return self.CANNOT_DIFF
 
672
        from_label = '%s%s\t%s' % (self.old_label, old_path, old_date)
 
673
        to_label = '%s%s\t%s' % (self.new_label, new_path, new_date)
 
674
        return self.diff_text(from_file_id, to_file_id, from_label, to_label,
 
675
            old_path, new_path)
 
676
 
 
677
    def diff_text(self, from_file_id, to_file_id, from_label, to_label,
 
678
        from_path=None, to_path=None):
 
679
        """Diff the content of given files in two trees
 
680
 
 
681
        :param from_file_id: The id of the file in the from tree.  If None,
 
682
            the file is not present in the from tree.
 
683
        :param to_file_id: The id of the file in the to tree.  This may refer
 
684
            to a different file from from_file_id.  If None,
 
685
            the file is not present in the to tree.
 
686
        :param from_path: The path in the from tree or None if unknown.
 
687
        :param to_path: The path in the to tree or None if unknown.
 
688
        """
 
689
        def _get_text(tree, file_id, path):
 
690
            if file_id is not None:
 
691
                return tree.get_file_lines(file_id, path)
 
692
            else:
 
693
                return []
 
694
        try:
 
695
            from_text = _get_text(self.old_tree, from_file_id, from_path)
 
696
            to_text = _get_text(self.new_tree, to_file_id, to_path)
 
697
            self.text_differ(from_label, from_text, to_label, to_text,
 
698
                             self.to_file, path_encoding=self.path_encoding,
 
699
                             context_lines=self.context_lines)
 
700
        except errors.BinaryFile:
 
701
            self.to_file.write(
 
702
                  ("Binary files %s and %s differ\n" %
 
703
                  (from_label, to_label)).encode(self.path_encoding,'replace'))
 
704
        return self.CHANGED
 
705
 
 
706
 
 
707
class DiffFromTool(DiffPath):
 
708
 
 
709
    def __init__(self, command_template, old_tree, new_tree, to_file,
 
710
                 path_encoding='utf-8'):
 
711
        DiffPath.__init__(self, old_tree, new_tree, to_file, path_encoding)
 
712
        self.command_template = command_template
 
713
        self._root = osutils.mkdtemp(prefix='bzr-diff-')
 
714
 
 
715
    @classmethod
 
716
    def from_string(klass, command_string, old_tree, new_tree, to_file,
 
717
                    path_encoding='utf-8'):
 
718
        command_template = cmdline.split(command_string)
 
719
        if '@' not in command_string:
 
720
            command_template.extend(['@old_path', '@new_path'])
 
721
        return klass(command_template, old_tree, new_tree, to_file,
 
722
                     path_encoding)
 
723
 
 
724
    @classmethod
 
725
    def make_from_diff_tree(klass, command_string, external_diff_options=None):
 
726
        def from_diff_tree(diff_tree):
 
727
            full_command_string = [command_string]
 
728
            if external_diff_options is not None:
 
729
                full_command_string += ' ' + external_diff_options
 
730
            return klass.from_string(full_command_string, diff_tree.old_tree,
 
731
                                     diff_tree.new_tree, diff_tree.to_file)
 
732
        return from_diff_tree
 
733
 
 
734
    def _get_command(self, old_path, new_path):
 
735
        my_map = {'old_path': old_path, 'new_path': new_path}
 
736
        command = [AtTemplate(t).substitute(my_map) for t in
 
737
                   self.command_template]
 
738
        if sys.platform == 'win32': # Popen doesn't accept unicode on win32
 
739
            command_encoded = []
 
740
            for c in command:
 
741
                if isinstance(c, unicode):
 
742
                    command_encoded.append(c.encode('mbcs'))
 
743
                else:
 
744
                    command_encoded.append(c)
 
745
            return command_encoded
 
746
        else:
 
747
            return command
 
748
 
 
749
    def _execute(self, old_path, new_path):
 
750
        command = self._get_command(old_path, new_path)
 
751
        try:
 
752
            proc = subprocess.Popen(command, stdout=subprocess.PIPE,
 
753
                                    cwd=self._root)
 
754
        except OSError, e:
 
755
            if e.errno == errno.ENOENT:
 
756
                raise errors.ExecutableMissing(command[0])
 
757
            else:
 
758
                raise
 
759
        self.to_file.write(proc.stdout.read())
 
760
        return proc.wait()
 
761
 
 
762
    def _try_symlink_root(self, tree, prefix):
 
763
        if (getattr(tree, 'abspath', None) is None
 
764
            or not osutils.host_os_dereferences_symlinks()):
 
765
            return False
 
766
        try:
 
767
            os.symlink(tree.abspath(''), osutils.pathjoin(self._root, prefix))
 
768
        except OSError, e:
 
769
            if e.errno != errno.EEXIST:
 
770
                raise
 
771
        return True
 
772
 
 
773
    @staticmethod
 
774
    def _fenc():
 
775
        """Returns safe encoding for passing file path to diff tool"""
 
776
        if sys.platform == 'win32':
 
777
            return 'mbcs'
 
778
        else:
 
779
            # Don't fallback to 'utf-8' because subprocess may not be able to
 
780
            # handle utf-8 correctly when locale is not utf-8.
 
781
            return sys.getfilesystemencoding() or 'ascii'
 
782
 
 
783
    def _is_safepath(self, path):
 
784
        """Return true if `path` may be able to pass to subprocess."""
 
785
        fenc = self._fenc()
 
786
        try:
 
787
            return path == path.encode(fenc).decode(fenc)
 
788
        except UnicodeError:
 
789
            return False
 
790
 
 
791
    def _safe_filename(self, prefix, relpath):
 
792
        """Replace unsafe character in `relpath` then join `self._root`,
 
793
        `prefix` and `relpath`."""
 
794
        fenc = self._fenc()
 
795
        # encoded_str.replace('?', '_') may break multibyte char.
 
796
        # So we should encode, decode, then replace(u'?', u'_')
 
797
        relpath_tmp = relpath.encode(fenc, 'replace').decode(fenc, 'replace')
 
798
        relpath_tmp = relpath_tmp.replace(u'?', u'_')
 
799
        return osutils.pathjoin(self._root, prefix, relpath_tmp)
 
800
 
 
801
    def _write_file(self, file_id, tree, prefix, relpath, force_temp=False,
 
802
                    allow_write=False):
 
803
        if not force_temp and isinstance(tree, WorkingTree):
 
804
            full_path = tree.abspath(tree.id2path(file_id))
 
805
            if self._is_safepath(full_path):
 
806
                return full_path
 
807
 
 
808
        full_path = self._safe_filename(prefix, relpath)
 
809
        if not force_temp and self._try_symlink_root(tree, prefix):
 
810
            return full_path
 
811
        parent_dir = osutils.dirname(full_path)
 
812
        try:
 
813
            os.makedirs(parent_dir)
 
814
        except OSError, e:
 
815
            if e.errno != errno.EEXIST:
 
816
                raise
 
817
        source = tree.get_file(file_id, relpath)
 
818
        try:
 
819
            target = open(full_path, 'wb')
 
820
            try:
 
821
                osutils.pumpfile(source, target)
 
822
            finally:
 
823
                target.close()
 
824
        finally:
 
825
            source.close()
 
826
        try:
 
827
            mtime = tree.get_file_mtime(file_id)
 
828
        except errors.FileTimestampUnavailable:
 
829
            pass
 
830
        else:
 
831
            os.utime(full_path, (mtime, mtime))
 
832
        if not allow_write:
 
833
            osutils.make_readonly(full_path)
 
834
        return full_path
 
835
 
 
836
    def _prepare_files(self, file_id, old_path, new_path, force_temp=False,
 
837
                       allow_write_new=False):
 
838
        old_disk_path = self._write_file(file_id, self.old_tree, 'old',
 
839
                                         old_path, force_temp)
 
840
        new_disk_path = self._write_file(file_id, self.new_tree, 'new',
 
841
                                         new_path, force_temp,
 
842
                                         allow_write=allow_write_new)
 
843
        return old_disk_path, new_disk_path
 
844
 
 
845
    def finish(self):
 
846
        try:
 
847
            osutils.rmtree(self._root)
 
848
        except OSError, e:
 
849
            if e.errno != errno.ENOENT:
 
850
                mutter("The temporary directory \"%s\" was not "
 
851
                        "cleanly removed: %s." % (self._root, e))
 
852
 
 
853
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
 
854
        if (old_kind, new_kind) != ('file', 'file'):
 
855
            return DiffPath.CANNOT_DIFF
 
856
        (old_disk_path, new_disk_path) = self._prepare_files(
 
857
                                                file_id, old_path, new_path)
 
858
        self._execute(old_disk_path, new_disk_path)
 
859
 
 
860
    def edit_file(self, file_id):
 
861
        """Use this tool to edit a file.
 
862
 
 
863
        A temporary copy will be edited, and the new contents will be
 
864
        returned.
 
865
 
 
866
        :param file_id: The id of the file to edit.
 
867
        :return: The new contents of the file.
 
868
        """
 
869
        old_path = self.old_tree.id2path(file_id)
 
870
        new_path = self.new_tree.id2path(file_id)
 
871
        old_abs_path, new_abs_path = self._prepare_files(
 
872
                                            file_id, old_path, new_path,
 
873
                                            allow_write_new=True,
 
874
                                            force_temp=True)
 
875
        command = self._get_command(old_abs_path, new_abs_path)
 
876
        subprocess.call(command, cwd=self._root)
 
877
        new_file = open(new_abs_path, 'rb')
 
878
        try:
 
879
            return new_file.read()
 
880
        finally:
 
881
            new_file.close()
 
882
 
 
883
 
 
884
class DiffTree(object):
 
885
    """Provides textual representations of the difference between two trees.
 
886
 
 
887
    A DiffTree examines two trees and where a file-id has altered
 
888
    between them, generates a textual representation of the difference.
 
889
    DiffTree uses a sequence of DiffPath objects which are each
 
890
    given the opportunity to handle a given altered fileid. The list
 
891
    of DiffPath objects can be extended globally by appending to
 
892
    DiffTree.diff_factories, or for a specific diff operation by
 
893
    supplying the extra_factories option to the appropriate method.
 
894
    """
 
895
 
 
896
    # list of factories that can provide instances of DiffPath objects
 
897
    # may be extended by plugins.
 
898
    diff_factories = [DiffSymlink.from_diff_tree,
 
899
                      DiffDirectory.from_diff_tree]
 
900
 
 
901
    def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8',
 
902
                 diff_text=None, extra_factories=None):
 
903
        """Constructor
 
904
 
 
905
        :param old_tree: Tree to show as old in the comparison
 
906
        :param new_tree: Tree to show as new in the comparison
 
907
        :param to_file: File to write comparision to
 
908
        :param path_encoding: Character encoding to write paths in
 
909
        :param diff_text: DiffPath-type object to use as a last resort for
 
910
            diffing text files.
 
911
        :param extra_factories: Factories of DiffPaths to try before any other
 
912
            DiffPaths"""
 
913
        if diff_text is None:
 
914
            diff_text = DiffText(old_tree, new_tree, to_file, path_encoding,
 
915
                                 '', '',  internal_diff)
 
916
        self.old_tree = old_tree
 
917
        self.new_tree = new_tree
 
918
        self.to_file = to_file
 
919
        self.path_encoding = path_encoding
 
920
        self.differs = []
 
921
        if extra_factories is not None:
 
922
            self.differs.extend(f(self) for f in extra_factories)
 
923
        self.differs.extend(f(self) for f in self.diff_factories)
 
924
        self.differs.extend([diff_text, DiffKindChange.from_diff_tree(self)])
 
925
 
 
926
    @classmethod
 
927
    def from_trees_options(klass, old_tree, new_tree, to_file,
 
928
                           path_encoding, external_diff_options, old_label,
 
929
                           new_label, using, context_lines):
 
930
        """Factory for producing a DiffTree.
 
931
 
 
932
        Designed to accept options used by show_diff_trees.
 
933
 
 
934
        :param old_tree: The tree to show as old in the comparison
 
935
        :param new_tree: The tree to show as new in the comparison
 
936
        :param to_file: File to write comparisons to
 
937
        :param path_encoding: Character encoding to use for writing paths
 
938
        :param external_diff_options: If supplied, use the installed diff
 
939
            binary to perform file comparison, using supplied options.
 
940
        :param old_label: Prefix to use for old file labels
 
941
        :param new_label: Prefix to use for new file labels
 
942
        :param using: Commandline to use to invoke an external diff tool
 
943
        """
 
944
        if using is not None:
 
945
            extra_factories = [DiffFromTool.make_from_diff_tree(using, external_diff_options)]
 
946
        else:
 
947
            extra_factories = []
 
948
        if external_diff_options:
 
949
            opts = external_diff_options.split()
 
950
            def diff_file(olab, olines, nlab, nlines, to_file, path_encoding=None, context_lines=None):
 
951
                """:param path_encoding: not used but required
 
952
                        to match the signature of internal_diff.
 
953
                """
 
954
                external_diff(olab, olines, nlab, nlines, to_file, opts)
 
955
        else:
 
956
            diff_file = internal_diff
 
957
        diff_text = DiffText(old_tree, new_tree, to_file, path_encoding,
 
958
                             old_label, new_label, diff_file, context_lines=context_lines)
 
959
        return klass(old_tree, new_tree, to_file, path_encoding, diff_text,
 
960
                     extra_factories)
 
961
 
 
962
    def show_diff(self, specific_files, extra_trees=None):
 
963
        """Write tree diff to self.to_file
 
964
 
 
965
        :param specific_files: the specific files to compare (recursive)
 
966
        :param extra_trees: extra trees to use for mapping paths to file_ids
 
967
        """
 
968
        try:
 
969
            return self._show_diff(specific_files, extra_trees)
 
970
        finally:
 
971
            for differ in self.differs:
 
972
                differ.finish()
 
973
 
 
974
    def _show_diff(self, specific_files, extra_trees):
 
975
        # TODO: Generation of pseudo-diffs for added/deleted files could
 
976
        # be usefully made into a much faster special case.
 
977
        iterator = self.new_tree.iter_changes(self.old_tree,
 
978
                                               specific_files=specific_files,
 
979
                                               extra_trees=extra_trees,
 
980
                                               require_versioned=True)
 
981
        has_changes = 0
 
982
        def changes_key(change):
 
983
            old_path, new_path = change[1]
 
984
            path = new_path
 
985
            if path is None:
 
986
                path = old_path
 
987
            return path
 
988
        def get_encoded_path(path):
 
989
            if path is not None:
 
990
                return path.encode(self.path_encoding, "replace")
 
991
        for (file_id, paths, changed_content, versioned, parent, name, kind,
 
992
             executable) in sorted(iterator, key=changes_key):
 
993
            # The root does not get diffed, and items with no known kind (that
 
994
            # is, missing) in both trees are skipped as well.
 
995
            if parent == (None, None) or kind == (None, None):
 
996
                continue
 
997
            oldpath, newpath = paths
 
998
            oldpath_encoded = get_encoded_path(paths[0])
 
999
            newpath_encoded = get_encoded_path(paths[1])
 
1000
            old_present = (kind[0] is not None and versioned[0])
 
1001
            new_present = (kind[1] is not None and versioned[1])
 
1002
            renamed = (parent[0], name[0]) != (parent[1], name[1])
 
1003
 
 
1004
            properties_changed = []
 
1005
            properties_changed.extend(get_executable_change(executable[0], executable[1]))
 
1006
 
 
1007
            if properties_changed:
 
1008
                prop_str = " (properties changed: %s)" % (", ".join(properties_changed),)
 
1009
            else:
 
1010
                prop_str = ""
 
1011
 
 
1012
            if (old_present, new_present) == (True, False):
 
1013
                self.to_file.write("=== removed %s '%s'\n" %
 
1014
                                   (kind[0], oldpath_encoded))
 
1015
                newpath = oldpath
 
1016
            elif (old_present, new_present) == (False, True):
 
1017
                self.to_file.write("=== added %s '%s'\n" %
 
1018
                                   (kind[1], newpath_encoded))
 
1019
                oldpath = newpath
 
1020
            elif renamed:
 
1021
                self.to_file.write("=== renamed %s '%s' => '%s'%s\n" %
 
1022
                    (kind[0], oldpath_encoded, newpath_encoded, prop_str))
 
1023
            else:
 
1024
                # if it was produced by iter_changes, it must be
 
1025
                # modified *somehow*, either content or execute bit.
 
1026
                self.to_file.write("=== modified %s '%s'%s\n" % (kind[0],
 
1027
                                   newpath_encoded, prop_str))
 
1028
            if changed_content:
 
1029
                self._diff(file_id, oldpath, newpath, kind[0], kind[1])
 
1030
                has_changes = 1
 
1031
            if renamed:
 
1032
                has_changes = 1
 
1033
        return has_changes
 
1034
 
 
1035
    def diff(self, file_id, old_path, new_path):
 
1036
        """Perform a diff of a single file
 
1037
 
 
1038
        :param file_id: file-id of the file
 
1039
        :param old_path: The path of the file in the old tree
 
1040
        :param new_path: The path of the file in the new tree
 
1041
        """
 
1042
        try:
 
1043
            old_kind = self.old_tree.kind(file_id)
 
1044
        except (errors.NoSuchId, errors.NoSuchFile):
 
1045
            old_kind = None
 
1046
        try:
 
1047
            new_kind = self.new_tree.kind(file_id)
 
1048
        except (errors.NoSuchId, errors.NoSuchFile):
 
1049
            new_kind = None
 
1050
        self._diff(file_id, old_path, new_path, old_kind, new_kind)
 
1051
 
 
1052
 
 
1053
    def _diff(self, file_id, old_path, new_path, old_kind, new_kind):
 
1054
        result = DiffPath._diff_many(self.differs, file_id, old_path,
 
1055
                                       new_path, old_kind, new_kind)
 
1056
        if result is DiffPath.CANNOT_DIFF:
 
1057
            error_path = new_path
 
1058
            if error_path is None:
 
1059
                error_path = old_path
 
1060
            raise errors.NoDiffFound(error_path)
 
1061
 
 
1062
 
 
1063
format_registry = Registry()
 
1064
format_registry.register('default', DiffTree)