← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/diff.py

  • Committer: Martin Pool
  • Date: 2009-06-19 06:21:13 UTC
  • mto: This revision was merged to the branch mainline in revision 4558.
  • Revision ID: mbp@sourcefrog.net-20090619062113-019bp0a3bl2y4nkx
Un-soft-deprecate _supports_progress - still useful

Show diffs side-by-side

added added

removed removed

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