/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/diff.py

  • Committer: Alexander Belchenko
  • Date: 2007-03-11 19:39:37 UTC
  • mto: This revision was merged to the branch mainline in revision 2335.
  • Revision ID: bialix@ukr.net-20070311193937-nx38jief5kw8pp2f
external diff: no need for special code path for win32 (suggested by John Meinel)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/diff.py
1
 
#! /usr/bin/env python
2
 
# -*- coding: UTF-8 -*-
3
 
 
 
1
# Copyright (C) 2004, 2005, 2006 Canonical Ltd.
 
2
#
4
3
# This program is free software; you can redistribute it and/or modify
5
4
# it under the terms of the GNU General Public License as published by
6
5
# the Free Software Foundation; either version 2 of the License, or
7
6
# (at your option) any later version.
8
 
 
 
7
#
9
8
# This program is distributed in the hope that it will be useful,
10
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
11
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12
11
# GNU General Public License for more details.
13
 
 
 
12
#
14
13
# You should have received a copy of the GNU General Public License
15
14
# along with this program; if not, write to the Free Software
16
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
16
 
18
 
from bzrlib.trace import mutter
19
 
from bzrlib.errors import BzrError
 
17
import os
 
18
import re
 
19
import sys
 
20
 
 
21
from bzrlib.lazy_import import lazy_import
 
22
lazy_import(globals(), """
 
23
import errno
 
24
import subprocess
 
25
import tempfile
 
26
import time
 
27
 
 
28
from bzrlib import (
 
29
    errors,
 
30
    osutils,
 
31
    patiencediff,
 
32
    textfile,
 
33
    )
 
34
""")
 
35
 
 
36
# compatability - plugins import compare_trees from diff!!!
 
37
# deprecated as of 0.10
20
38
from bzrlib.delta import compare_trees
 
39
from bzrlib.symbol_versioning import (
 
40
        deprecated_function,
 
41
        zero_eight,
 
42
        )
 
43
from bzrlib.trace import mutter, warning
 
44
 
21
45
 
22
46
# TODO: Rather than building a changeset object, we should probably
23
47
# invoke callbacks on an object.  That object can either accumulate a
24
48
# list, write them out directly, etc etc.
25
49
 
26
 
def internal_diff(old_label, oldlines, new_label, newlines, to_file):
27
 
    import difflib
28
 
    
 
50
def internal_diff(old_filename, oldlines, new_filename, newlines, to_file,
 
51
                  allow_binary=False, sequence_matcher=None,
 
52
                  path_encoding='utf8'):
29
53
    # FIXME: difflib is wrong if there is no trailing newline.
30
54
    # The syntax used by patch seems to be "\ No newline at
31
55
    # end of file" following the last diff line from that
41
65
    # both sequences are empty.
42
66
    if not oldlines and not newlines:
43
67
        return
44
 
 
45
 
    ud = difflib.unified_diff(oldlines, newlines,
46
 
                              fromfile=old_label, tofile=new_label)
47
 
 
 
68
    
 
69
    if allow_binary is False:
 
70
        textfile.check_text_lines(oldlines)
 
71
        textfile.check_text_lines(newlines)
 
72
 
 
73
    if sequence_matcher is None:
 
74
        sequence_matcher = patiencediff.PatienceSequenceMatcher
 
75
    ud = patiencediff.unified_diff(oldlines, newlines,
 
76
                      fromfile=old_filename.encode(path_encoding),
 
77
                      tofile=new_filename.encode(path_encoding),
 
78
                      sequencematcher=sequence_matcher)
 
79
 
 
80
    ud = list(ud)
48
81
    # work-around for difflib being too smart for its own good
49
82
    # if /dev/null is "1,0", patch won't recognize it as /dev/null
50
83
    if not oldlines:
51
 
        ud = list(ud)
52
84
        ud[2] = ud[2].replace('-1,0', '-0,0')
53
85
    elif not newlines:
54
 
        ud = list(ud)
55
86
        ud[2] = ud[2].replace('+1,0', '+0,0')
 
87
    # work around for difflib emitting random spaces after the label
 
88
    ud[0] = ud[0][:-2] + '\n'
 
89
    ud[1] = ud[1][:-2] + '\n'
56
90
 
57
91
    for line in ud:
