/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 breezy/diff.py

  • Committer: Jelmer Vernooij
  • Date: 2019-02-04 01:01:24 UTC
  • mto: This revision was merged to the branch mainline in revision 7268.
  • Revision ID: jelmer@jelmer.uk-20190204010124-ni0i4qc6f5tnbvux
Fix source tests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/diff.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd.
 
1
# Copyright (C) 2005-2014 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
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
 
17
from __future__ import absolute_import
 
18
 
17
19
import difflib
18
20
import os
19
21
import re
20
22
import string
21
23
import sys
22
24
 
23
 
from bzrlib.lazy_import import lazy_import
 
25
from .lazy_import import lazy_import
24
26
lazy_import(globals(), """
25
27
import errno
26
28
import subprocess
27
29
import tempfile
28
 
import time
29
30
 
30
 
from bzrlib import (
31
 
    branch as _mod_branch,
32
 
    bzrdir,
 
31
from breezy import (
33
32
    cmdline,
34
 
    cleanup,
 
33
    controldir,
35
34
    errors,
36
35
    osutils,
37
36
    patiencediff,
40
39
    views,
41
40
    )
42
41
 
43
 
from bzrlib.workingtree import WorkingTree
 
42
from breezy.workingtree import WorkingTree
 
43
from breezy.i18n import gettext
44
44
""")
45
45
 
46
 
from bzrlib.registry import (
 
46
from .registry import (
47
47
    Registry,
48
48
    )
49
 
from bzrlib.symbol_versioning import (
50
 
    deprecated_function,
51
 
    deprecated_in,
52
 
    )
53
 
from bzrlib.trace import mutter, note, warning
 
49
from .sixish import text_type
 
50
from .trace import mutter, note, warning
 
51
from .tree import FileTimestampUnavailable
 
52
 
 
53
 
 
54
DEFAULT_CONTEXT_AMOUNT = 3
54
55
 
55
56
 
56
57
class AtTemplate(string.Template):
73
74
        self.opcodes = None
74
75
 
75
76
 
76
 
def internal_diff(old_filename, oldlines, new_filename, newlines, to_file,
 
77
def internal_diff(old_label, oldlines, new_label, newlines, to_file,
77
78
                  allow_binary=False, sequence_matcher=None,
78
 
                  path_encoding='utf8'):
 
79
                  path_encoding='utf8', context_lines=DEFAULT_CONTEXT_AMOUNT):
79
80
    # FIXME: difflib is wrong if there is no trailing newline.
80
81
    # The syntax used by patch seems to be "\ No newline at
81
82
    # end of file" following the last diff line from that
86
87
    # In the meantime we at least make sure the patch isn't
87
88
    # mangled.
88
89
 
89
 
 
90
 
    # Special workaround for Python2.3, where difflib fails if
91
 
    # both sequences are empty.
92
 
    if not oldlines and not newlines:
93
 
        return
94
 
 
95
90
    if allow_binary is False:
96
91
        textfile.check_text_lines(oldlines)
97
92
        textfile.check_text_lines(newlines)
98
93
 
99
94
    if sequence_matcher is None:
100
95
        sequence_matcher = patiencediff.PatienceSequenceMatcher
101
 
    ud = patiencediff.unified_diff(oldlines, newlines,
102
 
                      fromfile=old_filename.encode(path_encoding),
103
 
                      tofile=new_filename.encode(path_encoding),
104
 
                      sequencematcher=sequence_matcher)
 
96
    ud = patiencediff.unified_diff_bytes(oldlines, newlines,
 
97
                                         fromfile=old_label.encode(
 
98
                                             path_encoding, 'replace'),
 
99
                                         tofile=new_label.encode(
 
100
                                             path_encoding, 'replace'),
 
101
                                         n=context_lines, sequencematcher=sequence_matcher)
105
102
 
106
103
    ud = list(ud)
107
 
    if len(ud) == 0: # Identical contents, nothing to do
 
104
    if len(ud) == 0:  # Identical contents, nothing to do
108
105
        return
109
106
    # work-around for difflib being too smart for its own good
110
107
    # if /dev/null is "1,0", patch won't recognize it as /dev/null
111
108
    if not oldlines:
112
 
        ud[2] = ud[2].replace('-1,0', '-0,0')
 
109
        ud[2] = ud[2].replace(b'-1,0', b'-0,0')
113
110
    elif not newlines:
114
 
        ud[2] = ud[2].replace('+1,0', '+0,0')
 
111
        ud[2] = ud[2].replace(b'+1,0', b'+0,0')
115
112
 
116
113
    for line in ud:
117
114
        to_file.write(line)
118
 
        if not line.endswith('\n'):
119
 
            to_file.write("\n\\ No newline at end of file\n")
120
 
    to_file.write('\n')
 
115
        if not line.endswith(b'\n'):
 
116
            to_file.write(b"\n\\ No newline at end of file\n")
 
117
    to_file.write(b'\n')
121
118
 
122
119
 
123
120
def _spawn_external_diff(diffcmd, capture_errors=True):
124
 
    """Spawn the externall diff process, and return the child handle.
 
121
    """Spawn the external diff process, and return the child handle.
125
122
 
126
123
    :param diffcmd: The command list to spawn
127
124
    :param capture_errors: Capture stderr as well as setting LANG=C
149
146
                                stdout=subprocess.PIPE,
150
147
                                stderr=stderr,
151
148
                                env=env)
152
 
    except OSError, e:
 
149
    except OSError as e:
153
150
        if e.errno == errno.ENOENT:
154
151
            raise errors.NoDiff(str(e))
155
152
        raise
157
154
    return pipe
158
155
 
159
156
 
160
 
