← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/diff.py

  • Committer: Patch Queue Manager
  • Date: 2016-04-21 04:10:52 UTC
  • mfrom: (6616.1.1 fix-en-user-guide)
  • Revision ID: pqm@pqm.ubuntu.com-20160421041052-clcye7ns1qcl2n7w
(richard-wilbur) Ensure build of English use guide always uses English text
 even when user's locale specifies a different language. (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/diff.py
1
 
# Copyright (C) 2004, 2005, 2006 Canonical Ltd.
 
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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
from __future__ import absolute_import
16
18
 
17
19
import difflib
18
20
import os
19
21
import re
20
 
import shutil
 
22
import string
21
23
import sys
22
24
 
23
25
from bzrlib.lazy_import import lazy_import
25
27
import errno
26
28
import subprocess
27
29
import tempfile
28
 
import time
29
30
 
30
31
from bzrlib import (
31
 
    branch as _mod_branch,
32
 
    bzrdir,
33
 
    commands,
 
32
    cleanup,
 
33
    cmdline,
 
34
    controldir,
34
35
    errors,
35
36
    osutils,
36
37
    patiencediff,
37
38
    textfile,
38
39
    timestamp,
 
40
    views,
39
41
    )
 
42
 
 
43
from bzrlib.workingtree import WorkingTree
 
44
from bzrlib.i18n import gettext
40
45
""")
41
46
 
42
 
from bzrlib.symbol_versioning import (
43
 
        deprecated_function,
44
 
        one_three
45
 
        )
46
 
from bzrlib.trace import mutter, warning
 
47
from bzrlib.registry import (
 
48
    Registry,
 
49
    )
 
50
from bzrlib.trace import mutter, note, warning
 
51
 
 
52
DEFAULT_CONTEXT_AMOUNT = 3
 
53
 
 
54
class AtTemplate(string.Template):
 
55
    """Templating class that uses @ instead of $."""
 
56
 
 
57
    delimiter = '@'
47
58
 
48
59
 
49
60
# TODO: Rather than building a changeset object, we should probably
62
73
 
63
74
def internal_diff(old_filename, oldlines, new_filename, newlines, to_file,
64
75
                  allow_binary=False, sequence_matcher=None,
65
 
                  path_encoding='utf8'):
 
76
                  path_encoding='utf8', context_lines=DEFAULT_CONTEXT_AMOUNT):
66
77
    # FIXME: difflib is wrong if there is no trailing newline.
67
78
    # The syntax used by patch seems to be "\ No newline at
68
79
    # end of file" following the last diff line from that
78
89
    # both sequences are empty.
79
90
    if not oldlines and not newlines:
80
91
        return
81
 
    
 
92
 
82
93
    if allow_binary is False:
83
94
        textfile.check_text_lines(oldlines)
84
95
        textfile.check_text_lines(newlines)
86
97
    if sequence_matcher is None:
87
98
        sequence_matcher = patiencediff.PatienceSequenceMatcher
88
99
    ud = patiencediff.unified_diff(oldlines, newlines,
89
 
                      fromfile=old_filename.encode(path_encoding),
90
 
                      tofile=new_filename.encode(path_encoding),
91
 
                      sequencematcher=sequence_matcher)
 
100
                      fromfile=old_filename.encode(path_encoding, 'replace'),
 
101
                      tofile=new_filename.encode(path_encoding, 'replace'),
 
102
                      n=context_lines, sequencematcher=sequence_matcher)
92
103
 
93
104
    ud = list(ud)
94
105
    if len(ud) == 0: # Identical contents, nothing to do
99
110
        ud[2] = ud[2].replace('-1,0', '-0,0')
100
111
    elif not newlines:
101
112
        ud[2] = ud[2].replace('+1,0', '+0,0')
102
 
    # work around for difflib emitting random spaces after the label
103
 
    ud[0] = ud[0][:-2] + '\n'
104
 
    ud[1] = ud[1][:-2] + '\n'
105
113
 
106
114
    for line in ud:
107
115
        to_file.write(line)
111
119
 
112
120
 
113
121
def _spawn_external_diff(diffcmd, capture_errors=True):
114
 
    """Spawn the externall diff process, and return the child handle.
 
