/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-13 02:12:11 UTC
  • mto: This revision was merged to the branch mainline in revision 2356.
  • Revision ID: bialix@ukr.net-20070313021211-su48tjggdkklec47
Cleanup patch after John's review

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
        if sys.platform == 'win32':
 
114
            # diffutils+gettext from http://gnuwin32.sf.net use only LANGUAGE
 
115
            env['LANGUAGE'] = 'C'
 
116
        else:
 
117
            env['LANG'] = 'C'
 
118
            env['LC_ALL'] = 'C'
 
119
        stderr = subprocess.PIPE
 
120
    else:
 
121
        env = None
 
122
        stderr = None
 
123
 
 
124
    try:
 
125
        pipe = subprocess.Popen(diffcmd,
 
126
                                stdin=subprocess.PIPE,
 
127
                                stdout=subprocess.PIPE,
 
128
                                stderr=stderr,
 
129
                                env=env)
 
130
    except OSError, e:
 
131
        if e.errno == errno.ENOENT:
 
132
            raise errors.NoDiff(str(e))
 
133
        raise
 
134
 
 
135
    return pipe
 
136
 
 
137
 
 
138
def external_diff(old_filename, oldlines, new_filename, newlines, to_file,
67
139
                  diff_opts):
68
140
    """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
141
    # make sure our own output is properly ordered before the diff
76
142
    to_file.flush()
77
143
 
78
 
    from tempfile import NamedTemporaryFile
79
 
    import os
80
 
 
81
 
    oldtmpf = NamedTemporaryFile()
82
 
    newtmpf = NamedTemporaryFile()
 
144
    oldtmp_fd, old_abspath = tempfile.mkstemp(prefix='bzr-diff-old-')
 
145
    newtmp_fd, new_abspath = tempfile.mkstemp(prefix='bzr-diff-new-')
 
146
    oldtmpf = os.fdopen(oldtmp_fd, 'wb')
 
147
    newtmpf = os.fdopen(newtmp_fd, 'wb')
83
148
 
84
149
    try:
85
150
        # TODO: perhaps a special case for comparing to or from the empty
92
157
        oldtmpf.writelines(oldlines)
93
158
        newtmpf.writelines(newlines)
94
159
 
95
 
        oldtmpf.flush()
96
 
        newtmpf.flush()
 
160
        oldtmpf.close()
 
161
        newtmpf.close()
97
162
 
98
163
        if not diff_opts:
99
164
            diff_opts = []
100
165
        diffcmd = ['diff',
101
 
                   '--label', old_label,
102
 
                   oldtmpf.name,
103
 
                   '--label', new_label,
104
 
                   newtmpf.name]
 
166
                   '--label', old_filename,
 
167
                   old_abspath,
 
168
                   '--label', new_filename,
 
169
                   new_abspath,
 
170
                   '--binary',
 
171
                  ]
105
172
 
106
173
        # diff only allows one style to be specified; they don't override.
107
174
        # note that some of these take optargs, and the optargs can be
127
194
        if diff_opts:
128
195
            diffcmd.extend(diff_opts)
129
196
 
130
 
        rc = os.spawnvp(os.P_WAIT, 'diff', diffcmd)
 
197
        pipe = _spawn_external_diff(diffcmd, capture_errors=True)
 
198
        out,err = pipe.communicate()
 
199
        rc = pipe.returncode
131
200
        
132
 
        if rc != 0 and rc != 1:
 
201
        # internal_diff() adds a trailing newline, add one here for consistency
 
202
        out += '\n'
 
203
        if rc == 2:
 
204
            # 'diff' gives retcode == 2 for all sorts of errors
 
205
            # one of those is 'Binary files differ'.
 
206
            # Bad options could also be the problem.
 
207
            # 'Binary files' is not a real error, so we suppress that error.
 
208
            lang_c_out = out
 
209
 
 
210
            # Since we got here, we want to make sure to give an i18n error
 
211
            pipe = _spawn_external_diff(diffcmd, capture_errors=False)
 
212
            out, err = pipe.communicate()
 
213
 
 
214
            # Write out the new i18n diff response
 
215
            to_file.write(out+'\n')
 
216
            if pipe.returncode != 2:
 
217
                raise errors.BzrError(
 
218
                               'external diff failed with exit code 2'
 
219
                               ' when run with LANG=C and LC_ALL=C,'
 
220
                               ' but not when run natively: %r' % (diffcmd,))
 
221
 
 
222
            first_line = lang_c_out.split('\n', 1)[0]
 
223
            # Starting with diffutils 2.8.4 the word "binary" was dropped.
 
224
            m = re.match('^(binary )?files.*differ$', first_line, re.I)
 
225
            if m is None:
 
226
                raise errors.BzrError('external diff failed with exit code 2;'
 
227
                                      ' command: %r' % (diffcmd,))
 
228
            else:
 
229
                # Binary files differ, just return
 
230
                return
 
231
 
 
232
        # If we got to here, we haven't written out the output of diff
 
233
        # do so now
 
234
        to_file.write(out)
 
235
        if rc not in (0, 1):
133
236
            # returns 1 if files differ; that's OK
134
237
            if rc < 0:
135
238
                msg = 'signal %d' % (-rc)
136
239
            else:
137
240
                msg = 'exit code %d' % rc
138
241
                
139
 
            raise BzrError('external diff failed with %s; command: %r' % (rc, diffcmd))
 
242
            raise errors.BzrError('external diff failed with %s; command: %r' 
 
243
                                  % (rc, diffcmd))
 
244
 
 
245
 
140
246
    finally:
141
247
        oldtmpf.close()                 # and delete
142
248
        newtmpf.close()
143
 
    
144
 
 
145
 
 
146
 
def show_diff(b, revision, specific_files, external_diff_options=None):
 
249
        # Clean up. Warn in case the files couldn't be deleted
 
250
        # (in case windows still holds the file open, but not
 
251
        # if the files have already been deleted)
 
252
        try:
 
253
            os.remove(old_abspath)
 
254
        except OSError, e:
 
255
            if e.errno not in (errno.ENOENT,):
 
256
                warning('Failed to delete temporary file: %s %s',
 
257
                        old_abspath, e)
 
258
        try:
 
259
            os.remove(new_abspath)
 
260
        except OSError:
 
261
            if e.errno not in (errno.ENOENT,):
 
262
                warning('Failed to delete temporary file: %s %s',
 
263
                        new_abspath, e)
 
264
 
 
265
 
 
266
@deprecated_function(zero_eight)
 
267
def show_diff(b, from_spec, specific_files, external_diff_options=None,
 
268
              revision2=None, output=None, b2=None):
147
269
    """Shortcut for showing the diff to the working tree.
