/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: Andrew Bennetts
  • Date: 2008-09-08 13:35:44 UTC
  • mto: This revision was merged to the branch mainline in revision 3756.
  • Revision ID: andrew.bennetts@canonical.com-20080908133544-jqm4r8fw0o6pafn3
Remove or lazyify a couple more imports.

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
    )
 
40
""")
 
41
 
 
42
from bzrlib.symbol_versioning import (
 
43
        deprecated_function,
 
44
        one_three
 
45
        )
 
46
from bzrlib.trace import 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
41
78
    # both sequences are empty.
42
79
    if not oldlines and not newlines:
43
80
        return
44
 
 
45
 
    ud = difflib.unified_diff(oldlines, newlines,
46
 
                              fromfile=old_label, tofile=new_label)
47
 
 
 
81
    
 
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')
 
102
    # work around for difflib emitting random spaces after the label
 
103
    ud[0] = ud[0][:-2] + '\n'
 
104
    ud[1] = ud[1][:-2] + '\n'
56
105
 
57
106
    for line in ud:
58
107
        to_file.write(line)
59
108
        if not line.endswith('\n'):
60
109
            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,
 
110
    to_file.write('\n')
 
111
 
 
112
 
 
113
def _spawn_external_diff(diffcmd, capture_errors=True):
 
114
    """Spawn the externall diff process, and return the child handle.
 
115
 
 
116
    :param diffcmd: The command list to spawn
 
117
    :param capture_errors: Capture stderr as well as setting LANG=C
 
118
        and LC_ALL=C. This lets us read and understand the output of diff,
 
119
        and respond to any errors.
 
120
    :return: A Popen object.
 
121
    """
 
122
    if capture_errors:
 
123
        # construct minimal environment
 
124
        env = {}
 
125
        path = os.environ.get('PATH')
 
126
        if path is not None:
 
127
            env['PATH'] = path
 
128
        env['LANGUAGE'] = 'C'   # on win32 only LANGUAGE has effect
 
129
        env['LANG'] = 'C'
 
130
        env['LC_ALL'] = 'C'
 
131
        stderr = subprocess.PIPE
 
132
    else:
 
133
        env = None
 
134
        stderr = None
 
135
 
 
136
    try:
 
137
        pipe = subprocess.Popen(diffcmd,
 
138
                                stdin=subprocess.PIPE,
 
139
                                stdout=subprocess.PIPE,
 
140
                                stderr=stderr,
 
141
                                env=env)
 
142
    except OSError, e:
 
143
        if e.errno == errno.ENOENT:
 
144
            raise errors.NoDiff(str(e))
 
145
        raise
 
146
 
 
147
    return pipe
 
148
 
 
149
 
 
150
def external_diff(old_filename, oldlines, new_filename, newlines, to_file,
67
151
                  diff_opts):
68
152
    """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
153
    # make sure our own output is properly ordered before the diff
76
154
    to_file.flush()
77
155
 
78
 
    from tempfile import NamedTemporaryFile
79
 
    import os
80
 
 
81
 
    oldtmpf = NamedTemporaryFile()
82
 
    newtmpf = NamedTemporaryFile()
 
156
    oldtmp_fd, old_abspath = tempfile.mkstemp(prefix='bzr-diff-old-')
 
157
    newtmp_fd, new_abspath = tempfile.mkstemp(prefix='bzr-diff-new-')
 
158
    oldtmpf = os.fdopen(oldtmp_fd, 'wb')
 
159
    newtmpf = os.fdopen(newtmp_fd, 'wb')
83
160
 
84
161
    try:
85
162
        # TODO: perhaps a special case for comparing to or from the empty
92
169
        oldtmpf.writelines(oldlines)
93
170
        newtmpf.writelines(newlines)
94
171
 
95
 
        oldtmpf.flush()
96
 
        newtmpf.flush()
 
172
        oldtmpf.close()
 
173
        newtmpf.close()
97
174
 
98
175
        if not diff_opts:
99
176
            diff_opts = []
