← 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
114
    for line in ud:
67
115
        to_file.write(line)
68
 
    if nonl:
69
 
        print >>to_file, "\\ No newline at end of file"
70
 
    print >>to_file
71
 
 
72
 
 
73
 
 
74
 
 
75
 
def external_diff(old_label, oldlines, new_label, newlines, to_file,
 
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,
76
193
                  diff_opts):
77
194
    """Display a diff by calling out to the external diff program."""
78
 
    import sys
79
 
    
80
 
    if to_file != sys.stdout:
81
 
        raise NotImplementedError("sorry, can't send external diff other than to stdout yet",
82
 
                                  to_file)
83
 
 
84
195
    # make sure our own output is properly ordered before the diff
85
196
    to_file.flush()
86
197
 
87
 
    from tempfile import NamedTemporaryFile
88
 
    import os
89
 
 
90
 
    oldtmpf = NamedTemporaryFile()
91
 
    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')
92
202
 
93
203
    try:
94
204
        # TODO: perhaps a special case for comparing to or from the empty
101
211
        oldtmpf.writelines(oldlines)
102
212
        newtmpf.writelines(newlines)
103
213
 
104
 
        oldtmpf.flush()
105
 
        newtmpf.flush()
 
214
        oldtmpf.close()
 
215
        newtmpf.close()
106
216
 
107
217
        if not diff_opts:
108
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')
109
224
        diffcmd = ['diff',
110
 
                   '--label', old_label,
111
 
                   oldtmpf.name,
112
 
                   '--label', new_label,
113
 
                   newtmpf.name]
114
 
 
115
 
        # diff only allows one style to be specified; they don't override.
116
 
        # note that some of these take optargs, and the optargs can be
117
 
        # directly appended to the options.
118
 
        # this is only an approximate parser; it doesn't properly understand
119
 
        # the grammar.
120
 
        for s in ['-c', '-u', '-C', '-U',
121
 
                  '-e', '--ed',
122
 
                  '-q', '--brief',
123
 
                  '--normal',
124
 
                  '-n', '--rcs',
125
 
                  '-y', '--side-by-side',
126
 
                  '-D', '--ifdef']:
127
 
            for j in diff_opts:
128
 
                if j.startswith(s):
129
 
                    break
130
 
            else:
131
 
                continue
132
 
            break
133
 
        else:
134
 
            diffcmd.append('-u')
135
 
                  
 
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
 
136
234
        if diff_opts:
137
235
            diffcmd.extend(diff_opts)
138
236
 
139
 
        rc = os.spawnvp(os.P_WAIT, 'diff', diffcmd)
140
 
        
141
 
        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):
142
276
            # returns 1 if files differ; that's OK
143
277
            if rc < 0:
144
278
                msg = 'signal %d' % (-rc)
145
279
            else:
146
280
                msg = 'exit code %d' % rc
147
 
                
148
 
            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
 
149
286
    finally:
150
287
        oldtmpf.close()                 # and delete
151
288
        newtmpf.close()
152
 
    
153
 
 
154
 
 
155
 
def show_diff(b, revision, specific_files, external_diff_options=None):
156
 
    """Shortcut for showing the diff to the working tree.
157
 
 
158
 
    b
159
 
        Branch.
160
 
 
161
 
    revision
162
 
        None for each, or otherwise the old revision to compare against.
163
 
    
164
 
    The more general form is show_diff_trees(), where the caller
165
 
    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.
166
334
    """
167
 
    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()
168
347
 
169
 
    if revision == None:
170
 
        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
171
358
    else:
172
 
        old_tree = b.revision_tree(b.lookup_revision(revision))
173
 
        
174
 
    new_tree = b.working_tree()
175
 
 
176
 
    show_diff_trees(old_tree, new_tree, sys.stdout, specific_files,
177
 
                    external_diff_options)
178
 
 
 
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)
179
435
 
180
436
 
181
437
def show_diff_trees(old_tree, new_tree, to_file, specific_files=None,
182
 
                    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):
183
445
    """Show in text form the changes from one tree to another.
184
446
 
185
 
    to_files
186
 
        If set, include only changes to these files.
187
 
 
188
 
    external_diff_options
189
 
        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)
190
456
    """
191
 
 
192
 
    # TODO: Options to control putting on a prefix or suffix, perhaps as a format string
193
 
    old_label = ''
194
 
    new_label = ''
195
 
 
196
 
    DEVNULL = '/dev/null'
197
 
    # Windows users, don't panic about this filename -- it is a
198
 
    # special signal to GNU patch that the file should be created or
199
 
    # deleted respectively.
200
 
 
201
 
    # TODO: Generation of pseudo-diffs for added/deleted files could
202
 
    # be usefully made into a much faster special case.
203
 
 
204
 
    if external_diff_options:
205
 
        assert isinstance(external_diff_options, basestring)
206
 
        opts = external_diff_options.split()
207
 
        def diff_file(olab, olines, nlab, nlines, to_file):
