← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/diff.py

Update test support, and remove deprecated functions pullable_revisions and get_intervening_revisions.

Show diffs side-by-side

added added

removed removed

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