def external_diff(old_filename, oldlines, new_filename, newlines, to_file,
 
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
 
 
169
def default_style_unified(diff_opts):
 
170
    """Default to unified diff style if alternative not specified in diff_opts.
 
171
 
 
172
        diff only allows one style to be specified; they don't override.
 
173
        Note that some of these take optargs, and the optargs can be
 
174
        directly appended to the options.
 
175
        This is only an approximate parser; it doesn't properly understand
 
176
        the grammar.
 
177
 
 
178
    :param diff_opts: List of options for external (GNU) diff.
 
179
    :return: List of options with default style=='unified'.
 
180
    """
 
181
    for s in style_option_list:
 
182
        for j in diff_opts:
 
183
            if j.startswith(s):
 
184
                break
 
185
        else:
 
186
            continue
 
187
        break
 
188
    else:
 
189
        diff_opts.append('-u')
 
190
    return diff_opts
 
191
 
 
192
 
 
193
def external_diff(old_label, oldlines, new_label, newlines, to_file,
161
194
                  diff_opts):
162
195
    """Display a diff by calling out to the external diff program."""
163
196
    # make sure our own output is properly ordered before the diff
164
197
    to_file.flush()
165
198
 
166
 
    oldtmp_fd, old_abspath = tempfile.mkstemp(prefix='bzr-diff-old-')
167
 
    newtmp_fd, new_abspath = tempfile.mkstemp(prefix='bzr-diff-new-')
 
199
    oldtmp_fd, old_abspath = tempfile.mkstemp(prefix='brz-diff-old-')
 
200
    newtmp_fd, new_abspath = tempfile.mkstemp(prefix='brz-diff-new-')
168
201
    oldtmpf = os.fdopen(oldtmp_fd, 'wb')
169
202
    newtmpf = os.fdopen(newtmp_fd, 'wb')
170
203
 
187
220
        if sys.platform == 'win32':
188
221
            # Popen doesn't do the proper encoding for external commands
189
222
            # Since we are dealing with an ANSI api, use mbcs encoding
190
 
            old_filename = old_filename.encode('mbcs')
191
 
            new_filename = new_filename.encode('mbcs')
 
223
            old_label = old_label.encode('mbcs')
 
224
            new_label = new_label.encode('mbcs')
192
225
        diffcmd = ['diff',
193
 
                   '--label', old_filename,
 
226
                   '--label', old_label,
194
227
                   old_abspath,
195
 
                   '--label', new_filename,
 
228
                   '--label', new_label,
196
229
                   new_abspath,
197
230
                   '--binary',
198
 
                  ]
 
231
                   ]
199
232
 
200
 
        # diff only allows one style to be specified; they don't override.
201
 
        # note that some of these take optargs, and the optargs can be
202
 
        # directly appended to the options.
203
 
        # this is only an approximate parser; it doesn't properly understand
204
 
        # the grammar.
205
 
        for s in ['-c', '-u', '-C', '-U',
206
 
                  '-e', '--ed',
207
 
                  '-q', '--brief',
208
 
                  '--normal',
209
 
                  '-n', '--rcs',
210
 
                  '-y', '--side-by-side',
211
 
                  '-D', '--ifdef']:
212
 
            for j in diff_opts:
213
 
                if j.startswith(s):
214
 
                    break
215
 
            else:
216
 
                continue
217
 
            break
218
 
        else:
219
 
            diffcmd.append('-u')
 
233
        diff_opts = default_style_unified(diff_opts)
220
234
 
221
235
        if diff_opts:
222
236
            diffcmd.extend(diff_opts)
223
237
 
224
238
        pipe = _spawn_external_diff(diffcmd, capture_errors=True)
225
 
        out,err = pipe.communicate()
 
239
        out, err = pipe.communicate()
226
240
        rc = pipe.returncode
227
241
 
228
242
        # internal_diff() adds a trailing newline, add one here for consistency
229
 
        out += '\n'
 
243
        out += b'\n'
230
244
        if rc == 2:
231
245
            # 'diff' gives retcode == 2 for all sorts of errors
232
246
            # one of those is 'Binary files differ'.
239
253
            out, err = pipe.communicate()
240
254
 
241
255
            # Write out the new i18n diff response
242
 
            to_file.write(out+'\n')
 
256
            to_file.write(out + b'\n')
243
257
            if pipe.returncode != 2:
244
258
                raise errors.BzrError(
245
 
                               'external diff failed with exit code 2'
246
 
                               ' when run with LANG=C and LC_ALL=C,'
247
 
                               ' but not when run natively: %r' % (diffcmd,))
 
259
                    'external diff failed with exit code 2'
 
260
                    ' when run with LANG=C and LC_ALL=C,'
 
261
                    ' but not when run natively: %r' % (diffcmd,))
248
262
 
249
 
            first_line = lang_c_out.split('\n', 1)[0]
 
263
            first_line = lang_c_out.split(b'\n', 1)[0]
250
264
            # Starting with diffutils 2.8.4 the word "binary" was dropped.
251
 
            m = re.match('^(binary )?files.*differ$', first_line, re.I)
 
265
            m = re.match(b'^(binary )?files.*differ$', first_line, re.I)
252
266
            if m is None:
253
267
                raise errors.BzrError('external diff failed with exit code 2;'
254
268
                                      ' command: %r' % (diffcmd,))
267
281
                msg = 'exit code %d' % rc
268
282
 
269
283
            raise errors.BzrError('external diff failed with %s; command: %r'
270
 
                                  % (rc, diffcmd))
271
 
 
 
284
                                  % (msg, diffcmd))
272
285
 
273
286
    finally:
274
287
        oldtmpf.close()                 # and delete
275
288
        newtmpf.close()
276
 
        # Clean up. Warn in case the files couldn't be deleted
277
 
        # (in case windows still holds the file open, but not
278
 
        # if the files have already been deleted)
279
 
        try:
280
 
            os.remove(old_abspath)
281
 
        except OSError, e:
