/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/diff.py

Merge the bulg of the fix for 320119 and fix NEWS entrieS

Show diffs side-by-side

added added

removed removed

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