100
177
        diffcmd = ['diff',
101
 
                   '--label', old_label,
102
 
                   oldtmpf.name,
103
 
                   '--label', new_label,
104
 
                   newtmpf.name]
 
178
                   '--label', old_filename,
 
179
                   old_abspath,
 
180
                   '--label', new_filename,
 
181
                   new_abspath,
 
182
                   '--binary',
 
183
                  ]
105
184
 
106
185
        # diff only allows one style to be specified; they don't override.
107
186
        # note that some of these take optargs, and the optargs can be
127
206
        if diff_opts:
128
207
            diffcmd.extend(diff_opts)
129
208
 
130
 
        rc = os.spawnvp(os.P_WAIT, 'diff', diffcmd)
 
209
        pipe = _spawn_external_diff(diffcmd, capture_errors=True)
 
210
        out,err = pipe.communicate()
 
211
        rc = pipe.returncode
131
212
        
132
 
        if rc != 0 and rc != 1:
 
213
        # internal_diff() adds a trailing newline, add one here for consistency
 
214
        out += '\n'
 
215
        if rc == 2:
 
216
            # 'diff' gives retcode == 2 for all sorts of errors
 
217
            # one of those is 'Binary files differ'.
 
218
            # Bad options could also be the problem.
 
219
            # 'Binary files' is not a real error, so we suppress that error.
 
220
            lang_c_out = out
 
221
 
 
222
            # Since we got here, we want to make sure to give an i18n error
 
223
            pipe = _spawn_external_diff(diffcmd, capture_errors=False)
 
224
            out, err = pipe.communicate()
 
225
 
 
226
            # Write out the new i18n diff response
 
227
            to_file.write(out+'\n')
 
228
            if pipe.returncode != 2:
 
229
                raise errors.BzrError(
 
230
                               'external diff failed with exit code 2'
 
231
                               ' when run with LANG=C and LC_ALL=C,'
 
232
                               ' but not when run natively: %r' % (diffcmd,))
 
233
 
 
234
            first_line = lang_c_out.split('\n', 1)[0]
 
235
            # Starting with diffutils 2.8.4 the word "binary" was dropped.
 
236
            m = re.match('^(binary )?files.*differ$', first_line, re.I)
 
237
            if m is None:
 
238
                raise errors.BzrError('external diff failed with exit code 2;'
 
239
                                      ' command: %r' % (diffcmd,))
 
240
            else:
 
241
                # Binary files differ, just return
 
242
                return
 
243
 
 
244
        # If we got to here, we haven't written out the output of diff
 
245
        # do so now
 
246
        to_file.write(out)
 
247
        if rc not in (0, 1):
133
248
            # returns 1 if files differ; that's OK
134
249
            if rc < 0:
135
250
                msg = 'signal %d' % (-rc)
136
251
            else:
137
252
                msg = 'exit code %d' % rc
138
253
                
139
 
            raise BzrError('external diff failed with %s; command: %r' % (rc, diffcmd))
 
254
            raise errors.BzrError('external diff failed with %s; command: %r' 
 
255
                                  % (rc, diffcmd))
 
256
 
 
257
 
140
258
    finally:
141
259
        oldtmpf.close()                 # and delete
142
260
        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.
 
261
        # Clean up. Warn in case the files couldn't be deleted
 
262
        # (in case windows still holds the file open, but not
 
263
        # if the files have already been deleted)
 
264
        try:
 
265
            os.remove(old_abspath)
 
266
        except OSError, e:
 
267
            if e.errno not in (errno.ENOENT,):
 
268
                warning('Failed to delete temporary file: %s %s',
 
269
                        old_abspath, e)
 
270
        try:
 
271
            os.remove(new_abspath)
 
272
        except OSError:
 
273
            if e.errno not in (errno.ENOENT,):
 
274
                warning('Failed to delete temporary file: %s %s',
 
275
                        new_abspath, e)
 
276
 
 
277
 
 
278
def _get_trees_to_diff(path_list, revision_specs, old_url, new_url):
 