58
92
        to_file.write(line)
61
95
    print >>to_file
62
96
 
63
97
 
64
 
 
65
 
 
66
 
def external_diff(old_label, oldlines, new_label, newlines, to_file,
 
98
def _spawn_external_diff(diffcmd, capture_errors=True):
 
99
    """Spawn the externall diff process, and return the child handle.
 
100
 
 
101
    :param diffcmd: The command list to spawn
 
102
    :param capture_errors: Capture stderr as well as setting LANG=C
 
103
        and LC_ALL=C. This lets us read and understand the output of diff,
 
104
        and respond to any errors.
 
105
    :return: A Popen object.
 
106
    """
 
107
    if capture_errors:
 
108
        # construct minimal environment
 
109
        env = {}
 
110
        path = os.environ.get('PATH')
 
111
        if path is not None:
 
112
            env['PATH'] = path
 
113
        env['LANGUAGE'] = 'C'   # on win32 only LANGUAGE has effect
 
114
        env['LANG'] = 'C'
 
115
        env['LC_ALL'] = 'C'
 
116
        stderr = subprocess.PIPE
 
117
    else:
 
118
        env = None
 
119
        stderr = None
 
120
 
 
121
    try:
 
122
        pipe = subprocess.Popen(diffcmd,
 
123
                                stdin=subprocess.PIPE,
 
124
                                stdout=subprocess.PIPE,
 
125
                                stderr=stderr,
 
126
                                env=env)
 
127
    except OSError, e:
 
128
        if e.errno == errno.ENOENT:
 
129
            raise errors.NoDiff(str(e))
 
130
        raise
 
131
 
 
132
    return pipe
 
133
 
 
134
 
 
135
def external_diff(old_filename, oldlines, new_filename, newlines, to_file,
67
136
                  diff_opts):
68
137
    """Display a diff by calling out to the external diff program."""
69
 
    import sys
70
 
    
71
 
    if to_file != sys.stdout:
72
 
        raise NotImplementedError("sorry, can't send external diff other than to stdout yet",
73
 
                                  to_file)
74
 
 
75
138
    # make sure our own output is properly ordered before the diff
76
139
    to_file.flush()
77
140
 
78
 
    from tempfile import NamedTemporaryFile
79
 
    import os
80
 
 
81
 
    oldtmpf = NamedTemporaryFile()
82
 
    newtmpf = NamedTemporaryFile()
 
141
    oldtmp_fd, old_abspath = tempfile.mkstemp(prefix='bzr-diff-old-')
 
142
    newtmp_fd, new_abspath = tempfile.mkstemp(prefix='bzr-diff-new-')
 
143
    oldtmpf = os.fdopen(oldtmp_fd, 'wb')
 
144
    newtmpf = os.fdopen(newtmp_fd, 'wb')
83
145
 
84
146
    try:
85
147
        # TODO: perhaps a special case for comparing to or from the empty
92
154
        oldtmpf.writelines(oldlines)
93
155
        newtmpf.writelines(newlines)
94
156
 
95
 
        oldtmpf.flush()
96
 
        newtmpf.flush()
 
157
        oldtmpf.close()
 
158
        newtmpf.close()
97
159
 
98
160
        if not diff_opts:
99
161
            diff_opts = []
100
162
        diffcmd = ['diff',
101
 
                   '--label', old_label,
102
 
                   oldtmpf.name,
103
 
                   '--label', new_label,
104
 
                   newtmpf.name]
 
163
                   '--label', old_filename,
 
164
                   old_abspath,
 
165
                   '--label', new_filename,
 
166
                   new_abspath,
 
167
                   '--binary',
 
168
                  ]
105
169
 
106
170
        # diff only allows one style to be specified; they don't override.
107
171
        # note that some of these take optargs, and the optargs can be
127
191
        if diff_opts:
128
192
            diffcmd.extend(diff_opts)
129
193
 
130
 
        rc = os.spawnvp(os.P_WAIT, 'diff', diffcmd)
 
194
        pipe = _spawn_external_diff(diffcmd, capture_errors=True)
 
195
        out,err = pipe.communicate()
 
196
        rc = pipe.returncode
131
197
        
132
 
        if rc != 0 and rc != 1:
 
198
        # internal_diff() adds a trailing newline, add one here for consistency
 