282
 
            if e.errno not in (errno.ENOENT,):
283
 
                warning('Failed to delete temporary file: %s %s',
284
 
                        old_abspath, e)
285
 
        try:
286
 
            os.remove(new_abspath)
287
 
        except OSError:
288
 
            if e.errno not in (errno.ENOENT,):
289
 
                warning('Failed to delete temporary file: %s %s',
290
 
                        new_abspath, e)
291
 
 
292
 
 
293
 
@deprecated_function(deprecated_in((2, 2, 0)))
294
 
def get_trees_and_branches_to_diff(path_list, revision_specs, old_url, new_url,
295
 
                                   apply_view=True):
296
 
    """Get the trees and specific files to diff given a list of paths.
297
 
 
298
 
    This method works out the trees to be diff'ed and the files of
299
 
    interest within those trees.
300
 
 
301
 
    :param path_list:
302
 
        the list of arguments passed to the diff command
303
 
    :param revision_specs:
304
 
        Zero, one or two RevisionSpecs from the diff command line,
305
 
        saying what revisions to compare.
306
 
    :param old_url:
307
 
        The url of the old branch or tree. If None, the tree to use is
308
 
        taken from the first path, if any, or the current working tree.
309
 
    :param new_url:
310
 
        The url of the new branch or tree. If None, the tree to use is
311
 
        taken from the first path, if any, or the current working tree.
312
 
    :param apply_view:
313
 
        if True and a view is set, apply the view or check that the paths
314
 
        are within it
315
 
    :returns:
316
 
        a tuple of (old_tree, new_tree, old_branch, new_branch,
317
 
        specific_files, extra_trees) where extra_trees is a sequence of
318
 
        additional trees to search in for file-ids.  The trees and branches
319
 
        are not locked.
320
 
    """
321
 
    op = cleanup.OperationWithCleanups(get_trees_and_branches_to_diff_locked)
322
 
    return op.run_simple(path_list, revision_specs, old_url, new_url,
323
 
            op.add_cleanup, apply_view=apply_view)
324
 
    
 
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 as 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
 
325
303
 
326
304
def get_trees_and_branches_to_diff_locked(
327
 
    path_list, revision_specs, old_url, new_url, add_cleanup, apply_view=True):
 
305
        path_list, revision_specs, old_url, new_url, add_cleanup, apply_view=True):
328
306
    """Get the trees and specific files to diff given a list of paths.
329
307
 
330
308
    This method works out the trees to be diff'ed and the files of
394
372
    if old_url is None:
395
373
        old_url = default_location
396
374
    working_tree, branch, relpath = \
397
 
        bzrdir.BzrDir.open_containing_tree_or_branch(old_url)
 
375
        controldir.ControlDir.open_containing_tree_or_branch(old_url)
398
376
    lock_tree_or_branch(working_tree, branch)
399
377
    if consider_relpath and relpath != '':
400
378
        if working_tree is not None and apply_view:
408
386
        new_url = default_location
409
387
    if new_url != old_url:
410
388
        working_tree, branch, relpath = \
411
 
            bzrdir.BzrDir.open_containing_tree_or_branch(new_url)
 
389
            controldir.ControlDir.open_containing_tree_or_branch(new_url)
412
390
        lock_tree_or_branch(working_tree, branch)
413
391
        if consider_relpath and relpath != '':
414
392
            if working_tree is not None and apply_view:
415
393
                views.check_path_in_view(working_tree, relpath)
416
394
            specific_files.append(relpath)
417
395
    new_tree = _get_tree_to_diff(new_revision_spec, working_tree, branch,
418
 
        basis_is_default=working_tree is None)
 
396
                                 basis_is_default=working_tree is None)
419
397
    new_branch = branch
420
398
 
421
399
    # Get the specific files (all files is None, no files is [])
422
400
    if make_paths_wt_relative and working_tree is not None:
423
 
        try:
424
 
            from bzrlib.builtins import safe_relpath_files
425
 
            other_paths = safe_relpath_files(working_tree, other_paths,
 
401
        other_paths = working_tree.safe_relpath_files(
 
402
            other_paths,
426
403
            apply_view=apply_view)
427
 
        except errors.FileInWrongBranch:
428
 
            raise errors.BzrCommandError("Files are in different branches")
429
404
    specific_files.extend(other_paths)
430
405
    if len(specific_files) == 0:
431
406
        specific_files = None
432
 
        if (working_tree is not None and working_tree.supports_views()
433
 
            and apply_view):
 
407
        if (working_tree is not None and working_tree.supports_views() and
 
408
                apply_view):
434
409
            view_files = working_tree.views.lookup_view()
435
410
            if view_files:
436
411
                specific_files = view_files
437
412
                view_str = views.view_display_str(view_files)
438
 
                note("*** Ignoring files outside view. View is %s" % view_str)
 
413
                note(gettext("*** Ignoring files outside view. View is %s") % view_str)
439
414
 
440
415
    # Get extra trees that ought to be searched for file-ids
441
416
    extra_trees = None
442
417
    if working_tree is not None and working_tree not in (old_tree, new_tree):
443
418
        extra_trees = (working_tree,)
444
 
    return old_tree, new_tree, old_branch, new_branch, specific_files, extra_trees
 
419
    return (old_tree, new_tree, old_branch, new_branch,
 
420
            specific_files, extra_trees)
445
421
 
446
422
 
447
423
def _get_tree_to_diff(spec, tree=None, branch=None, basis_is_default=True):
464
440
                    extra_trees=None,
465
441
                    path_encoding='utf8',
466
442
                    using=None,
467
 
                    format_cls=None):
 
443
                    format_cls=None,
 
444
                    context=DEFAULT_CONTEXT_AMOUNT):
468
445
    """Show in text form the changes from one tree to another.
469
446
 