279
    """Get the trees and specific files to diff given a list of paths.
 
280
 
 
281
    This method works out the trees to be diff'ed and the files of
 
282
    interest within those trees.
 
283
 
 
284
    :param path_list:
 
285
        the list of arguments passed to the diff command
 
286
    :param revision_specs:
 
287
        Zero, one or two RevisionSpecs from the diff command line,
 
288
        saying what revisions to compare.
 
289
    :param old_url:
 
290
        The url of the old branch or tree. If None, the tree to use is
 
291
        taken from the first path, if any, or the current working tree.
 
292
    :param new_url:
 
293
        The url of the new branch or tree. If None, the tree to use is
 
294
        taken from the first path, if any, or the current working tree.
 
295
    :returns:
 
296
        a tuple of (old_tree, new_tree, specific_files, extra_trees) where
 
297
        extra_trees is a sequence of additional trees to search in for
 
298
        file-ids.
157
299
    """
158
 
    import sys
 
300
    # Get the old and new revision specs
 
301
    old_revision_spec = None
 
302
    new_revision_spec = None
 
303
    if revision_specs is not None:
 
304
        if len(revision_specs) > 0:
 
305
            old_revision_spec = revision_specs[0]
 
306
            if old_url is None:
 
307
                old_url = old_revision_spec.get_branch()
 
308
        if len(revision_specs) > 1:
 
309
            new_revision_spec = revision_specs[1]
 
310
            if new_url is None:
 
311
                new_url = new_revision_spec.get_branch()
159
312
 
160
 
    if revision == None:
161
 
        old_tree = b.basis_tree()
 
313
    other_paths = []
 
314
    make_paths_wt_relative = True
 
315
    consider_relpath = True
 
316
    if path_list is None or len(path_list) == 0:
 
317
        # If no path is given, the current working tree is used
 
318
        default_location = u'.'
 
319
        consider_relpath = False
 
320
    elif old_url is not None and new_url is not None:
 
321
        other_paths = path_list
 
322
        make_paths_wt_relative = False
162
323
    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
 
 
 
324
        default_location = path_list[0]
 
325
        other_paths = path_list[1:]
 
326
 
 
327
    # Get the old location
 
328
    specific_files = []
 
329
    if old_url is None:
 
330
        old_url = default_location
 
331
    working_tree, branch, relpath = \
 
332
        bzrdir.BzrDir.open_containing_tree_or_branch(old_url)
 
333
    if consider_relpath and relpath != '':
 
334
        specific_files.append(relpath)
 
335
    old_tree = _get_tree_to_diff(old_revision_spec, working_tree, branch)
 
336
 
 
337
    # Get the new location
 
338
    if new_url is None:
 
339
        new_url = default_location
 
340
    if new_url != old_url:
 
341
        working_tree, branch, relpath = \
 
342
            bzrdir.BzrDir.open_containing_tree_or_branch(new_url)
 
343
        if consider_relpath and relpath != '':
 
344
            specific_files.append(relpath)
 
345
    new_tree = _get_tree_to_diff(new_revision_spec, working_tree, branch,
 
346
        basis_is_default=working_tree is None)
 
347
 
 
348
    # Get the specific files (all files is None, no files is [])
 
349
    if make_paths_wt_relative and working_tree is not None:
 
350
        other_paths = _relative_paths_in_tree(working_tree, other_paths)
 
351
    specific_files.extend(other_paths)
 
352
    if len(specific_files) == 0:
 
353
        specific_files = None
 
354
 
 
355
    # Get extra trees that ought to be searched for file-ids
 
356
    extra_trees = None
 
357
    if working_tree is not None and working_tree not in (old_tree, new_tree):
 
358
        extra_trees = (working_tree,)
 
359
    return old_tree, new_tree, specific_files, extra_trees
 
360
 
 
361
 
 
362
def _get_tree_to_diff(spec, tree=None, branch=None, basis_is_default=True):
 
363
    if branch is None and tree is not None:
 
364
        branch = tree.branch
 
365
    if spec is None or spec.spec is None:
 
366
        if basis_is_default:
 
367
            if tree is not None:
 
368
                return tree.basis_tree()
 
369
            else:
 
370
                return branch.basis_tree()
 
371
        else:
 
372
            return tree
 
373
    if not spec.needs_branch():
 
374
        branch = _mod_branch.Branch.open(spec.get_branch())
 
375
    revision_id = spec.as_revision_id(branch)
 
376
    return branch.repository.revision_tree(revision_id)
 
377
 
 
378
 
 
379
def _relative_paths_in_tree(tree, paths):
 
380
    """Get the relative paths within a working tree.
 
381
 
 
382
    Each path may be either an absolute path or a path relative to the
 
383
    current working directory.
 
384
    """
 
385
    result = []
 
386
    for filename in paths:
 
387
        try:
 
388
            result.append(tree.relpath(osutils.dereference_path(filename)))
 
389
        except errors.PathNotChild:
 
390
            raise errors.BzrCommandError("Files are in different branches")
 
391
    return result
170
392
 
171
393
 
172
394
def show_diff_trees(old_tree, new_tree, to_file, specific_files=None,
173
 
                    external_diff_options=None):
 
395
                    external_diff_options=None,
 
396
                    old_label='a/', new_label='b/',
 
397
                    extra_trees=None,
 
398
                    path_encoding='utf8',
 
399
                    using=None):
174
400
    """Show in text form the changes from one tree to another.
175
401
 
176
 
    to_files
177
 
        If set, include only changes to these files.
 
402
    to_file
 
403
        The output stream.
 
404
 
 
405
    specific_files
 
406
        Include only changes to these files - None for all changes.
178
407
 
179
408
    external_diff_options
180
409
        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
 
 
 
410
 
 
411
    extra_trees
 
412
        If set, more Trees to use for looking up file ids
 
413
 
 
414
    path_encoding
 
415
        If set, the path will be encoded as specified, otherwise is supposed
 
416
        to be utf8
 
417
    """
 
418
    old_tree.lock_read()
 
419
    try:
 
420
        if extra_trees is not None:
 
421
            for tree in extra_trees:
 
422
                tree.lock_read()
 
423
        new_tree.lock_read()
 
424
        try:
 
425
            differ = DiffTree.from_trees_options(old_tree, new_tree, to_file,
 
426
                                                 path_encoding,
 
427
                                                 external_diff_options,
 
428
                                                 old_label, new_label, using)
 
429
            return differ.show_diff(specific_files, extra_trees)
 
430
        finally:
 
431
            new_tree.unlock()
 
432
            if extra_trees is not None:
 
433
                for tree in extra_trees:
 
434
                    tree.unlock()
 
435
    finally:
 
436
        old_tree.unlock()
 
437
 
 
438
 
 
439
def _patch_header_date(tree, file_id, path):
 
440
    """Returns a timestamp suitable for use in a patch header."""
 
441
    mtime = tree.get_file_mtime(file_id, path)
 
442
    return timestamp.format_patch_date(mtime)
 
443
 
 
444
 
 
445
@deprecated_function(one_three)
 
446
def get_prop_change(meta_modified):
 
447
    if meta_modified:
 
448
        return " (properties changed)"
 
449
    else:
 
450
        return  ""
 
451
 
 
452
def get_executable_change(old_is_x, new_is_x):
 
453
    descr = { True:"+x", False:"-x", None:"??" }
 
454
    if old_is_x != new_is_x:
 
455
        return ["%s to %s" % (descr[old_is_x], descr[new_is_x],)]
 
456
    else:
 
457
        return []
 
458
 
 
459
 
 
460
class DiffPath(object):
 
461
    """Base type for command object that compare files"""
 
462
 
 
463
    # The type or contents of the file were unsuitable for diffing
 
464
    CANNOT_DIFF = 'CANNOT_DIFF'
 
465
    # The file has changed in a semantic way
 
466
    CHANGED = 'CHANGED'
 
467
    # The file content may have changed, but there is no semantic change
 
468
    UNCHANGED = 'UNCHANGED'
 
469
 
 
470
    def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8'):
 
471
        """Constructor.
 
472
 
 
473
        :param old_tree: The tree to show as the old tree in the comparison
 
474
        :param new_tree: The tree to show as new in the comparison
 
475
        :param to_file: The file to write comparison data to
 
476
        :param path_encoding: The character encoding to write paths in
 
477
        """
 
478
        self.old_tree = old_tree
 
479
        self.new_tree = new_tree
 
480
        self.to_file = to_file
 
481
        self.path_encoding = path_encoding
 
482
 
 
483
    def finish(self):
 
484
        pass
 
485
 
 
486
    @classmethod
 
487
    def from_diff_tree(klass, diff_tree):
 
488
        return klass(diff_tree.old_tree, diff_tree.new_tree,
 
489
                     diff_tree.to_file, diff_tree.path_encoding)
 
490
 
 
491
    @staticmethod
 
492
    def _diff_many(differs, file_id, old_path, new_path, old_kind, new_kind):
 
493
        for file_differ in differs:
 
494
            result = file_differ.diff(file_id, old_path, new_path, old_kind,
 
495
                                      new_kind)
 
496
            if result is not DiffPath.CANNOT_DIFF:
 
497
                return result
 
498
        else:
 
499
            return DiffPath.CANNOT_DIFF
 
500
 
 
501
 
 
502
class DiffKindChange(object):
 
503
    """Special differ for file kind changes.
 
504
 
 
505
    Represents kind change as deletion + creation.  Uses the other differs
 
506
    to do this.
 
507
    """
 
508
    def __init__(self, differs):
 
509
        self.differs = differs
 
510
 
 
511
    def finish(self):
 
512
        pass
 
513
 
 
514
    @classmethod
 
515
    def from_diff_tree(klass, diff_tree):
 
516
        return klass(diff_tree.differs)
 
517
 
 
518
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
 
519
        """Perform comparison
 
520
 
 
521
        :param file_id: The file_id of the file to compare
 
522
        :param old_path: Path of the file in the old tree
 
523
        :param new_path: Path of the file in the new tree
 
524
        :param old_kind: Old file-kind of the file
 
525
        :param new_kind: New file-kind of the file
 
526
        """
 
527
        if None in (old_kind, new_kind):
 
528
            return DiffPath.CANNOT_DIFF
 
529
        result = DiffPath._diff_many(self.differs, file_id, old_path,
 
530
                                       new_path, old_kind, None)
 
531
        if result is DiffPath.CANNOT_DIFF:
 
532
            return result
 
533
        return DiffPath._diff_many(self.differs, file_id, old_path, new_path,
 
534
                                     None, new_kind)
 
535
 
 
536
 
 
537
class DiffDirectory(DiffPath):
 
538
 
 
539
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
 
540
        """Perform comparison between two directories.  (dummy)
 
541
 
 
542
        """
 
543
        if 'directory' not in (old_kind, new_kind):
 
544
            return self.CANNOT_DIFF
 
545
        if old_kind not in ('directory', None):
 
546
            return self.CANNOT_DIFF
 
547
        if new_kind not in ('directory', None):
 
548
            return self.CANNOT_DIFF
 
549
        return self.CHANGED
 
550
 
 
551
 
 
552
class DiffSymlink(DiffPath):
 
553
 
 
554
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
 
555
        """Perform comparison between two symlinks
 
556
 
 
557
        :param file_id: The file_id of the file to compare
 
558
        :param old_path: Path of the file in the old tree
 
559
        :param new_path: Path of the file in the new tree
 
560
        :param old_kind: Old file-kind of the file
 
561
        :param new_kind: New file-kind of the file
 
562
        """
 
563
        if 'symlink' not in (old_kind, new_kind):
 
564
            return self.CANNOT_DIFF
 
565
        if old_kind == 'symlink':
 
566
            old_target = self.old_tree.get_symlink_target(file_id)
 
567
        elif old_kind is None:
 
568
            old_target = None
 
569
        else:
 
570
            return self.CANNOT_DIFF
 
571
        if new_kind == 'symlink':
 
572
            new_target = self.new_tree.get_symlink_target(file_id)
 
573
        elif new_kind is None:
 
574
            new_target = None
 
575
        else:
 
576
            return self.CANNOT_DIFF
 
577
        return self.diff_symlink(old_target, new_target)
 
578
 
 
579
    def diff_symlink(self, old_target, new_target):
 
580
        if old_target is None:
 
581
            self.to_file.write('=== target is %r\n' % new_target)
 
582
        elif new_target is None:
 
583
            self.to_file.write('=== target was %r\n' % old_target)
 
584
        else:
 
585
            self.to_file.write('=== target changed %r => %r\n' %
 
586
                              (old_target, new_target))
 
587
        return self.CHANGED
 
588
 
 
589
 
 
590
class DiffText(DiffPath):
 
591
 
 
592
    # GNU Patch uses the epoch date to detect files that are being added
 
593
    # or removed in a diff.
 
594
    EPOCH_DATE = '1970-01-01 00:00:00 +0000'
 
595
 
 
596
    def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8',
 
597
                 old_label='', new_label='', text_differ=internal_diff):
 
598
        DiffPath.__init__(self, old_tree, new_tree, to_file, path_encoding)
 
599
        self.text_differ = text_differ
 
600
        self.old_label = old_label
 
601
        self.new_label = new_label
 
602
        self.path_encoding = path_encoding
 
603
 
 
604
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
 
605
        """Compare two files in unified diff format
 
606
 
 
607
        :param file_id: The file_id of the file to compare
 
608
        :param old_path: Path of the file in the old tree
 
609
        :param new_path: Path of the file in the new tree
 
610
        :param old_kind: Old file-kind of the file
 
611
        :param new_kind: New file-kind of the file
 
612
        """
 
613
        if 'file' not in (old_kind, new_kind):
 
614
            return self.CANNOT_DIFF
 
615
        from_file_id = to_file_id = file_id
 
616
        if old_kind == 'file':
 
617
            old_date = _patch_header_date(self.old_tree, file_id, old_path)
 
618
        elif old_kind is None:
 
619
            old_date = self.EPOCH_DATE
 
620
            from_file_id = None
 
621
        else:
 
622
            return self.CANNOT_DIFF
 
623
        if new_kind == 'file':
 
624
            new_date = _patch_header_date(self.new_tree, file_id, new_path)
 
625
        elif new_kind is None:
 
626
            new_date = self.EPOCH_DATE
 
627
            to_file_id = None
 
628
        else:
 
629
            return self.CANNOT_DIFF
 
630
        from_label = '%s%s\t%s' % (self.old_label, old_path, old_date)
 
631
        to_label = '%s%s\t%s' % (self.new_label, new_path, new_date)
 
632
        return self.diff_text(from_file_id, to_file_id, from_label, to_label)
 
633
 
 
634
    def diff_text(self, from_file_id, to_file_id, from_label, to_label):
 
635
        """Diff the content of given files in two trees
 
636
 
 
637
        :param from_file_id: The id of the file in the from tree.  If None,
 
638
            the file is not present in the from tree.
 
639
        :param to_file_id: The id of the file in the to tree.  This may refer
 
640
            to a different file from from_file_id.  If None,
 
641
            the file is not present in the to tree.
 
642
        """
 
643
        def _get_text(tree, file_id):
 
644
            if file_id is not None:
 
645
                return tree.get_file(file_id).readlines()
 
646
            else:
 
647
                return []
 
648
        try:
 
649
            from_text = _get_text(self.old_tree, from_file_id)
 
650
            to_text = _get_text(self.new_tree, to_file_id)
 
651
            self.text_differ(from_label, from_text, to_label, to_text,
 
652
                             self.to_file)
 
653
        except errors.BinaryFile:
 
654
            self.to_file.write(
 
655
                  ("Binary files %s and %s differ\n" %
 
656
                  (from_label, to_label)).encode(self.path_encoding))
 
657
        return self.CHANGED
 
658
 
 
659
 
 
660
class DiffFromTool(DiffPath):
 
661
 
 
662
    def __init__(self, command_template, old_tree, new_tree, to_file,
 
663
                 path_encoding='utf-8'):
 