199
        out += '\n'
 
200
        if rc == 2:
 
201
            # 'diff' gives retcode == 2 for all sorts of errors
 
202
            # one of those is 'Binary files differ'.
 
203
            # Bad options could also be the problem.
 
204
            # 'Binary files' is not a real error, so we suppress that error.
 
205
            lang_c_out = out
 
206
 
 
207
            # Since we got here, we want to make sure to give an i18n error
 
208
            pipe = _spawn_external_diff(diffcmd, capture_errors=False)
 
209
            out, err = pipe.communicate()
 
210
 
 
211
            # Write out the new i18n diff response
 
212
            to_file.write(out+'\n')
 
213
            if pipe.returncode != 2:
 
214
                raise errors.BzrError(
 
215
                               'external diff failed with exit code 2'
 
216
                               ' when run with LANG=C and LC_ALL=C,'
 
217
                               ' but not when run natively: %r' % (diffcmd,))
 
218
 
 
219
            first_line = lang_c_out.split('\n', 1)[0]
 
220
            # Starting with diffutils 2.8.4 the word "binary" was dropped.
 
221
            m = re.match('^(binary )?files.*differ$', first_line, re.I)
 
222
            if m is None:
 
223
                raise errors.BzrError('external diff failed with exit code 2;'
 
224
                                      ' command: %r' % (diffcmd,))
 
225
            else:
 
226
                # Binary files differ, just return
 
227
                return
 
228
 
 
229
        # If we got to here, we haven't written out the output of diff
 
230
        # do so now
 
231
        to_file.write(out)
 
232
        if rc not in (0, 1):
133
233
            # returns 1 if files differ; that's OK
134
234
            if rc < 0:
135
235
                msg = 'signal %d' % (-rc)
136
236
            else:
137
237
                msg = 'exit code %d' % rc
138
238
                
139
 
            raise BzrError('external diff failed with %s; command: %r' % (rc, diffcmd))
 
239
            raise errors.BzrError('external diff failed with %s; command: %r' 
 
240
                                  % (rc, diffcmd))
 
241
 
 
242
 
140
243
    finally:
141
244
        oldtmpf.close()                 # and delete
142
245
        newtmpf.close()
143
 
    
144
 
 
145
 
 
146
 
def show_diff(b, revision, specific_files, external_diff_options=None):
 
246
        # Clean up. Warn in case the files couldn't be deleted
 
247
        # (in case windows still holds the file open, but not
 
248
        # if the files have already been deleted)
 
249
        try:
 
250
            os.remove(old_abspath)
 
251
        except OSError, e:
 
252
            if e.errno not in (errno.ENOENT,):
 
253
                warning('Failed to delete temporary file: %s %s',
 
254
                        old_abspath, e)
 
255
        try:
 
256
            os.remove(new_abspath)
 
257
        except OSError:
 
258
            if e.errno not in (errno.ENOENT,):
 
259
                warning('Failed to delete temporary file: %s %s',
 
260
                        new_abspath, e)
 
261
 
 
262
 
 
263
@deprecated_function(zero_eight)
 
264
def show_diff(b, from_spec, specific_files, external_diff_options=None,
 
265
              revision2=None, output=None, b2=None):
147
266
    """Shortcut for showing the diff to the working tree.
148
267
 
 
268
    Please use show_diff_trees instead.
 
269
 
149
270
    b
150
271
        Branch.
151
272
 
152
273
    revision
153
 
        None for each, or otherwise the old revision to compare against.
154
 
    
155
 
    The more general form is show_diff_trees(), where the caller
156
 
    supplies any two trees.
157
 
    """
158
 
    import sys
159
 
 
160
 
    if revision == None:
161
 
        old_tree = b.basis_tree()
162
 
    else:
163
 
        old_tree = b.revision_tree(b.lookup_revision(revision))
164
 
        
165
 
    new_tree = b.working_tree()
166
 
 
167
 
    show_diff_trees(old_tree, new_tree, sys.stdout, specific_files,
168
 
                    external_diff_options)
169
 
 
 
274
        None for 'basis tree', or otherwise the old revision to compare against.
 
275
    
 
276
    The more general form is show_diff_trees(), where the caller
 
277
    supplies any two trees.
 
