/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: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

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