/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

  • Committer: Alexander Belchenko
  • Date: 2010-04-30 07:54:33 UTC
  • mto: This revision was merged to the branch mainline in revision 5196.
  • Revision ID: bialix@ukr.net-20100430075433-w19uwxoo2vds3mdt
rewrited docstring for tree_ignores_add_patterns function to reflect the reality. also changed literal .bzrignore to bzrlib.IGNORE_FILENAME to keep consistency within that function.

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