278
    """
 
279
    if output is None:
 
280
        output = sys.stdout
 
281
 
 
282
    if from_spec is None:
 
283
        old_tree = b.bzrdir.open_workingtree()
 
284
        if b2 is None:
 
285
            old_tree = old_tree = old_tree.basis_tree()
 
286
    else:
 
287
        old_tree = b.repository.revision_tree(from_spec.in_history(b).rev_id)
 
288
 
 
289
    if revision2 is None:
 
290
        if b2 is None:
 
291
            new_tree = b.bzrdir.open_workingtree()
 
292
        else:
 
293
            new_tree = b2.bzrdir.open_workingtree()
 
294
    else:
 
295
        new_tree = b.repository.revision_tree(revision2.in_history(b).rev_id)
 
296
 
 
297
    return show_diff_trees(old_tree, new_tree, output, specific_files,
 
298
                           external_diff_options)
 
299
 
 
300
 
 
301
def diff_cmd_helper(tree, specific_files, external_diff_options, 
 
302
                    old_revision_spec=None, new_revision_spec=None,
 
303
                    revision_specs=None,
 
304
                    old_label='a/', new_label='b/'):
 
305
    """Helper for cmd_diff.
 
306
 
 
307
    :param tree:
 
308
        A WorkingTree
 
309
 
 
310
    :param specific_files:
 
311
        The specific files to compare, or None
 
312
 
 
313
    :param external_diff_options:
 
314
        If non-None, run an external diff, and pass it these options
 
315
 
 
316
    :param old_revision_spec:
 
317
        If None, use basis tree as old revision, otherwise use the tree for
 
318
        the specified revision. 
 
319
 
 
320
    :param new_revision_spec:
 
321
        If None, use working tree as new revision, otherwise use the tree for
 
322
        the specified revision.
 
323
    
 
324
    :param revision_specs: 
 
325
        Zero, one or two RevisionSpecs from the command line, saying what revisions 
 
326
        to compare.  This can be passed as an alternative to the old_revision_spec 
 
327
        and new_revision_spec parameters.
 
328
 
 
329
    The more general form is show_diff_trees(), where the caller
 
330
    supplies any two trees.
 
331
    """
 
332
 
 
333
    # TODO: perhaps remove the old parameters old_revision_spec and
 
334
    # new_revision_spec, since this is only really for use from cmd_diff and
 
335
    # it now always passes through a sequence of revision_specs -- mbp
 
336
    # 20061221
 
337
 
 
338
    def spec_tree(spec):
 
339
        if tree:
 
340
            revision = spec.in_store(tree.branch)
 
341
        else:
 
342
            revision = spec.in_store(None)
 
343
        revision_id = revision.rev_id
 
344
        branch = revision.branch
 
345
        return branch.repository.revision_tree(revision_id)
 
346
 
 
347
    if revision_specs is not None:
 
348
        assert (old_revision_spec is None
 
349
                and new_revision_spec is None)
 
350
        if len(revision_specs) > 0:
 
351
            old_revision_spec = revision_specs[0]
 
352
        if len(revision_specs) > 1:
 
353
            new_revision_spec = revision_specs[1]
 
354
 
 
355
    if old_revision_spec is None:
 
356
        old_tree = tree.basis_tree()
 
357
    else:
 
358
        old_tree = spec_tree(old_revision_spec)
 
359
 
 
360
    if (new_revision_spec is None
 
361
        or new_revision_spec.spec is None):
 
362
        new_tree = tree
 
363
    else:
 
364
        new_tree = spec_tree(new_revision_spec)
 
365
 
 
366
    if new_tree is not tree:
 
367
        extra_trees = (tree,)
 
368
    else:
 
369
        extra_trees = None
 
370
 
 
371
    return show_diff_trees(old_tree, new_tree, sys.stdout, specific_files,
 
372
                           external_diff_options,
 
373
                           old_label=old_label, new_label=new_label,
 
374
                           extra_trees=extra_trees)
170
375
 
171
376
 
172
377
def show_diff_trees(old_tree, new_tree, to_file, specific_files=None,
173
 
                    external_diff_options=None):
 
378
                    external_diff_options=None,
 
379
                    old_label='a/', new_label='b/',
 
380
                    extra_trees=None):
174
381
    """Show in text form the changes from one tree to another.
