/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

Only chown() the .bzr.log when creating it, fixing NEWS entry to put it under 2.2b3

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