122
    """Spawn the external diff process, and return the child handle.
115
123
 
116
124
    :param diffcmd: The command list to spawn
117
125
    :param capture_errors: Capture stderr as well as setting LANG=C
146
154
 
147
155
    return pipe
148
156
 
 
157
# diff style options as of GNU diff v3.2
 
158
style_option_list = ['-c', '-C', '--context',
 
159
                     '-e', '--ed',
 
160
                     '-f', '--forward-ed',
 
161
                     '-q', '--brief',
 
162
                     '--normal',
 
163
                     '-n', '--rcs',
 
164
                     '-u', '-U', '--unified',
 
165
                     '-y', '--side-by-side',
 
166
                     '-D', '--ifdef']
 
167
 
 
168
def default_style_unified(diff_opts):
 
169
    """Default to unified diff style if alternative not specified in diff_opts.
 
170
 
 
171
        diff only allows one style to be specified; they don't override.
 
172
        Note that some of these take optargs, and the optargs can be
 
173
        directly appended to the options.
 
174
        This is only an approximate parser; it doesn't properly understand
 
175
        the grammar.
 
176
 
 
177
    :param diff_opts: List of options for external (GNU) diff.
 
178
    :return: List of options with default style=='unified'.
 
179
    """
 
180
    for s in style_option_list:
 
181
        for j in diff_opts:
 
182
            if j.startswith(s):
 
183
                break
 
184
        else:
 
185
            continue
 
186
        break
 
187
    else:
 
188
        diff_opts.append('-u')
 
189
    return diff_opts
 
190
 
149
191
 
150
192
def external_diff(old_filename, oldlines, new_filename, newlines, to_file,
151
193
                  diff_opts):
174
216
 
175
217
        if not diff_opts:
176
218
            diff_opts = []
 
219
        if sys.platform == 'win32':
 
220
            # Popen doesn't do the proper encoding for external commands
 
221
            # Since we are dealing with an ANSI api, use mbcs encoding
 
222
            old_filename = old_filename.encode('mbcs')
 
223
            new_filename = new_filename.encode('mbcs')
177
224
        diffcmd = ['diff',
178
225
                   '--label', old_filename,
179
226
                   old_abspath,
182
229
                   '--binary',
183
230
                  ]
184
231
 
185
 
        # diff only allows one style to be specified; they don't override.
186
 
        # note that some of these take optargs, and the optargs can be
187
 
        # directly appended to the options.
188
 
        # this is only an approximate parser; it doesn't properly understand
189
 
        # the grammar.
190
 
        for s in ['-c', '-u', '-C', '-U',
191
 
                  '-e', '--ed',
192
 
                  '-q', '--brief',
193
 
                  '--normal',
194
 
                  '-n', '--rcs',
195
 
                  '-y', '--side-by-side',
196
 
                  '-D', '--ifdef']:
197
 
            for j in diff_opts:
198
 
                if j.startswith(s):
199
 
                    break
200
 
            else:
201
 
                continue
202
 
            break
203
 
        else:
204
 
            diffcmd.append('-u')
205
 
                  
 
232
        diff_opts = default_style_unified(diff_opts)
 
233
 
206
234
        if diff_opts:
207
235
            diffcmd.extend(diff_opts)
208
236
 
209
237
        pipe = _spawn_external_diff(diffcmd, capture_errors=True)
210
238
        out,err = pipe.communicate()
211
239
        rc = pipe.returncode
212
 
        
 
240
 
213
241
        # internal_diff() adds a trailing newline, add one here for consistency
214
242
        out += '\n'
215
243
        if rc == 2:
250
278
                msg = 'signal %d' % (-rc)
251
279
            else:
252
280
                msg = 'exit code %d' % rc
253
 
                
254
 
            raise errors.BzrError('external diff failed with %s; command: %r' 
255
 
                                  % (rc, diffcmd))
 
281
 
 
282
            raise errors.BzrError('external diff failed with %s; command: %r'
 
283
                                  % (msg, diffcmd))
256
284
 
257
285
 
258
286
    finally:
259
287
        oldtmpf.close()                 # and delete
260
288
        newtmpf.close()
261
 
        # Clean up. Warn in case the files couldn't be deleted
262
 
        # (in case windows still holds the file open, but not
263
 
        # if the files have already been deleted)
264
 
        try:
265
 
            os.remove(old_abspath)
266
 
        except OSError, e:
267
 
            if e.errno not in (errno.ENOENT,):
268
 
                warning('Failed to delete temporary file: %s %s',
269
 
                        old_abspath, e)
270
 
        try:
271
 
            os.remove(new_abspath)
272
 
        except OSError:
273
 
            if e.errno not in (errno.ENOENT,):
274
 
                warning('Failed to delete temporary file: %s %s',
275
 
                        new_abspath, e)
276
 
 
277
 
 
278
 
def _get_trees_to_diff(path_list, revision_specs, old_url, new_url):
 
289
 
 
290
        def cleanup(path):
 
291
            # Warn in case the file couldn't be deleted (in case windows still
 
292
            # holds the file open, but not if the files have already been
 
293
            # deleted)
 
294
            try:
 
295
                os.remove(path)
 
296
            except OSError, e:
 
297
                if e.errno not in (errno.ENOENT,):
 
298
                    warning('Failed to delete temporary file: %s %s', path, e)
 
299
 
 
300
        cleanup(old_abspath)
 
301
        cleanup(new_abspath)
 
302
 
 
303
 
 
304
def get_trees_and_branches_to_diff_locked(
 
305
    path_list, revision_specs, old_url, new_url, add_cleanup, apply_view=True):
279
306
    """Get the trees and specific files to diff given a list of paths.