470
447
    :param to_file: The output stream.
471
 
    :param specific_files:Include only changes to these files - None for all
 
448
    :param specific_files: Include only changes to these files - None for all
472
449
        changes.
473
 
    :param external_diff_options: If set, use an external GNU diff and pass 
 
450
    :param external_diff_options: If set, use an external GNU diff and pass
474
451
        these options.
475
452
    :param extra_trees: If set, more Trees to use for looking up file ids
476
 
    :param path_encoding: If set, the path will be encoded as specified, 
 
453
    :param path_encoding: If set, the path will be encoded as specified,
477
454
        otherwise is supposed to be utf8
478
455
    :param format_cls: Formatter class (DiffTree subclass)
479
456
    """
 
457
    if context is None:
 
458
        context = DEFAULT_CONTEXT_AMOUNT
480
459
    if format_cls is None:
481
460
        format_cls = DiffTree
482
 
    old_tree.lock_read()
483
 
    try:
 
461
    with old_tree.lock_read():
484
462
        if extra_trees is not None:
485
463
            for tree in extra_trees:
486
464
                tree.lock_read()
489
467
            differ = format_cls.from_trees_options(old_tree, new_tree, to_file,
490
468
                                                   path_encoding,
491
469
                                                   external_diff_options,
492
 
                                                   old_label, new_label, using)
 
470
                                                   old_label, new_label, using,
 
471
                                                   context_lines=context)
493
472
            return differ.show_diff(specific_files, extra_trees)
494
473
        finally:
495
474
            new_tree.unlock()
496
475
            if extra_trees is not None:
497
476
                for tree in extra_trees:
498
477
                    tree.unlock()
499
 
    finally:
500
 
        old_tree.unlock()
501
 
 
502
 
 
503
 
def _patch_header_date(tree, file_id, path):
 
478
 
 
479
 
 
480
def _patch_header_date(tree, path):
504
481
    """Returns a timestamp suitable for use in a patch header."""
505
482
    try:
506
 
        mtime = tree.get_file_mtime(file_id, path)
507
 
    except errors.FileTimestampUnavailable:
 
483
        mtime = tree.get_file_mtime(path)
 
484
    except FileTimestampUnavailable:
508
485
        mtime = 0
509
486
    return timestamp.format_patch_date(mtime)
510
487
 
511
488
 
512
489
def get_executable_change(old_is_x, new_is_x):
513
 
    descr = { True:"+x", False:"-x", None:"??" }
 
490
    descr = {True: b"+x", False: b"-x", None: b"??"}
514
491
    if old_is_x != new_is_x:
515
 
        return ["%s to %s" % (descr[old_is_x], descr[new_is_x],)]
 
492
        return [b"%s to %s" % (descr[old_is_x], descr[new_is_x],)]
516
493
    else:
517
494
        return []
518
495
 
549
526
                     diff_tree.to_file, diff_tree.path_encoding)
550
527
 
551
528
    @staticmethod
552
 
    def _diff_many(differs, file_id, old_path, new_path, old_kind, new_kind):
 
529
    def _diff_many(differs, old_path, new_path, old_kind, new_kind):
553
530
        for file_differ in differs:
554
 
            result = file_differ.diff(file_id, old_path, new_path, old_kind,
555
 
                                      new_kind)
 
531
            result = file_differ.diff(old_path, new_path, old_kind, new_kind)
556
532
            if result is not DiffPath.CANNOT_DIFF:
557
533
                return result
558
534
        else:
565
541
    Represents kind change as deletion + creation.  Uses the other differs
566
542
    to do this.
567
543
    """
 
544
 
568
545
    def __init__(self, differs):
569
546
        self.differs = differs
570
547
 
575
552
    def from_diff_tree(klass, diff_tree):
576
553
        return klass(diff_tree.differs)
577
554
 
578
 
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
 
555
    def diff(self, old_path, new_path, old_kind, new_kind):
579
556
        """Perform comparison
580
557
 
581
 
        :param file_id: The file_id of the file to compare
582
558
        :param old_path: Path of the file in the old tree
583
559
        :param new_path: Path of the file in the new tree
584
560
        :param old_kind: Old file-kind of the file
586
562
        """
587
563
        if None in (old_kind, new_kind):
588
564
            return DiffPath.CANNOT_DIFF
589
 
        result = DiffPath._diff_many(self.differs, file_id, old_path,
590
 
                                       new_path, old_kind, None)
 
565
        result = DiffPath._diff_many(
 
566
            self.differs, old_path, new_path, old_kind, None)
591
567
        if result is DiffPath.CANNOT_DIFF:
592
568
            return result
593
 
        return DiffPath._diff_many(self.differs, file_id, old_path, new_path,
594
 
                                     None, new_kind)
 
569
        return DiffPath._diff_many(
 
570
            self.differs, old_path, new_path, None, new_kind)
595
571
 
596
572
 
597
573
class DiffDirectory(DiffPath):
598
574
 
599
 
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
 
575
    def diff(self, old_path, new_path, old_kind, new_kind):
600
576
        """Perform comparison between two directories.  (dummy)
601
577
 
602
578
        """
611
587
 
612
588
class DiffSymlink(DiffPath):
613
589
 
614
 
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
 
590
    def diff(self, old_path, new_path, old_kind, new_kind):