175
382
 
176
383
    to_files
178
385
 
179
386
    external_diff_options
180
387
        If set, use an external GNU diff and pass these options.
 
388
 
 
389
    extra_trees
 
390
        If set, more Trees to use for looking up file ids
181
391
    """
182
 
 
183
 
    # TODO: Options to control putting on a prefix or suffix, perhaps as a format string
184
 
    old_label = ''
185
 
    new_label = ''
186
 
 
187
 
    DEVNULL = '/dev/null'
188
 
    # Windows users, don't panic about this filename -- it is a
189
 
    # special signal to GNU patch that the file should be created or
190
 
    # deleted respectively.
 
392
    old_tree.lock_read()
 
393
    try:
 
394
        new_tree.lock_read()
 
395
        try:
 
396
            return _show_diff_trees(old_tree, new_tree, to_file,
 
397
                                    specific_files, external_diff_options,
 
398
                                    old_label=old_label, new_label=new_label,
 
399
                                    extra_trees=extra_trees)
 
400
        finally:
 
401
            new_tree.unlock()
 
402
    finally:
 
403
        old_tree.unlock()
 
404
 
 
405
 
 
406
def _show_diff_trees(old_tree, new_tree, to_file,
 
407
                     specific_files, external_diff_options, 
 
408
                     old_label='a/', new_label='b/', extra_trees=None):
 
409
 
 
410
    # GNU Patch uses the epoch date to detect files that are being added
 
411
    # or removed in a diff.
 
412
    EPOCH_DATE = '1970-01-01 00:00:00 +0000'
191
413
 
192
414
    # TODO: Generation of pseudo-diffs for added/deleted files could
193
415
    # be usefully made into a much faster special case.
200
422
    else:
201
423
        diff_file = internal_diff
202
424
    
203
 
 
204
 
    delta = compare_trees(old_tree, new_tree, want_unchanged=False,
205
 
                          specific_files=specific_files)
206
 
 
 
425
    delta = new_tree.changes_from(old_tree,
 
426
        specific_files=specific_files,
 
427
        extra_trees=extra_trees, require_versioned=True)
 
428
 
 
429
    has_changes = 0
207
430
    for path, file_id, kind in delta.removed:
208
 
        print >>to_file, '*** removed %s %r' % (kind, path)
209
 
        if kind == 'file':
210
 
            diff_file(old_label + path,
211
 
                      old_tree.get_file(file_id).readlines(),
212
 
                      DEVNULL, 
213
 
                      [],
214
 
                      to_file)
215
 
 
 
431
        has_changes = 1
 
432
        print >>to_file, '=== removed %s %r' % (kind, path.encode('utf8'))
 
433
        old_name = '%s%s\t%s' % (old_label, path,
 
434
                                 _patch_header_date(old_tree, file_id, path))
 
435
        new_name = '%s%s\t%s' % (new_label, path, EPOCH_DATE)
 
436
        old_tree.inventory[file_id].diff(diff_file, old_name, old_tree,
 
437
                                         new_name, None, None, to_file)
216
438
    for path, file_id, kind in delta.added:
217
 
        print >>to_file, '*** added %s %r' % (kind, path)
218
 
        if kind == 'file':
219
 
            diff_file(DEVNULL,
220
 
                      [],
221
 
                      new_label + path,
222
 
                      new_tree.get_file(file_id).readlines(),
223
 
                      to_file)
224
 
 
225
 
    for old_path, new_path, file_id, kind, text_modified in delta.renamed:
226
 
        print >>to_file, '*** renamed %s %r => %r' % (kind, old_path, new_path)
 
439
        has_changes = 1
 
440
        print >>to_file, '=== added %s %r' % (kind, path.encode('utf8'))
 
441
        old_name = '%s%s\t%s' % (old_label, path, EPOCH_DATE)
 
442
        new_name = '%s%s\t%s' % (new_label, path,
 
443
                                 _patch_header_date(new_tree, file_id, path))
 
444
        new_tree.inventory[file_id].diff(diff_file, new_name, new_tree,
 
445
                                         old_name, None, None, to_file, 
 
446
                                         reverse=True)
 
447
    for (old_path, new_path, file_id, kind,
 
448
         text_modified, meta_modified) in delta.renamed:
 
449
        has_changes = 1
 
450
        prop_str = get_prop_change(meta_modified)
 
451
        print >>to_file, '=== renamed %s %r => %r%s' % (
 
452
                    kind, old_path.encode('utf8'),
 
453
                    new_path.encode('utf8'), prop_str)
 
454
        old_name = '%s%s\t%s' % (old_label, old_path,
 
455
                                 _patch_header_date(old_tree, file_id,
 
456
                                                    old_path))
 
457
        new_name = '%s%s\t%s' % (new_label, new_path,
 
458
                                 _patch_header_date(new_tree, file_id,
 
459
                                                    new_path))
 
460
        _maybe_diff_file_or_symlink(old_name, old_tree, file_id,
 
461
                                    new_name, new_tree,
 
462
                                    text_modified, kind, to_file, diff_file)
 
463
    for path, file_id, kind, text_modified, meta_modified in delta.modified:
 
464
        has_changes = 1
 
465
        prop_str = get_prop_change(meta_modified)
 
466
        print >>to_file, '=== modified %s %r%s' % (kind, path.encode('utf8'), prop_str)
 
467
        old_name = '%s%s\t%s' % (old_label, path,
 
468
                                 _patch_header_date(old_tree, file_id, path))
 
469
        new_name = '%s%s\t%s' % (new_label, path,
 
470
                                 _patch_header_date(new_tree, file_id, path))
227
471
        if text_modified:
228
 
            diff_file(old_label + old_path,
229
 
                      old_tree.get_file(file_id).readlines(),
230
 
                      new_label + new_path,
231
 
                      new_tree.get_file(file_id).readlines(),
232
 
                      to_file)
233
 
 
234
 
    for path, file_id, kind in delta.modified:
235
 
        print >>to_file, '*** modified %s %r' % (kind, path)
236
 
        if kind == 'file':
237
 
            diff_file(old_label + path,
238
 
                      old_tree.get_file(file_id).readlines(),
239
 
                      new_label + path,
240
 
                      new_tree.get_file(file_id).readlines(),
241
 
                      to_file)
242
 
 
243
 
 
244
 
 
245
 
 
246
 
 
 
472
            _maybe_diff_file_or_symlink(old_name, old_tree, file_id,
 
473
                                        new_name, new_tree,
 
474
                                        True, kind, to_file, diff_file)
 
475
 
 
476
    return has_changes
 
477
 
 
478
 
 
479
def _patch_header_date(tree, file_id, path):
 
480
    """Returns a timestamp suitable for use in a patch header."""
 
481
    tm = time.gmtime(tree.get_file_mtime(file_id, path))
 
482
    return time.strftime('%Y-%m-%d %H:%M:%S +0000', tm)
 
483
 
 
484
 
 
485
def _raise_if_nonexistent(paths, old_tree, new_tree):
 
486
    """Complain if paths are not in either inventory or tree.
 