280
307
 
281
308
    This method works out the trees to be diff'ed and the files of
292
319
    :param new_url:
293
320
        The url of the new branch or tree. If None, the tree to use is
294
321
        taken from the first path, if any, or the current working tree.
 
322
    :param add_cleanup:
 
323
        a callable like Command.add_cleanup.  get_trees_and_branches_to_diff
 
324
        will register cleanups that must be run to unlock the trees, etc.
 
325
    :param apply_view:
 
326
        if True and a view is set, apply the view or check that the paths
 
327
        are within it
295
328
    :returns:
296
 
        a tuple of (old_tree, new_tree, specific_files, extra_trees) where
297
 
        extra_trees is a sequence of additional trees to search in for
298
 
        file-ids.
 
329
        a tuple of (old_tree, new_tree, old_branch, new_branch,
 
330
        specific_files, extra_trees) where extra_trees is a sequence of
 
331
        additional trees to search in for file-ids.  The trees and branches
 
332
        will be read-locked until the cleanups registered via the add_cleanup
 
333
        param are run.
299
334
    """
300
335
    # Get the old and new revision specs
301
336
    old_revision_spec = None
324
359
        default_location = path_list[0]
325
360
        other_paths = path_list[1:]
326
361
 
 
362
    def lock_tree_or_branch(wt, br):
 
363
        if wt is not None:
 
364
            wt.lock_read()
 
365
            add_cleanup(wt.unlock)
 
366
        elif br is not None:
 
367
            br.lock_read()
 
368
            add_cleanup(br.unlock)
 
369
 
327
370
    # Get the old location
328
371
    specific_files = []
329
372
    if old_url is None:
330
373
        old_url = default_location
331
374
    working_tree, branch, relpath = \
332
 
        bzrdir.BzrDir.open_containing_tree_or_branch(old_url)
 
375
        controldir.ControlDir.open_containing_tree_or_branch(old_url)
 
376
    lock_tree_or_branch(working_tree, branch)
333
377
    if consider_relpath and relpath != '':
 
378
        if working_tree is not None and apply_view:
 
379
            views.check_path_in_view(working_tree, relpath)
334
380
        specific_files.append(relpath)
335
381
    old_tree = _get_tree_to_diff(old_revision_spec, working_tree, branch)
 
382
    old_branch = branch
336
383
 
337
384
    # Get the new location
338
385
    if new_url is None:
339
386
        new_url = default_location
340
387
    if new_url != old_url:
341
388
        working_tree, branch, relpath = \
342
 
            bzrdir.BzrDir.open_containing_tree_or_branch(new_url)
 
389
            controldir.ControlDir.open_containing_tree_or_branch(new_url)
 
390
        lock_tree_or_branch(working_tree, branch)
343
391
        if consider_relpath and relpath != '':
 
392
            if working_tree is not None and apply_view:
 
393
                views.check_path_in_view(working_tree, relpath)
344
394
            specific_files.append(relpath)
345
395
    new_tree = _get_tree_to_diff(new_revision_spec, working_tree, branch,
346
396
        basis_is_default=working_tree is None)
 
397
    new_branch = branch
347
398
 
348
399
    # Get the specific files (all files is None, no files is [])
349
400
    if make_paths_wt_relative and working_tree is not None:
350
 
        other_paths = _relative_paths_in_tree(working_tree, other_paths)
 
401
        other_paths = working_tree.safe_relpath_files(
 
402
            other_paths,
 
403
            apply_view=apply_view)
351
404
    specific_files.extend(other_paths)
352
405
    if len(specific_files) == 0:
353
406
        specific_files = None
 
407
        if (working_tree is not None and working_tree.supports_views()
 
408
            and apply_view):
 
409
            view_files = working_tree.views.lookup_view()
 
410
            if view_files:
 
411
                specific_files = view_files
 
412
                view_str = views.view_display_str(view_files)
 
413
                note(gettext("*** Ignoring files outside view. View is %s") % view_str)
354
414
 
355
415
    # Get extra trees that ought to be searched for file-ids
356
416
    extra_trees = None
357
417
    if working_tree is not None and working_tree not in (old_tree, new_tree):
358
418
        extra_trees = (working_tree,)
359
 
    return old_tree, new_tree, specific_files, extra_trees
 
419
    return (old_tree, new_tree, old_branch, new_branch,
 
420
            specific_files, extra_trees)
360
421
 
361
422
 
362
423
def _get_tree_to_diff(spec, tree=None, branch=None, basis_is_default=True):
370
431
                return branch.basis_tree()
371
432
        else:
372
433
            return tree
373
 
    if not spec.needs_branch():
374
 
        branch = _mod_branch.Branch.open(spec.get_branch())
375
 
    revision_id = spec.as_revision_id(branch)
376
 
    return branch.repository.revision_tree(revision_id)
377
 
 
378
 
 
379
 
def _relative_paths_in_tree(tree, paths):
380
 
    """Get the relative paths within a working tree.
