/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/diff.py

Merge from bzr.dev, resolving conflicts.

Show diffs side-by-side

added added

removed removed

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