← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/diff.py

  • Committer: John Arbash Meinel
  • Date: 2006-06-10 14:53:51 UTC
  • mto: (1711.7.2 win32)
  • mto: This revision was merged to the branch mainline in revision 1796.
  • Revision ID: john@arbash-meinel.com-20060610145351-9da0c1f8ba8a57e0
the _posix_* routines should use posixpath not os.path, so tests pass on win32

Show diffs side-by-side

added added

removed removed

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