208
 
            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],)]
209
496
    else:
210
 
        diff_file = internal_diff
211
 
    
212
 
 
213
 
    delta = compare_trees(old_tree, new_tree, want_unchanged=False,
214
 
                          specific_files=specific_files)
215
 
 
216
 
    for path, file_id, kind in delta.removed:
217
 
        print >>to_file, '*** removed %s %r' % (kind, path)
218
 
        if kind == 'file':
219
 
            diff_file(old_label + path,
220
 
                      old_tree.get_file(file_id).readlines(),
221
 
                      DEVNULL, 
222
 
                      [],
223
 
                      to_file)
224
 
 
225
 
    for path, file_id, kind in delta.added:
226
 
        print >>to_file, '*** added %s %r' % (kind, path)
227
 
        if kind == 'file':
228
 
            diff_file(DEVNULL,
229
 
                      [],
230
 
                      new_label + path,
231
 
                      new_tree.get_file(file_id).readlines(),
232
 
                      to_file)
233
 
 
234
 
    for old_path, new_path, file_id, kind, text_modified in delta.renamed:
235
 
        print >>to_file, '*** renamed %s %r => %r' % (kind, old_path, new_path)
236
 
        if text_modified:
237
 
            diff_file(old_label + old_path,
238
 
                      old_tree.get_file(file_id).readlines(),
239
 
                      new_label + new_path,
240
 
                      new_tree.get_file(file_id).readlines(),
241
 
                      to_file)
242
 
 
243
 
    for path, file_id, kind in delta.modified:
244
 
        print >>to_file, '*** modified %s %r' % (kind, path)
245
 
        if kind == 'file':
246
 
            diff_file(old_label + path,
247
 
                      old_tree.get_file(file_id).readlines(),
248
 
                      new_label + path,
249
 
                      new_tree.get_file(file_id).readlines(),
250
 
                      to_file)
251
 
 
252
 
 
253
 
 
254
 
class TreeDelta(object):
255
 
    """Describes changes from one tree to another.
256
 
 
257
 
    Contains four lists:
258
 
 
259
 
    added
260
 
        (path, id, kind)
261
 
    removed
262
 
        (path, id, kind)
263
 
    renamed
264
 
        (oldpath, newpath, id, kind, text_modified)
265
 
    modified
266
 
        (path, id, kind)
267
 
    unchanged
268
 
        (path, id, kind)
269
 
 
270
 
    Each id is listed only once.
271
 
 
272
 
    Files that are both modified and renamed are listed only in
273
 
    renamed, with the text_modified flag true.
274
 
 
275
 
    Files are only considered renamed if their name has changed or
276
 
    their parent directory has changed.  Renaming a directory
277
 
    does not count as renaming all its contents.
278
 
 
279
 
    The lists are normally sorted when the delta is created.
280
 
    """
281
 
    def __init__(self):
282
 
        self.added = []
283
 
        self.removed = []
284
 
        self.renamed = []
285
 
        self.modified = []
286
 
        self.unchanged = []
287
 
 
288
 
    def __eq__(self, other):
289
 
        if not isinstance(other, TreeDelta):
290
 
            return False
291
 
        return self.added == other.added \
292
 
               and self.removed == other.removed \
293
 
               and self.renamed == other.renamed \
294
 
               and self.modified == other.modified \
295
 
               and self.unchanged == other.unchanged
296
 
 
297
 
    def __ne__(self, other):
298
 
        return not (self == other)
299
 
 
300
 
    def __repr__(self):
301
 
        return "TreeDelta(added=%r, removed=%r, renamed=%r, modified=%r," \
302
 
            " unchanged=%r)" % (self.added, self.removed, self.renamed,
303
 
            self.modified, self.unchanged)
304
 
 
305
 
    def has_changed(self):
306
 
        changes = len(self.added) + len(self.removed) + len(self.renamed)
307
 
        changes += len(self.modified) 
308
 
        return (changes != 0)
309
 
 
310
 
    def touches_file_id(self, file_id):
311
 
        """Return True if file_id is modified by this delta."""
312
 
        for l in self.added, self.removed, self.modified:
313
 
            for v in l:
314
 
                if v[1] == file_id:
315
 
                    return True
316
 
        for v in self.renamed:
317
 
            if v[2] == file_id:
318
 
                return True
319
 
        return False
320
 
            
321
 
 
322
 
    def show(self, to_file, show_ids=False, show_unchanged=False):
323
 
        def show_list(files):
324
 
            for path, fid, kind in files:
325
 
                if kind == 'directory':
326
 
                    path += '/'
327
 
                elif kind == 'symlink':
328
 
                    path += '@'
329
 
                    
330
 
                if show_ids:
331
 
                    print >>to_file, '  %-30s %s' % (path, fid)
332
 
                else:
333
 
                    print >>to_file, ' ', path
334
 
            
335
 
        if self.removed:
336
 
            print >>to_file, 'removed:'