381
 
 
382
 
    Each path may be either an absolute path or a path relative to the
383
 
    current working directory.
384
 
    """
385
 
    result = []
386
 
    for filename in paths:
387
 
        try:
388
 
            result.append(tree.relpath(osutils.dereference_path(filename)))
389
 
        except errors.PathNotChild:
390
 
            raise errors.BzrCommandError("Files are in different branches")
391
 
    return result
 
434
    return spec.as_tree(branch)
392
435
 
393
436
 
394
437
def show_diff_trees(old_tree, new_tree, to_file, specific_files=None,
396
439
                    old_label='a/', new_label='b/',
397
440
                    extra_trees=None,
398
441
                    path_encoding='utf8',
399
 
                    using=None):
 
442
                    using=None,
 
443
                    format_cls=None,
 
444
                    context=DEFAULT_CONTEXT_AMOUNT):
400
445
    """Show in text form the changes from one tree to another.
401
446
 
402
 
    to_file
403
 
        The output stream.
404
 
 
405
 
    specific_files
406
 
        Include only changes to these files - None for all changes.
407
 
 
408
 
    external_diff_options
409
 
        If set, use an external GNU diff and pass these options.
410
 
 
411
 
    extra_trees
412
 
        If set, more Trees to use for looking up file ids
413
 
 
414
 
    path_encoding
415
 
        If set, the path will be encoded as specified, otherwise is supposed
416
 
        to be utf8
 
447
    :param to_file: The output stream.
 
448
    :param specific_files: Include only changes to these files - None for all
 
449
        changes.
 
450
    :param external_diff_options: If set, use an external GNU diff and pass 
 
451
        these options.
 
452
    :param extra_trees: If set, more Trees to use for looking up file ids
 