148
270
 
 
271
    Please use show_diff_trees instead.
 
272
 
149
273
    b
150
274
        Branch.
151
275
 
152
276
    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
 
 
 
277
        None for 'basis tree', or otherwise the old revision to compare against.
 
278
    
 
279
    The more general form is show_diff_trees(), where the caller
 
280
    supplies any two trees.
 
281
    """
 
282
    if output is None:
 
283
        output = sys.stdout
 
284
 
 
285
    if from_spec is None:
 
286
        old_tree = b.bzrdir.open_workingtree()
 
287
        if b2 is None:
 
288
            old_tree = old_tree = old_tree.basis_tree()
 
289
    else:
 
290
        old_tree = b.repository.revision_tree(from_spec.in_history(b).rev_id)
 
291
 
 
292
    if revision2 is None:
 
293
        if b2 is None:
 
294
            new_tree = b.bzrdir.open_workingtree()
 
295
        else:
 
296
            new_tree = b2.bzrdir.open_workingtree()
 
297
    else:
 
298
        new_tree = b.repository.revision_tree(revision2.in_history(b).rev_id)
 
299
 
 
300
    return show_diff_trees(old_tree, new_tree, output, specific_files,
 
301
                           external_diff_options)
 
302
 
 
303
 
 
304
def diff_cmd_helper(tree, specific_files, external_diff_options, 
 
305
                    old_revision_spec=None, new_revision_spec=None,
 
306
                    revision_specs=None,
 
307
                    old_label='a/', new_label='b/'):
 
308
    """Helper for cmd_diff.
 
309
 
 
310
    :param tree:
 
311
        A WorkingTree
 
312
 
 
313
    :param specific_files:
 
314
        The specific files to compare, or None
 
315
 
 
316
    :param external_diff_options:
 
317
        If non-None, run an external diff, and pass it these options
 
318
 
 
319
    :param old_revision_spec:
 
320
        If None, use basis tree as old revision, otherwise use the tree for
 
321
        the specified revision. 
 
322
 
 
323
    :param new_revision_spec:
 
324
        If None, use working tree as new revision, otherwise use the tree for
 
325
        the specified revision.
 
326
    
 
327
    :param revision_specs: 
 
328
        Zero, one or two RevisionSpecs from the command line, saying what revisions 
 
