/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/diff.py

  • Committer: Jelmer Vernooij
  • Date: 2009-02-25 14:36:59 UTC
  • mfrom: (4048 +trunk)
  • mto: This revision was merged to the branch mainline in revision 4049.
  • Revision ID: jelmer@samba.org-20090225143659-vx6cbqtmyicuzfyf
Merge bzr.dev.

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