453
    :param path_encoding: If set, the path will be encoded as specified, 
 
454
        otherwise is supposed to be utf8
 
455
    :param format_cls: Formatter class (DiffTree subclass)
417
456
    """
 
457
    if context is None:
 
458
        context = DEFAULT_CONTEXT_AMOUNT
 
459
    if format_cls is None:
 
460
        format_cls = DiffTree
418
461
    old_tree.lock_read()
419
462
    try:
420
463
        if extra_trees is not None:
422
465
                tree.lock_read()
423
466
        new_tree.lock_read()
424
467
        try:
425
 
            differ = DiffTree.from_trees_options(old_tree, new_tree, to_file,
426
 
                                                 path_encoding,
427
 
                                                 external_diff_options,
428
 
                                                 old_label, new_label, using)
 
468
            differ = format_cls.from_trees_options(old_tree, new_tree, to_file,
 
469
                                                   path_encoding,
 
470
                                                   external_diff_options,
 
471
                                                   old_label, new_label, using,
 
472
                                                   context_lines=context)
429
473
            return differ.show_diff(specific_files, extra_trees)
430
474
        finally:
431
475
            new_tree.unlock()
438
482
 
439
483
def _patch_header_date(tree, file_id, path):
440
484
    """Returns a timestamp suitable for use in a patch header."""
441
 
    mtime = tree.get_file_mtime(file_id, path)
 
485
    try:
 
486
        mtime = tree.get_file_mtime(file_id, path)
 
487
    except errors.FileTimestampUnavailable:
 
488
        mtime = 0
442
489
    return timestamp.format_patch_date(mtime)
443
490
 
444
491
 
445
 
def _raise_if_nonexistent(paths, old_tree, new_tree):
446
 
    """Complain if paths are not in either inventory or tree.
447
 
 
448
 
    It's OK with the files exist in either tree's inventory, or 
449
 
    if they exist in the tree but are not versioned.
450
 
    
451
 
    This can be used by operations such as bzr status that can accept
452
 
    unknown or ignored files.
453
 
    """
454
 
    mutter("check paths: %r", paths)
455
 
    if not paths:
456
 
        return
457
 
    s = old_tree.filter_unversioned_files(paths)
458
 
    s = new_tree.filter_unversioned_files(s)
459
 
    s = [path for path in s if not new_tree.has_filename(path)]
460
 
    if s:
461
 
        raise errors.PathsDoNotExist(sorted(s))
462
 
 
463
 
 
464
 
@deprecated_function(one_three)
465
 
def get_prop_change(meta_modified):
466
 
    if meta_modified:
467
 
        return " (properties changed)"
468
 
    else:
469
 
        return  ""
470
 
 
471
492
def get_executable_change(old_is_x, new_is_x):
472
493
    descr = { True:"+x", False:"-x", None:"??" }
473
494
    if old_is_x != new_is_x:
612
633
    # or removed in a diff.
613
634
    EPOCH_DATE = '1970-01-01 00:00:00 +0000'
614
635
 
615
 
    def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8',
616
 
                 old_label='', new_label='', text_differ=internal_diff):
 
636
    def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8', 
 
637
                 old_label='', new_label='', text_differ=internal_diff, 
 
638
                 context_lines=DEFAULT_CONTEXT_AMOUNT):
617
639
        DiffPath.__init__(self, old_tree, new_tree, to_file, path_encoding)
618
640
        self.text_differ = text_differ
619
641
        self.old_label = old_label
620
642
        self.new_label = new_label
621
643
        self.path_encoding = path_encoding
 
644
        self.context_lines = context_lines
622
645
 
623
646
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
624
647
        """Compare two files in unified diff format
648
671
            return self.CANNOT_DIFF
649
672
        from_label = '%s%s\t%s' % (self.old_label, old_path, old_date)
650
673
        to_label = '%s%s\t%s' % (self.new_label, new_path, new_date)
651
 
        return self.diff_text(from_file_id, to_file_id, from_label, to_label)
 
674
        return self.diff_text(from_file_id, to_file_id, from_label, to_label,
 
675
            old_path, new_path)
652
676
 