615
591
        """Perform comparison between two symlinks
616
592
 
617
 
        :param file_id: The file_id of the file to compare
618
593
        :param old_path: Path of the file in the old tree
619
594
        :param new_path: Path of the file in the new tree
620
595
        :param old_kind: Old file-kind of the file
623
598
        if 'symlink' not in (old_kind, new_kind):
624
599
            return self.CANNOT_DIFF
625
600
        if old_kind == 'symlink':
626
 
            old_target = self.old_tree.get_symlink_target(file_id)
 
601
            old_target = self.old_tree.get_symlink_target(old_path)
627
602
        elif old_kind is None:
628
603
            old_target = None
629
604
        else:
630
605
            return self.CANNOT_DIFF
631
606
        if new_kind == 'symlink':
632
 
            new_target = self.new_tree.get_symlink_target(file_id)
 
607
            new_target = self.new_tree.get_symlink_target(new_path)
633
608
        elif new_kind is None:
634
609
            new_target = None
635
610
        else:
638
613
 
639
614
    def diff_symlink(self, old_target, new_target):
640
615
        if old_target is None:
641
 
            self.to_file.write('=== target is %r\n' % new_target)
 
616
            self.to_file.write(b'=== target is \'%s\'\n' %
 
617
                               new_target.encode(self.path_encoding, 'replace'))
642
618
        elif new_target is None:
643
 
            self.to_file.write('=== target was %r\n' % old_target)
 
619
            self.to_file.write(b'=== target was \'%s\'\n' %
 
620
                               old_target.encode(self.path_encoding, 'replace'))
644
621
        else:
645
 
            self.to_file.write('=== target changed %r => %r\n' %
646
 
                              (old_target, new_target))
 
622
            self.to_file.write(b'=== target changed \'%s\' => \'%s\'\n' %
 
623
                               (old_target.encode(self.path_encoding, 'replace'),
 
624
                                new_target.encode(self.path_encoding, 'replace')))
647
625
        return self.CHANGED
648
626
 
649
627
 
654
632
    EPOCH_DATE = '1970-01-01 00:00:00 +0000'
655
633
 
656
634
    def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8',
657
 
                 old_label='', new_label='', text_differ=internal_diff):
 
635
                 old_label='', new_label='', text_differ=internal_diff,
 
636
                 context_lines=DEFAULT_CONTEXT_AMOUNT):
658
637
        DiffPath.__init__(self, old_tree, new_tree, to_file, path_encoding)
659
638
        self.text_differ = text_differ
660
639
        self.old_label = old_label
661
640
        self.new_label = new_label
662
641
        self.path_encoding = path_encoding
 
642
        self.context_lines = context_lines
663
643
 
664
 
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
 
644
    def diff(self, old_path, new_path, old_kind, new_kind):
665
645
        """Compare two files in unified diff format
666
646
 
667
 
        :param file_id: The file_id of the file to compare
668
647
        :param old_path: Path of the file in the old tree
669
648
        :param new_path: Path of the file in the new tree
670
649
        :param old_kind: Old file-kind of the file
672
651
        """
673
652
        if 'file' not in (old_kind, new_kind):
674
653
            return self.CANNOT_DIFF
675
 
        from_file_id = to_file_id = file_id
676
654
        if old_kind == 'file':
677
 
            old_date = _patch_header_date(self.old_tree, file_id, old_path)
 
655
            old_date = _patch_header_date(self.old_tree, old_path)
678
656
        elif old_kind is None:
679
657
            old_date = self.EPOCH_DATE
680
 
            from_file_id = None
681
658
        else:
682
659
            return self.CANNOT_DIFF
683
660
        if new_kind == 'file':
684
 
            new_date = _patch_header_date(self.new_tree, file_id, new_path)
 
661
            new_date = _patch_header_date(self.new_tree, new_path)
685
662
        elif new_kind is None:
686
663
            new_date = self.EPOCH_DATE
687
 
            to_file_id = None
688
664
        else:
689
665
            return self.CANNOT_DIFF
690
 
        from_label = '%s%s\t%s' % (self.old_label, old_path, old_date)
691
 
        to_label = '%s%s\t%s' % (self.new_label, new_path, new_date)
692
 
        return self.diff_text(from_file_id, to_file_id, from_label, to_label,
693
 
            old_path, new_path)
 
666
        from_label = '%s%s\t%s' % (self.old_label, old_path,
 
667
                                   old_date)
 
668
        to_label = '%s%s\t%s' % (self.new_label, new_path,
 
669
                                 new_date)
 
670
        return self.diff_text(old_path, new_path, from_label, to_label)
694
671
 
695
 
    def diff_text(self, from_file_id, to_file_id, from_label, to_label,
696
 
        from_path=None, to_path=None):
 
672
    def diff_text(self, from_path, to_path, from_label, to_label):
697
673
        """Diff the content of given files in two trees
698
674
 
699
 
        :param from_file_id: The id of the file in the from tree.  If None,
 
675
        :param from_path: The path in the from tree. If None,
700
676
            the file is not present in the from tree.
701
 
        :param to_file_id: The id of the file in the to tree.  This may refer
702
 
            to a different file from from_file_id.  If None,
 
677
        :param to_path: The path in the to tree. This may refer
 
678
            to a different file from from_path.  If None,
703
679
            the file is not present in the to tree.
704
 
        :param from_path: The path in the from tree or None if unknown.
705
 
        :param to_path: The path in the to tree or None if unknown.