329
        to compare.  This can be passed as an alternative to the old_revision_spec 
 
330
        and new_revision_spec parameters.
 
331
 
 
332
    The more general form is show_diff_trees(), where the caller
 
333
    supplies any two trees.
 
334
    """
 
335
 
 
336
    # TODO: perhaps remove the old parameters old_revision_spec and
 
337
    # new_revision_spec, since this is only really for use from cmd_diff and
 
338
    # it now always passes through a sequence of revision_specs -- mbp
 
339
    # 20061221
 
340
 
 
341
    def spec_tree(spec):
 
342
        if tree:
 
343
            revision = spec.in_store(tree.branch)
 
344
        else:
 
345
            revision = spec.in_store(None)
 
346
        revision_id = revision.rev_id
 
347
        branch = revision.branch
 
348
        return branch.repository.revision_tree(revision_id)
 
349
 
 
350
    if revision_specs is not None:
 
351
        assert (old_revision_spec is None
 
352
                and new_revision_spec is None)
 
353
        if len(revision_specs) > 0:
 
354
            old_revision_spec = revision_specs[0]
 
355
        if len(revision_specs) > 1:
 
356
            new_revision_spec = revision_specs[1]
 
357
 
 
358
    if old_revision_spec is None:
 
359
        old_tree = tree.basis_tree()
 
360
    else:
 
361
        old_tree = spec_tree(old_revision_spec)
 
362
 
 
363
    if (new_revision_spec is None
 
364
        or new_revision_spec.spec is None):
 
365
        new_tree = tree
 
366
    else:
 
367
        new_tree = spec_tree(new_revision_spec)
 
368
 
 
369
    if new_tree is not tree:
 
370
        extra_trees = (tree,)
 
371
    else:
 
372
        extra_trees = None
 
373
 
 
374
    return show_diff_trees(old_tree, new_tree, sys.stdout, specific_files,
 
375
                           external_diff_options,
 
376
                           old_label=old_label, new_label=new_label,
 
377
                           extra_trees=extra_trees)
170
378
 
171
379
 
172
380
def show_diff_trees(old_tree, new_tree, to_file, specific_files=None,
173
 
                    external_diff_options=None):
 
381
                    external_diff_options=None,
 
382
                    old_label='a/', new_label='b/',
 
383
                    extra_trees=None):
174
384
    """Show in text form the changes from one tree to another.
175
385
 
176
386
    to_files
178
388
 
179
389
    external_diff_options
180
390
        If set, use an external GNU diff and pass these options.
 
391
 
 
392
    extra_trees
 
393
        If set, more Trees to use for looking up file ids