487
 
 
488
    It's OK with the files exist in either tree's inventory, or 
 
489
    if they exist in the tree but are not versioned.
 
490
    
 
491
    This can be used by operations such as bzr status that can accept
 
492
    unknown or ignored files.
 
493
    """
 
494
    mutter("check paths: %r", paths)
 
495
    if not paths:
 
496
        return
 
497
    s = old_tree.filter_unversioned_files(paths)
 
498
    s = new_tree.filter_unversioned_files(s)
 
499
    s = [path for path in s if not new_tree.has_filename(path)]
 
500
    if s:
 
501
        raise errors.PathsDoNotExist(sorted(s))
 
502
 
 
503
 
 
504
def get_prop_change(meta_modified):
 
505
    if meta_modified:
 
506
        return " (properties changed)"
 
507
    else:
 
508
        return  ""
 
509
 
 
510
 
 
511
def _maybe_diff_file_or_symlink(old_path, old_tree, file_id,
 
512
                                new_path, new_tree, text_modified,
 
513
                                kind, to_file, diff_file):
 
514
    if text_modified:
 
515
        new_entry = new_tree.inventory[file_id]
 
516
        old_tree.inventory[file_id].diff(diff_file,
 
517
                                         old_path, old_tree,
 
518
                                         new_path, new_entry, 
 
519
                                         new_tree, to_file)