706
680
        """
707
 
        def _get_text(tree, file_id, path):
708
 
            if file_id is not None:
709
 
                return tree.get_file(file_id, path).readlines()
710
 
            else:
 
681
        def _get_text(tree, path):
 
682
            if path is None:
 
683
                return []
 
684
            try:
 
685
                return tree.get_file_lines(path)
 
686
            except errors.NoSuchFile:
711
687
                return []
712
688
        try:
713
 
            from_text = _get_text(self.old_tree, from_file_id, from_path)
714
 
            to_text = _get_text(self.new_tree, to_file_id, to_path)
 
689
            from_text = _get_text(self.old_tree, from_path)
 
690
            to_text = _get_text(self.new_tree, to_path)
715
691
            self.text_differ(from_label, from_text, to_label, to_text,
716
 
                             self.to_file)
 
692
                             self.to_file, path_encoding=self.path_encoding,
 
693
                             context_lines=self.context_lines)
717
694
        except errors.BinaryFile:
718
695
            self.to_file.write(
719
 
                  ("Binary files %s and %s differ\n" %
720
 
                  (from_label, to_label)).encode(self.path_encoding))
 
696
                ("Binary files %s and %s differ\n" %
 
697
                 (from_label, to_label)).encode(self.path_encoding, 'replace'))
721
698
        return self.CHANGED
722
699
 
723
700
 
727
704
                 path_encoding='utf-8'):
728
705
        DiffPath.__init__(self, old_tree, new_tree, to_file, path_encoding)
729
706
        self.command_template = command_template
730
 
        self._root = osutils.mkdtemp(prefix='bzr-diff-')
 
707
        self._root = osutils.mkdtemp(prefix='brz-diff-')
731
708
 
732
709
    @classmethod
733
710
    def from_string(klass, command_string, old_tree, new_tree, to_file,
739
716
                     path_encoding)
740
717
 
741
718
    @classmethod
742
 
    def make_from_diff_tree(klass, command_string):
 
719
    def make_from_diff_tree(klass, command_string, external_diff_options=None):
743
720
        def from_diff_tree(diff_tree):
744
 
            return klass.from_string(command_string, diff_tree.old_tree,
 
721
            full_command_string = [command_string]
 
722
            if external_diff_options is not None:
 
723
                full_command_string += ' ' + external_diff_options
 
724
            return klass.from_string(full_command_string, diff_tree.old_tree,
745
725
                                     diff_tree.new_tree, diff_tree.to_file)
746
726
        return from_diff_tree
747
727
 
748
728
    def _get_command(self, old_path, new_path):
749
729
        my_map = {'old_path': old_path, 'new_path': new_path}
750
 
        return [AtTemplate(t).substitute(my_map) for t in
751
 
                self.command_template]
 
730
        command = [AtTemplate(t).substitute(my_map) for t in
 
731
                   self.command_template]
 
732
        if sys.platform == 'win32':  # Popen doesn't accept unicode on win32
 
733
            command_encoded = []
 
734
            for c in command:
 
735
                if isinstance(c, text_type):
 
736
                    command_encoded.append(c.encode('mbcs'))
 
737
                else:
 
738
                    command_encoded.append(c)
 
739
            return command_encoded
 
740
        else:
 
741
            return command
752
742
 
753
743
    def _execute(self, old_path, new_path):
754
744
        command = self._get_command(old_path, new_path)
755
745
        try:
756
746
            proc = subprocess.Popen(command, stdout=subprocess.PIPE,
757
747
                                    cwd=self._root)
758
 
        except OSError, e:
 
748
        except OSError as e:
759
749
            if e.errno == errno.ENOENT:
760
750
                raise errors.ExecutableMissing(command[0])
761
751
            else:
762
752
                raise
763
753
        self.to_file.write(proc.stdout.read())
 
754
        proc.stdout.close()
764
755
        return proc.wait()
765
756
 
766
757
    def _try_symlink_root(self, tree, prefix):
767
 
        if (getattr(tree, 'abspath', None) is None
768
 
            or not osutils.host_os_dereferences_symlinks()):
 
758
        if (getattr(tree, 'abspath', None) is None or
 
759
                not osutils.host_os_dereferences_symlinks()):
769
760
            return False
770
761
        try:
771
762
            os.symlink(tree.abspath(''), osutils.pathjoin(self._root, prefix))
772
 
        except OSError, e:
 
763
        except OSError as e:
773
764
            if e.errno != errno.EEXIST:
774
765
                raise
775
766
        return True
776
767
 
777
 
    def _write_file(self, file_id, tree, prefix, relpath, force_temp=False,
 
768
    @staticmethod
 
769
    def _fenc():
 
770
        """Returns safe encoding for passing file path to diff tool"""
 
771
        if sys.platform == 'win32':
 
772
            return 'mbcs'
 
773
        else:
 
774
            # Don't fallback to 'utf-8' because subprocess may not be able to
 
775
            # handle utf-8 correctly when locale is not utf-8.
 
776
            return sys.getfilesystemencoding() or 'ascii'
 
777
 
 
778
    def _is_safepath(self, path):
 
779
        """Return true if `path` may be able to pass to subprocess."""
 
780
        fenc = self._fenc()
 
781
        try:
 
782
            return path == path.encode(fenc).decode(fenc)
 
783
        except UnicodeError:
 
784
            return False
 
785
 
 
786
    def _safe_filename(self, prefix, relpath):
 
787
        """Replace unsafe character in `relpath` then join `self._root`,
 