653
 
    def diff_text(self, from_file_id, to_file_id, from_label, to_label):
 
677
    def diff_text(self, from_file_id, to_file_id, from_label, to_label,
 
678
        from_path=None, to_path=None):
654
679
        """Diff the content of given files in two trees
655
680
 
656
681
        :param from_file_id: The id of the file in the from tree.  If None,
658
683
        :param to_file_id: The id of the file in the to tree.  This may refer
659
684
            to a different file from from_file_id.  If None,
660
685
            the file is not present in the to tree.
 
686
        :param from_path: The path in the from tree or None if unknown.
 
687
        :param to_path: The path in the to tree or None if unknown.
661
688
        """
662
 
        def _get_text(tree, file_id):
 
689
        def _get_text(tree, file_id, path):
663
690
            if file_id is not None:
664
 
                return tree.get_file(file_id).readlines()
 
691
                return tree.get_file_lines(file_id, path)
665
692
            else:
666
693
                return []
667
694
        try:
668
 
            from_text = _get_text(self.old_tree, from_file_id)
669
 
            to_text = _get_text(self.new_tree, to_file_id)
 
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)
670
697
            self.text_differ(from_label, from_text, to_label, to_text,
671
 
                             self.to_file)
 
698
                             self.to_file, path_encoding=self.path_encoding,
 
699
                             context_lines=self.context_lines)
672
700
        except errors.BinaryFile:
673
701
            self.to_file.write(
674
702
                  ("Binary files %s and %s differ\n" %
675
 
                  (from_label, to_label)).encode(self.path_encoding))
 
703
                  (from_label, to_label)).encode(self.path_encoding,'replace'))
676
704
        return self.CHANGED
677
705
 
678
706
 
687
715
    @classmethod
688
716
    def from_string(klass, command_string, old_tree, new_tree, to_file,
689
717
                    path_encoding='utf-8'):
690
 
        command_template = commands.shlex_split_unicode(command_string)
691
 
        command_template.extend(['%(old_path)s', '%(new_path)s'])
 
718
        command_template = cmdline.split(command_string)
 
719
        if '@' not in command_string:
 
720
            command_template.extend(['@old_path', '@new_path'])
692
721
        return klass(command_template, old_tree, new_tree, to_file,
693
722
                     path_encoding)
694
723
 
695
724
    @classmethod
696
 
    def make_from_diff_tree(klass, command_string):
 
725
    def make_from_diff_tree(klass, command_string, external_diff_options=None):
697
726
        def from_diff_tree(diff_tree):
698
 
            return klass.from_string(command_string, diff_tree.old_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,
699
731
                                     diff_tree.new_tree, diff_tree.to_file)
700
732
        return from_diff_tree
701
733
 
702
734
    def _get_command(self, old_path, new_path):
703
735
        my_map = {'old_path': old_path, 'new_path': new_path}
704
 
        return [t % my_map for t in self.command_template]
 
736
        command = [AtTemplate(t).substitute(my_map) for t in
 
737
                   self.command_template]
 
738
        if sys.platform == 'win32': # Popen doesn't accept unicode on win32
 
739
            command_encoded = []
 
740
            for c in command:
 
741
                if isinstance(c, unicode):
 
742
                    command_encoded.append(c.encode('mbcs'))
 
743
                else:
 
744
                    command_encoded.append(c)
 
745
            return command_encoded
 
746
        else:
 
747
            return command
705
748
 
706
749
    def _execute(self, old_path, new_path):
707
750
        command = self._get_command(old_path, new_path)
727
770
                raise
728
771
        return True
729
772
 
730
 
    def _write_file(self, file_id, tree, prefix, relpath):
731
 
        full_path = osutils.pathjoin(self._root, prefix, relpath)
732
 
        if self._try_symlink_root(tree, prefix):
 
773
    @staticmethod
 
774
    def _fenc():
 
775
        """Returns safe encoding for passing file path to diff tool"""
 
776
        if sys.platform == 'win32':
 
777
            return 'mbcs'
 
778
        else:
 
779
            # Don't fallback to 'utf-8' because subprocess may not be able to
 
780
            # handle utf-8 correctly when locale is not utf-8.
 
