/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: Canonical.com Patch Queue Manager
  • Date: 2011-08-20 22:42:34 UTC
  • mfrom: (6083.1.2 more-get-transport-from)
  • Revision ID: pqm@pqm.ubuntu.com-20110820224234-l0c0cmesdnfp2srq
(jelmer) Use get_transport_from_path and get_transport_from_url in more
 places. (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

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