788
        `prefix` and `relpath`."""
 
789
        fenc = self._fenc()
 
790
        # encoded_str.replace('?', '_') may break multibyte char.
 
791
        # So we should encode, decode, then replace(u'?', u'_')
 
792
        relpath_tmp = relpath.encode(fenc, 'replace').decode(fenc, 'replace')
 
793
        relpath_tmp = relpath_tmp.replace(u'?', u'_')
 
794
        return osutils.pathjoin(self._root, prefix, relpath_tmp)
 
795
 
 
796
    def _write_file(self, relpath, tree, prefix, force_temp=False,
778
797
                    allow_write=False):
779
798
        if not force_temp and isinstance(tree, WorkingTree):
780
 
            return tree.abspath(tree.id2path(file_id))
781
 
        
782
 
        full_path = osutils.pathjoin(self._root, prefix, relpath)
 
799
            full_path = tree.abspath(relpath)
 
800
            if self._is_safepath(full_path):
 
801
                return full_path
 
802
 
 
803
        full_path = self._safe_filename(prefix, relpath)
783
804
        if not force_temp and self._try_symlink_root(tree, prefix):
784
805
            return full_path
785
806
        parent_dir = osutils.dirname(full_path)
786
807
        try:
787
808
            os.makedirs(parent_dir)
788
 
        except OSError, e:
 
809
        except OSError as e:
789
810
            if e.errno != errno.EEXIST:
790
811
                raise
791
 
        source = tree.get_file(file_id, relpath)
 
812
        source = tree.get_file(relpath)
792
813
        try:
793
 
            target = open(full_path, 'wb')
794
 
            try:
 
814
            with open(full_path, 'wb') as target:
795
815
                osutils.pumpfile(source, target)
796
 
            finally:
797
 
                target.close()
798
816
        finally:
799
817
            source.close()
800
818
        try:
801
 
            mtime = tree.get_file_mtime(file_id)
802
 
        except errors.FileTimestampUnavailable:
 
819
            mtime = tree.get_file_mtime(relpath)
 
820
        except FileTimestampUnavailable:
803
821
            pass
804
822
        else:
805
823
            os.utime(full_path, (mtime, mtime))
807
825
            osutils.make_readonly(full_path)
808
826
        return full_path
809
827
 
810
 
    def _prepare_files(self, file_id, old_path, new_path, force_temp=False,
 
828
    def _prepare_files(self, old_path, new_path, force_temp=False,
811
829
                       allow_write_new=False):
812
 
        old_disk_path = self._write_file(file_id, self.old_tree, 'old',
813
 
                                         old_path, force_temp)
814
 
        new_disk_path = self._write_file(file_id, self.new_tree, 'new',
815
 
                                         new_path, force_temp,
816
 
                                         allow_write=allow_write_new)
 
830
        old_disk_path = self._write_file(
 
831
            old_path, self.old_tree, 'old', force_temp)
 
832
        new_disk_path = self._write_file(
 
833
            new_path, self.new_tree, 'new', force_temp,
 
834
            allow_write=allow_write_new)
817
835
        return old_disk_path, new_disk_path
818
836
 
819
837
    def finish(self):
820
838
        try:
821
839
            osutils.rmtree(self._root)
822
 
        except OSError, e:
 
840
        except OSError as e:
823
841
            if e.errno != errno.ENOENT:
824
842
                mutter("The temporary directory \"%s\" was not "
825
 
                        "cleanly removed: %s." % (self._root, e))
 
843
                       "cleanly removed: %s." % (self._root, e))
826
844
 
827
 
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
 
845
    def diff(self, old_path, new_path, old_kind, new_kind):
828
846
        if (old_kind, new_kind) != ('file', 'file'):
829
847
            return DiffPath.CANNOT_DIFF
830
848
        (old_disk_path, new_disk_path) = self._prepare_files(
831
 
                                                file_id, old_path, new_path)
 
849
            old_path, new_path)
832
850
        self._execute(old_disk_path, new_disk_path)
833
851
 
834
 
    def edit_file(self, file_id):
 
852
    def edit_file(self, old_path, new_path):
835
853
        """Use this tool to edit a file.
836
854
 
837
855
        A temporary copy will be edited, and the new contents will be
838
856
        returned.
839
857
 
840
 
        :param file_id: The id of the file to edit.
841
858
        :return: The new contents of the file.
842
859
        """
843
 
        old_path = self.old_tree.id2path(file_id)
844
 
        new_path = self.new_tree.id2path(file_id)
845
 
        new_abs_path = self._prepare_files(file_id, old_path, new_path,
846
 
                                           allow_write_new=True,
847
 
                                           force_temp=True)[1]
848
 
        command = self._get_command(osutils.pathjoin('old', old_path),
849
 
                                    osutils.pathjoin('new', new_path))
 
860
        old_abs_path, new_abs_path = self._prepare_files(
 
861
            old_path, new_path, allow_write_new=True, force_temp=True)
 
862
        command = self._get_command(old_abs_path, new_abs_path)
850
863
        subprocess.call(command, cwd=self._root)
851
 
        new_file = open(new_abs_path, 'r')
852
 
        try:
 
864
        with open(new_abs_path, 'rb') as new_file:
853
865
            return new_file.read()
854
 
        finally:
855
 
            new_file.close()
856
866
 
857
867
 
858
868
class DiffTree(object):
886
896
            DiffPaths"""
887
897
        if diff_text is None:
888
898
            diff_text = DiffText(old_tree, new_tree, to_file, path_encoding,
889
 
                                 '', '',  internal_diff)
 
899
                                 '', '', internal_diff)
890
900
        self.old_tree = old_tree
891
901
        self.new_tree = new_tree
892
902
        self.to_file = to_file
900
910
    @classmethod
901
911
    def from_trees_options(klass, old_tree, new_tree, to_file,
902
912
                           path_encoding, external_diff_options, old_label,
903
 
                           new_label, using):
 
913
                           new_label, using, context_lines):
904
914
        """Factory for producing a DiffTree.
905
915
 
906
916
        Designed to accept options used by show_diff_trees.
 
917
 
907
918
        :param old_tree: The tree to show as old in the comparison
908
919
        :param new_tree: The tree to show as new in the comparison
909
920
        :param to_file: File to write comparisons to
915
926
        :param using: Commandline to use to invoke an external diff tool
916
927
        """
917
928
        if using is not None:
918
 
            extra_factories = [DiffFromTool.make_from_diff_tree(using)]
 
929
            extra_factories = [DiffFromTool.make_from_diff_tree(
 
930
                using, external_diff_options)]
919
931
        else:
920
932
            extra_factories = []
921
933
        if external_diff_options:
922
934
            opts = external_diff_options.split()
923
 
            def diff_file(olab, olines, nlab, nlines, to_file):
 
935
 
 
936
            def diff_file(olab, olines, nlab, nlines, to_file, path_encoding=None, context_lines=None):
 
937
                """:param path_encoding: not used but required
 
938
                        to match the signature of internal_diff.
 
939
                """