781
            return sys.getfilesystemencoding() or 'ascii'
 
782
 
 
783
    def _is_safepath(self, path):
 
784
        """Return true if `path` may be able to pass to subprocess."""
 
785
        fenc = self._fenc()
 
786
        try:
 
787
            return path == path.encode(fenc).decode(fenc)
 
788
        except UnicodeError:
 
789
            return False
 
790
 
 
791
    def _safe_filename(self, prefix, relpath):
 
792
        """Replace unsafe character in `relpath` then join `self._root`,
 
793
        `prefix` and `relpath`."""
 
794
        fenc = self._fenc()
 
795
        # encoded_str.replace('?', '_') may break multibyte char.
 
796
        # So we should encode, decode, then replace(u'?', u'_')
 
797
        relpath_tmp = relpath.encode(fenc, 'replace').decode(fenc, 'replace')
 
798
        relpath_tmp = relpath_tmp.replace(u'?', u'_')
 
799
        return osutils.pathjoin(self._root, prefix, relpath_tmp)
 
800
 
 
801
    def _write_file(self, file_id, tree, prefix, relpath, force_temp=False,
 
802
                    allow_write=False):
 
803
        if not force_temp and isinstance(tree, WorkingTree):
 
804
            full_path = tree.abspath(tree.id2path(file_id))
 
805
            if self._is_safepath(full_path):
 
806
                return full_path
 
807
 
 
808
        full_path = self._safe_filename(prefix, relpath)
 
809
        if not force_temp and self._try_symlink_root(tree, prefix):
733
810
            return full_path
734
811
        parent_dir = osutils.dirname(full_path)
735
812
        try:
746
823
                target.close()
747
824
        finally:
748
825
            source.close()
749
 
        osutils.make_readonly(full_path)
750
 
        mtime = tree.get_file_mtime(file_id)
751
 
        os.utime(full_path, (mtime, mtime))
 
826
        try:
 
827
            mtime = tree.get_file_mtime(file_id)
 
828
        except errors.FileTimestampUnavailable:
 
829
            pass
 
830
        else:
 
831
            os.utime(full_path, (mtime, mtime))
 
832
        if not allow_write:
 
833
            osutils.make_readonly(full_path)
752
834
        return full_path
753
835
 
754
 
    def _prepare_files(self, file_id, old_path, new_path):
 
836
    def _prepare_files(self, file_id, old_path, new_path, force_temp=False,
 
837
                       allow_write_new=False):
755
838
        old_disk_path = self._write_file(file_id, self.old_tree, 'old',
756
 
                                         old_path)
 
839
                                         old_path, force_temp)
757
840
        new_disk_path = self._write_file(file_id, self.new_tree, 'new',
758
 
                                         new_path)
 
841
                                         new_path, force_temp,
 
842
                                         allow_write=allow_write_new)
759
843
        return old_disk_path, new_disk_path
760
844
 
761
845
    def finish(self):
762
 
        osutils.rmtree(self._root)
 
846
        try:
 
847
            osutils.rmtree(self._root)
 
848
        except OSError, e:
 
849
            if e.errno != errno.ENOENT:
 
850
                mutter("The temporary directory \"%s\" was not "
 
851
                        "cleanly removed: %s." % (self._root, e))
763
852
 
764
853
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
765
854
        if (old_kind, new_kind) != ('file', 'file'):
766
855
            return DiffPath.CANNOT_DIFF
767
 
        self._prepare_files(file_id, old_path, new_path)
768
 
        self._execute(osutils.pathjoin('old', old_path),
769
 
                      osutils.pathjoin('new', new_path))
 
856
        (old_disk_path, new_disk_path) = self._prepare_files(
 
857
                                                file_id, old_path, new_path)
 
858
        self._execute(old_disk_path, new_disk_path)
 
859
 
 
860
    def edit_file(self, file_id):
 
861
        """Use this tool to edit a file.
 
862
 
 
863
        A temporary copy will be edited, and the new contents will be
 
864
        returned.
 
865
 
 
866
        :param file_id: The id of the file to edit.
 
867
        :return: The new contents of the file.
 
868
        """
 