337
 
            show_list(self.removed)
338
 
                
339
 
        if self.added:
340
 
            print >>to_file, 'added:'
341
 
            show_list(self.added)
342
 
 
343
 
        if self.renamed:
344
 
            print >>to_file, 'renamed:'
345
 
            for oldpath, newpath, fid, kind, text_modified in self.renamed:
346
 
                if show_ids:
347
 
                    print >>to_file, '  %s => %s %s' % (oldpath, newpath, fid)
348
 
                else:
349
 
                    print >>to_file, '  %s => %s' % (oldpath, newpath)
350
 
                    
351
 
        if self.modified:
352
 
            print >>to_file, 'modified:'
353
 
            show_list(self.modified)
354
 
            
355
 
        if show_unchanged and self.unchanged:
356
 
            print >>to_file, 'unchanged:'
357
 
            show_list(self.unchanged)
358
 
 
359
 
 
360
 
 
361
 
def compare_trees(old_tree, new_tree, want_unchanged=False, specific_files=None):
362
 
    """Describe changes from one tree to another.
363
 
 
364
 
    Returns a TreeDelta with details of added, modified, renamed, and
365
 
    deleted entries.
366
 
 
367
 
    The root entry is specifically exempt.
368
 
 
369
 
    This only considers versioned files.
370
 
 
371
 
    want_unchanged
372
 
        If true, also list files unchanged from one version to
373
 
        the next.
374
 
 
375
 
    specific_files
376
 
        If true, only check for changes to specified names or
377
 
        files within them.
378
 
    """
379
 
 
380
 
    from osutils import is_inside_any
381
 
    
382
 
    old_inv = old_tree.inventory
383
 
    new_inv = new_tree.inventory
384
 
    delta = TreeDelta()
385
 
    mutter('start compare_trees')
386
 
 
387
 
    # TODO: match for specific files can be rather smarter by finding
388
 
    # the IDs of those files up front and then considering only that.
389
 
 
390
 
    for file_id in old_tree:
391
 
        if file_id in new_tree:
392
 
            kind = old_inv.get_file_kind(file_id)
393
 
            assert kind == new_inv.get_file_kind(file_id)
394
 
            
395
 
            assert kind in ('file', 'directory', 'symlink', 'root_directory'), \
396
 
                   'invalid file kind %r' % kind
397
 
 
398
 
            if kind == 'root_directory':
399
 
                continue
400
 
            
401
 
            old_path = old_inv.id2path(file_id)
402
 
            new_path = new_inv.id2path(file_id)
403
 
 
404
 
            old_ie = old_inv[file_id]
405
 
            new_ie = new_inv[file_id]
406
 
 
407
 
            if specific_files:
408
 
                if (not is_inside_any(specific_files, old_path) 
409
 
                    and not is_inside_any(specific_files, new_path)):
410
 
                    continue
411
 
 
412
 
            if kind == 'file':
413
 
                old_sha1 = old_tree.get_file_sha1(file_id)
414
 
                new_sha1 = new_tree.get_file_sha1(file_id)
415
 
                text_modified = (old_sha1 != new_sha1)
416
 
            else:
417
 
                ## mutter("no text to check for %r %r" % (file_id, kind))
418
 
                text_modified = False
419
 
 
420
 
            # TODO: Can possibly avoid calculating path strings if the
421
 
            # two files are unchanged and their names and parents are
422
 
            # the same and the parents are unchanged all the way up.
423
 
            # May not be worthwhile.
424
 
            
425
 
            if (old_ie.name != new_ie.name
426
 
                or old_ie.parent_id != new_ie.parent_id):
427
 
                delta.renamed.append((old_path, new_path, file_id, kind,
428
 
                                      text_modified))
429
 
            elif text_modified:
430
 
                delta.modified.append((new_path, file_id, kind))
431
 
            elif want_unchanged:
432
 
                delta.unchanged.append((new_path, file_id, kind))
433
 
        else:
434
 
            kind = old_inv.get_file_kind(file_id)
435
 
            old_path = old_inv.id2path(file_id)
436
 
            if specific_files:
437
 
                if not is_inside_any(specific_files, old_path):
438
 
                    continue
439
 
            delta.removed.append((old_path, file_id, kind))
440
 
 
441
 
    mutter('start looking for new files')
442
 
    for file_id in new_inv:
443
 
        if file_id in old_inv:
444
 
            continue
445
 
        new_path = new_inv.id2path(file_id)
446
 
        if specific_files:
447
 
            if not is_inside_any(specific_files, new_path):
448
 
                continue
449
 
        kind = new_inv.get_file_kind(file_id)
450
 
        delta.added.append((new_path, file_id, kind))
451
 
            
452
 
    delta.removed.sort()
453
 
    delta.added.sort()
454
 
    delta.renamed.sort()
455
 
    delta.modified.sort()
456
 
    delta.unchanged.sort()
457
 
 
458
 
    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)