181
394
    """
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.
 
395
    old_tree.lock_read()
 
396
    try:
 
397
        if extra_trees is not None:
 
398
            for tree in extra_trees:
 
399
                tree.lock_read()
 
400
        new_tree.lock_read()
 
401
        try:
 
402
            return _show_diff_trees(old_tree, new_tree, to_file,
 
403
                                    specific_files, external_diff_options,
 
404
                                    old_label=old_label, new_label=new_label,
 
405
                                    extra_trees=extra_trees)
 
406
        finally:
 
407
            new_tree.unlock()
 
408
            if extra_trees is not None:
 
409
                for tree in extra_trees:
 
410
                    tree.unlock()
 
411
    finally:
 
412
        old_tree.unlock()
 
413
 
 
414
 
 
415
def _show_diff_trees(old_tree, new_tree, to_file,
 
416
                     specific_files, external_diff_options, 
 
417
                     old_label='a/', new_label='b/', extra_trees=None):
 
418
 
 
419
    # GNU Patch uses the epoch date to detect files that are being added
 
420
    # or removed in a diff.
 
421
    EPOCH_DATE = '1970-01-01 00:00:00 +0000'
191
422
 
192
423
    # TODO: Generation of pseudo-diffs for added/deleted files could
193
424
    # be usefully made into a much faster special case.
200
431
    else:
201
432
        diff_file = internal_diff
202
433
    
203
 
 
204
 
    delta = compare_trees(old_tree, new_tree, want_unchanged=False,
205
 
                          specific_files=specific_files)
206
 
 
 
434
    delta = new_tree.changes_from(old_tree,
 
435
        specific_files=specific_files,
 
436
        extra_trees=extra_trees, require_versioned=True)
 
437
 
 
438
    has_changes = 0
207
439
    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
 
 
 
440
        has_changes = 1
 
441
        print >>to_file, '=== removed %s %r' % (kind, path.encode('utf8'))
 
442
        old_name = '%s%s\t%s' % (old_label, path,
 
443
                                 _patch_header_date(old_tree, file_id, path))
 
444
        new_name = '%s%s\t%s' % (new_label, path, EPOCH_DATE)
 
445
        old_tree.inventory[file_id].diff(diff_file, old_name, old_tree,
 
446
                                         new_name, None, None, to_file)
216
447
    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)
 
448
        has_changes = 1
 
449
        print >>to_file, '=== added %s %r' % (kind, path.encode('utf8'))
 
450
        old_name = '%s%s\t%s' % (old_label, path, EPOCH_DATE)
 
451
        new_name = '%s%s\t%s' % (new_label, path,
 
452
                                 _patch_header_date(new_tree, file_id, path))
 
453
        new_tree.inventory[file_id].diff(diff_file, new_name, new_tree,
 
454
                                         old_name, None, None, to_file, 
 
455
                                         reverse=True)
 
456
    for (old_path, new_path, file_id, kind,
 
457
         text_modified, meta_modified) in delta.renamed:
 
458
        has_changes = 1
 
459
        prop_str = get_prop_change(meta_modified)
 
460
        print >>to_file, '=== renamed %s %r => %r%s' % (
 
461
                    kind, old_path.encode('utf8'),
 
462
                    new_path.encode('utf8'), prop_str)
 
463
        old_name = '%s%s\t%s' % (old_label, old_path,
 
464
                                 _patch_header_date(old_tree, file_id,
 
465
                                                    old_path))
 
466
        new_name = '%s%s\t%s' % (new_label, new_path,
 
467
                                 _patch_header_date(new_tree, file_id,
 
468
                                                    new_path))
 
469
        _maybe_diff_file_or_symlink(old_name, old_tree, file_id,
 
470
                                    new_name, new_tree,
 
471
                                    text_modified, kind, to_file, diff_file)
 
472
    for path, file_id, kind, text_modified, meta_modified in delta.modified:
 
473
        has_changes = 1
 
474
        prop_str = get_prop_change(meta_modified)
 
475
        print >>to_file, '=== modified %s %r%s' % (kind, path.encode('utf8'), prop_str)
 
476
        old_name = '%s%s\t%s' % (old_label, path,
 
477
                                 _patch_header_date(old_tree, file_id, path))
 
478
        new_name = '%s%s\t%s' % (new_label, path,
 
479
                                 _patch_header_date(new_tree, file_id, path))
227
480
        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
 
 
 
481
            _maybe_diff_file_or_symlink(old_name, old_tree, file_id,
 
482
                                        new_name, new_tree,
 
483
                                        True, kind, to_file, diff_file)
 
484
 
 
485
    return has_changes
 
486
 
 
487
 
 
488
def _patch_header_date(tree, file_id, path):
 
489
    """Returns a timestamp suitable for use in a patch header."""
 
490
    tm = time.gmtime(tree.get_file_mtime(file_id, path))
 
491
    return time.strftime('%Y-%m-%d %H:%M:%S +0000', tm)
 
492
 
 
493
 
 
494
def _raise_if_nonexistent(paths, old_tree, new_tree):
 
495
    """Complain if paths are not in either inventory or tree.
 
496
 
 
497
    It's OK with the files exist in either tree's inventory, or 
 
498
    if they exist in the tree but are not versioned.
 
499
    
 
500
    This can be used by operations such as bzr status that can accept
 
501
    unknown or ignored files.
 
502
    """
 
503
    mutter("check paths: %r", paths)
 
504
    if not paths:
 
505
        return
 
506
    s = old_tree.filter_unversioned_files(paths)
 
507
    s = new_tree.filter_unversioned_files(s)
 
508
    s = [path for path in s if not new_tree.has_filename(path)]
 
509
    if s:
 
510
        raise errors.PathsDoNotExist(sorted(s))
 
511
 
 
512
 
 
513
def get_prop_change(meta_modified):
 
514
    if meta_modified:
 
515
        return " (properties changed)"
 
516
    else:
 
517
        return  ""
 
518
 
 
519
 
 
520
def _maybe_diff_file_or_symlink(old_path, old_tree, file_id,
 
521
                                new_path, new_tree, text_modified,
 
522
                                kind, to_file, diff_file):
 
523
    if text_modified:
 
524
        new_entry = new_tree.inventory[file_id]
 
525
        old_tree.inventory[file_id].diff(diff_file,
 
526
                                         old_path, old_tree,
 
527
                                         new_path, new_entry, 
 
528
                                         new_tree, to_file)