869
        old_path = self.old_tree.id2path(file_id)
 
870
        new_path = self.new_tree.id2path(file_id)
 
871
        old_abs_path, new_abs_path = self._prepare_files(
 
872
                                            file_id, old_path, new_path,
 
873
                                            allow_write_new=True,
 
874
                                            force_temp=True)
 
875
        command = self._get_command(old_abs_path, new_abs_path)
 
876
        subprocess.call(command, cwd=self._root)
 
877
        new_file = open(new_abs_path, 'rb')
 
878
        try:
 
879
            return new_file.read()
 
880
        finally:
 
881
            new_file.close()
770
882
 
771
883
 
772
884
class DiffTree(object):
814
926
    @classmethod
815
927
    def from_trees_options(klass, old_tree, new_tree, to_file,
816
928
                           path_encoding, external_diff_options, old_label,
817
 
                           new_label, using):
 
929
                           new_label, using, context_lines):
818
930
        """Factory for producing a DiffTree.
819
931
 
820
932
        Designed to accept options used by show_diff_trees.
 
933
 
821
934
        :param old_tree: The tree to show as old in the comparison
822
935
        :param new_tree: The tree to show as new in the comparison
823
936
        :param to_file: File to write comparisons to
829
942
        :param using: Commandline to use to invoke an external diff tool
830
943
        """
831
944
        if using is not None:
832
 
            extra_factories = [DiffFromTool.make_from_diff_tree(using)]
 
945
            extra_factories = [DiffFromTool.make_from_diff_tree(using, external_diff_options)]
833
946
        else:
834
947
            extra_factories = []
835
948
        if external_diff_options:
836
949
            opts = external_diff_options.split()
837
 
            def diff_file(olab, olines, nlab, nlines, to_file):
 
950
            def diff_file(olab, olines, nlab, nlines, to_file, path_encoding=None, context_lines=None):
 
951
                """:param path_encoding: not used but required
 
952
                        to match the signature of internal_diff.
 
953
                """
838
954
                external_diff(olab, olines, nlab, nlines, to_file, opts)
839
955
        else:
840
956
            diff_file = internal_diff
841
957
        diff_text = DiffText(old_tree, new_tree, to_file, path_encoding,
842
 
                             old_label, new_label, diff_file)
 
958
                             old_label, new_label, diff_file, context_lines=context_lines)
843
959
        return klass(old_tree, new_tree, to_file, path_encoding, diff_text,
844
960
                     extra_factories)
845
961
 
846
962
    def show_diff(self, specific_files, extra_trees=None):
847
963
        """Write tree diff to self.to_file
848
964
 
849
 
        :param sepecific_files: the specific files to compare (recursive)
 
965
        :param specific_files: the specific files to compare (recursive)
850
966
        :param extra_trees: extra trees to use for mapping paths to file_ids
851
967
        """
852
968
        try:
910
1026
                self.to_file.write("=== modified %s '%s'%s\n" % (kind[0],
911
1027
                                   newpath_encoded, prop_str))
912
1028
            if changed_content:
913
 
                self.diff(file_id, oldpath, newpath)
 
1029
                self._diff(file_id, oldpath, newpath, kind[0], kind[1])
914
1030
                has_changes = 1
915
1031
            if renamed:
916
1032
                has_changes = 1
931
1047
            new_kind = self.new_tree.kind(file_id)
932
1048
        except (errors.NoSuchId, errors.NoSuchFile):
933
1049
            new_kind = None
934
 
 
 
1050
        self._diff(file_id, old_path, new_path, old_kind, new_kind)
 
1051
 
 
1052
 
 
1053
    def _diff(self, file_id, old_path, new_path, old_kind, new_kind):
935
1054
        result = DiffPath._diff_many(self.differs, file_id, old_path,
936
1055
                                       new_path, old_kind, new_kind)
937
1056
        if result is DiffPath.CANNOT_DIFF:
939
1058
            if error_path is None:
940
1059
                error_path = old_path
941
1060
            raise errors.NoDiffFound(error_path)
 
1061
 
 
1062
 
 
1063
format_registry = Registry()
 
1064
format_registry.register('default', DiffTree)