924
940
                external_diff(olab, olines, nlab, nlines, to_file, opts)
925
941
        else:
926
942
            diff_file = internal_diff
927
943
        diff_text = DiffText(old_tree, new_tree, to_file, path_encoding,
928
 
                             old_label, new_label, diff_file)
 
944
                             old_label, new_label, diff_file, context_lines=context_lines)
929
945
        return klass(old_tree, new_tree, to_file, path_encoding, diff_text,
930
946
                     extra_factories)
931
947
 
945
961
        # TODO: Generation of pseudo-diffs for added/deleted files could
946
962
        # be usefully made into a much faster special case.
947
963
        iterator = self.new_tree.iter_changes(self.old_tree,
948
 
                                               specific_files=specific_files,
949
 
                                               extra_trees=extra_trees,
950
 
                                               require_versioned=True)
 
964
                                              specific_files=specific_files,
 
965
                                              extra_trees=extra_trees,
 
966
                                              require_versioned=True)
951
967
        has_changes = 0
 
968
 
952
969
        def changes_key(change):
953
970
            old_path, new_path = change[1]
954
971
            path = new_path
955
972
            if path is None:
956
973
                path = old_path
957
974
            return path
 
975
 
958
976
        def get_encoded_path(path):
959
977
            if path is not None:
960
978
                return path.encode(self.path_encoding, "replace")
972
990
            renamed = (parent[0], name[0]) != (parent[1], name[1])
973
991
 
974
992
            properties_changed = []
975
 
            properties_changed.extend(get_executable_change(executable[0], executable[1]))
 
993
            properties_changed.extend(
 
994
                get_executable_change(executable[0], executable[1]))
976
995
 
977
996
            if properties_changed:
978
 
                prop_str = " (properties changed: %s)" % (", ".join(properties_changed),)
 
997
                prop_str = b" (properties changed: %s)" % (
 
998
                    b", ".join(properties_changed),)
979
999
            else:
980
 
                prop_str = ""
 
1000
                prop_str = b""
981
1001
 
982
1002
            if (old_present, new_present) == (True, False):
983
 
                self.to_file.write("=== removed %s '%s'\n" %
984
 
                                   (kind[0], oldpath_encoded))
 
1003
                self.to_file.write(b"=== removed %s '%s'\n" %
 
1004
                                   (kind[0].encode('ascii'), oldpath_encoded))
985
1005
                newpath = oldpath
986
1006
            elif (old_present, new_present) == (False, True):
987
 
                self.to_file.write("=== added %s '%s'\n" %
988
 
                                   (kind[1], newpath_encoded))
 
1007
                self.to_file.write(b"=== added %s '%s'\n" %
 
1008
                                   (kind[1].encode('ascii'), newpath_encoded))
989
1009
                oldpath = newpath
990
1010
            elif renamed:
991
 
                self.to_file.write("=== renamed %s '%s' => '%s'%s\n" %
992
 
                    (kind[0], oldpath_encoded, newpath_encoded, prop_str))
 
1011
                self.to_file.write(b"=== renamed %s '%s' => '%s'%s\n" %
 
1012
                                   (kind[0].encode('ascii'), oldpath_encoded, newpath_encoded, prop_str))
993
1013
            else:
994
1014
                # if it was produced by iter_changes, it must be
995
1015
                # modified *somehow*, either content or execute bit.
996
 
                self.to_file.write("=== modified %s '%s'%s\n" % (kind[0],
997
 
                                   newpath_encoded, prop_str))
 
1016
                self.to_file.write(b"=== modified %s '%s'%s\n" % (kind[0].encode('ascii'),
 
1017
                                                                  newpath_encoded, prop_str))
998
1018
            if changed_content:
999
 
                self._diff(file_id, oldpath, newpath, kind[0], kind[1])
 
1019
                self._diff(oldpath, newpath, kind[0], kind[1])
1000
1020
                has_changes = 1
1001
1021
            if renamed:
1002
1022
                has_changes = 1
1003
1023
        return has_changes
1004
1024
 
1005
 
    def diff(self, file_id, old_path, new_path):
 
1025
    def diff(self, old_path, new_path):
1006
1026
        """Perform a diff of a single file
1007
1027
 
1008
 
        :param file_id: file-id of the file
1009
1028
        :param old_path: The path of the file in the old tree
1010
1029
        :param new_path: The path of the file in the new tree
1011
1030
        """
1012
 
        try:
1013
 
            old_kind = self.old_tree.kind(file_id)
1014
 
        except (errors.NoSuchId, errors.NoSuchFile):
 
1031
        if old_path is None:
1015
1032
            old_kind = None
1016
 
        try:
1017
 
            new_kind = self.new_tree.kind(file_id)
1018
 
        except (errors.NoSuchId, errors.NoSuchFile):
 
1033
        else:
 
1034
            old_kind = self.old_tree.kind(old_path)
 
1035
        if new_path is None:
1019
1036
            new_kind = None
1020
 
        self._diff(file_id, old_path, new_path, old_kind, new_kind)
1021
 
 
1022
 
 
1023
 
    def _diff(self, file_id, old_path, new_path, old_kind, new_kind):
1024
 
        result = DiffPath._diff_many(self.differs, file_id, old_path,
1025
 
                                       new_path, old_kind, new_kind)
 
1037
        else:
 
1038
            new_kind = self.new_tree.kind(new_path)
 
1039
        self._diff(old_path, new_path, old_kind, new_kind)
 
1040
 
 
1041
    def _diff(self, old_path, new_path, old_kind, new_kind):
 
1042
        result = DiffPath._diff_many(
 
1043
            self.differs, old_path, new_path, old_kind, new_kind)
1026
1044
        if result is DiffPath.CANNOT_DIFF:
1027
1045
            error_path = new_path
1028
1046
            if error_path is None: