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