664
        DiffPath.__init__(self, old_tree, new_tree, to_file, path_encoding)
 
665
        self.command_template = command_template
 
666
        self._root = osutils.mkdtemp(prefix='bzr-diff-')
 
667
 
 
668
    @classmethod
 
669
    def from_string(klass, command_string, old_tree, new_tree, to_file,
 
670
                    path_encoding='utf-8'):
 
671
        command_template = commands.shlex_split_unicode(command_string)
 
672
        command_template.extend(['%(old_path)s', '%(new_path)s'])
 
673
        return klass(command_template, old_tree, new_tree, to_file,
 
674
                     path_encoding)
 
675
 
 
676
    @classmethod
 
677
    def make_from_diff_tree(klass, command_string):
 
678
        def from_diff_tree(diff_tree):
 
679
            return klass.from_string(command_string, diff_tree.old_tree,
 
680
                                     diff_tree.new_tree, diff_tree.to_file)
 
681
        return from_diff_tree
 
682
 
 
683
    def _get_command(self, old_path, new_path):
 
684
        my_map = {'old_path': old_path, 'new_path': new_path}
 
685
        return [t % my_map for t in self.command_template]
 
686
 
 
687
    def _execute(self, old_path, new_path):
 
688
        command = self._get_command(old_path, new_path)
 
689
        try:
 
690
            proc = subprocess.Popen(command, stdout=subprocess.PIPE,
 
691
                                    cwd=self._root)
 
692
        except OSError, e:
 
693
            if e.errno == errno.ENOENT:
 
694
                raise errors.ExecutableMissing(command[0])
 
695
            else:
 
696
                raise
 
697
        self.to_file.write(proc.stdout.read())
 
698
        return proc.wait()
 
699
 
 
700
    def _try_symlink_root(self, tree, prefix):
 
701
        if (getattr(tree, 'abspath', None) is None
 
702
            or not osutils.host_os_dereferences_symlinks()):
 
703
            return False
 
704
        try:
 
705
            os.symlink(tree.abspath(''), osutils.pathjoin(self._root, prefix))
 
706
        except OSError, e:
 
707
            if e.errno != errno.EEXIST:
 
708
                raise
 
709
        return True
 
710
 
 
711
    def _write_file(self, file_id, tree, prefix, relpath):
 
712
        full_path = osutils.pathjoin(self._root, prefix, relpath)
 
713
        if self._try_symlink_root(tree, prefix):
 
714
            return full_path
 
715
        parent_dir = osutils.dirname(full_path)
 
716
        try:
 
717
            os.makedirs(parent_dir)
 
718
        except OSError, e:
 
719
            if e.errno != errno.EEXIST:
 
720
                raise
 
721
        source = tree.get_file(file_id, relpath)
 
722
        try:
 
723
            target = open(full_path, 'wb')
 
724
            try:
 
725
                osutils.pumpfile(source, target)
 
726
            finally:
 
727
                target.close()
 
728
        finally:
 
729
            source.close()
 
730
        osutils.make_readonly(full_path)
 
731
        mtime = tree.get_file_mtime(file_id)
 
732
        os.utime(full_path, (mtime, mtime))
 
733
        return full_path
 
734
 
 
735
    def _prepare_files(self, file_id, old_path, new_path):
 
736
        old_disk_path = self._write_file(file_id, self.old_tree, 'old',
 
737
                                         old_path)
 
738
        new_disk_path = self._write_file(file_id, self.new_tree, 'new',
 
739
                                         new_path)
 
740
        return old_disk_path, new_disk_path
 
741
 
 
742
    def finish(self):
 
743
        osutils.rmtree(self._root)
 
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)
 
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
 
 
916
        result = DiffPath._diff_many(self.differs, file_id, old_path,
 
917
                                       new_path, old_kind, new_kind)
 
918
        if result is DiffPath.CANNOT_DIFF:
 
919
            error_path = new_path
 
920
            if error_path is None:
 
921
                error_path = old_path
 
922
            raise errors.NoDiffFound(error_path)