← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/diff.py

  • Committer: Tarmac
  • Author(s): Vincent Ladeuil
  • Date: 2017-01-30 14:42:05 UTC
  • mfrom: (6620.1.1 trunk)
  • Revision ID: tarmac-20170130144205-r8fh2xpmiuxyozpv
Merge  2.7 into trunk including fix for bug #1657238 [r=vila]

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