← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/diff.py

  • Committer: Aaron Bentley
  • Date: 2006-06-14 19:45:57 UTC
  • mto: This revision was merged to the branch mainline in revision 1777.
  • Revision ID: abentley@panoramicfeedback.com-20060614194557-6b499aa1cf03f7e6
Use create_signature for signing policy, deprecate check_signatures for this

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
17
import time
29
18
 
30
 
from bzrlib import (
31
 
    branch as _mod_branch,
32
 
    bzrdir,
33
 
    commands,
34
 
    errors,
35
 
    osutils,
36
 
    patiencediff,
37
 
    textfile,
38
 
    timestamp,
39
 
    )
40
 
""")
41
 
 
42
 
from bzrlib.symbol_versioning import (
43
 
        deprecated_function,
44
 
        one_three
45
 
        )
46
 
from bzrlib.trace import warning
 
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
47
27
 
48
28
 
49
29
# TODO: Rather than building a changeset object, we should probably
50
30
# invoke callbacks on an object.  That object can either accumulate a
51
31
# list, write them out directly, etc etc.
52
32
 
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
33
def internal_diff(old_filename, oldlines, new_filename, newlines, to_file,
64
34
                  allow_binary=False, sequence_matcher=None,
65
35
                  path_encoding='utf8'):
80
50
        return
81
51
    
82
52
    if allow_binary is False:
83
 
        textfile.check_text_lines(oldlines)
84
 
        textfile.check_text_lines(newlines)
 
53
        check_text_lines(oldlines)
 
54
        check_text_lines(newlines)
85
55
 
86
56
    if sequence_matcher is None:
87
 
        sequence_matcher = patiencediff.PatienceSequenceMatcher
88
 
    ud = patiencediff.unified_diff(oldlines, newlines,
 
57
        sequence_matcher = bzrlib.patiencediff.PatienceSequenceMatcher
 
58
    ud = unified_diff(oldlines, newlines,
89
59
                      fromfile=old_filename.encode(path_encoding),
90
60
                      tofile=new_filename.encode(path_encoding),
91
61
                      sequencematcher=sequence_matcher)
92
62
 
93
63
    ud = list(ud)
94
 
    if len(ud) == 0: # Identical contents, nothing to do
95
 
        return
96
64
    # work-around for difflib being too smart for its own good
97
65
    # if /dev/null is "1,0", patch won't recognize it as /dev/null
98
66
    if not oldlines:
107
75
        to_file.write(line)
108
76
        if not line.endswith('\n'):
109
77
            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
 
78
    print >>to_file
148
79
 
149
80
 
150
81
def external_diff(old_filename, oldlines, new_filename, newlines, to_file,
151
82
                  diff_opts):
152
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
 
153
90
    # make sure our own output is properly ordered before the diff
154
91
    to_file.flush()
155
92
 
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')
 
93
    from tempfile import NamedTemporaryFile
 
94
    import os
 
95
 
 
96
    oldtmpf = NamedTemporaryFile()
 
97
    newtmpf = NamedTemporaryFile()
160
98
 
161
99
    try:
162
100
        # TODO: perhaps a special case for comparing to or from the empty
169
107
        oldtmpf.writelines(oldlines)
170
108
        newtmpf.writelines(newlines)
171
109
 
172
 
        oldtmpf.close()
173
 
        newtmpf.close()
 
110
        oldtmpf.flush()
 
111
        newtmpf.flush()
174
112
 
175
113
        if not diff_opts:
176
114
            diff_opts = []
177
115
        diffcmd = ['diff',
178
116
                   '--label', old_filename,
179
 
                   old_abspath,
 
117
                   oldtmpf.name,
180
118
                   '--label', new_filename,
181
 
                   new_abspath,
182
 
                   '--binary',
183
 
                  ]
 
119
                   newtmpf.name]
184
120
 
185
121
        # diff only allows one style to be specified; they don't override.
186
122
        # note that some of these take optargs, and the optargs can be
206
142
        if diff_opts:
207
143
            diffcmd.extend(diff_opts)
208
144
 
209
 
        pipe = _spawn_external_diff(diffcmd, capture_errors=True)
210
 
        out,err = pipe.communicate()
211
 
        rc = pipe.returncode
 
145
        rc = os.spawnvp(os.P_WAIT, 'diff', diffcmd)
212
146
        
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):
 
147
        if rc != 0 and rc != 1:
248
148
            # returns 1 if files differ; that's OK
249
149
            if rc < 0:
250
150
                msg = 'signal %d' % (-rc)
251
151
            else:
252
152
                msg = 'exit code %d' % rc
253
153
                
254
 
            raise errors.BzrError('external diff failed with %s; command: %r' 
255
 
                                  % (rc, diffcmd))
256
 
 
257
 
 
 
154
            raise BzrError('external diff failed with %s; command: %r' % (rc, diffcmd))
258
155
    finally:
259
156
        oldtmpf.close()                 # and delete
260
157
        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.
 
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.
299
175
    """
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()
 
176
    if output is None:
 
177
        import sys
 
178
        output = sys.stdout
312
179
 
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
 
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()
323
184
    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()
 
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()
371
190
        else:
372
 
            return tree
373
 
    return spec.as_tree(branch)
374
 
 
375
 
 
376
 
def _relative_paths_in_tree(tree, paths):
377
 
    """Get the relative paths within a working tree.
378
 
 
379
 
    Each path may be either an absolute path or a path relative to the
380
 
    current working directory.
 
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.
381
223
    """
382
 
    result = []
383
 
    for filename in paths:
384
 
        try:
385
 
            result.append(tree.relpath(osutils.dereference_path(filename)))
386
 
        except errors.PathNotChild:
387
 
            raise errors.BzrCommandError("Files are in different branches")
388
 
    return result
 
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)
389
242
 
390
243
 
391
244
def show_diff_trees(old_tree, new_tree, to_file, specific_files=None,
392
245
                    external_diff_options=None,
393
 
                    old_label='a/', new_label='b/',
394
 
                    extra_trees=None,
395
 
                    path_encoding='utf8',
396
 
                    using=None):
 
246
                    old_label='a/', new_label='b/'):
397
247
    """Show in text form the changes from one tree to another.
398
248
 
399
 
    to_file
400
 
        The output stream.
401
 
 
402
 
    specific_files
403
 
        Include only changes to these files - None for all changes.
 
249
    to_files
 
250
        If set, include only changes to these files.
404
251
 
405
252
    external_diff_options
406
253
        If set, use an external GNU diff and pass these options.
407
 
 
408
 
    extra_trees
409
 
        If set, more Trees to use for looking up file ids
410
 
 
411
 
    path_encoding
412
 
        If set, the path will be encoded as specified, otherwise is supposed
413
 
        to be utf8
414
254
    """
415
255
    old_tree.lock_read()
416
256
    try:
417
 
        if extra_trees is not None:
418
 
            for tree in extra_trees:
419
 
                tree.lock_read()
420
257
        new_tree.lock_read()
421
258
        try:
422
 
            differ = DiffTree.from_trees_options(old_tree, new_tree, to_file,
423
 
                                                 path_encoding,
424
 
                                                 external_diff_options,
425
 
                                                 old_label, new_label, using)
426
 
            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)
427
262
        finally:
428
263
            new_tree.unlock()
429
 
            if extra_trees is not None:
430
 
                for tree in extra_trees:
431
 
                    tree.unlock()
432
264
    finally:
433
265
        old_tree.unlock()
434
266
 
435
267
 
 
268
def _show_diff_trees(old_tree, new_tree, to_file,
 
269
                     specific_files, external_diff_options, 
 
270
                     old_label='a/', new_label='b/' ):
 
271
 
 
272
    # GNU Patch uses the epoch date to detect files that are being added
 
273
    # or removed in a diff.
 
274
    EPOCH_DATE = '1970-01-01 00:00:00 +0000'
 
275
 
 
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
 
436
342
def _patch_header_date(tree, file_id, path):
437
343
    """Returns a timestamp suitable for use in a patch header."""
438
 
    mtime = tree.get_file_mtime(file_id, path)
439
 
    return timestamp.format_patch_date(mtime)
440
 
 
441
 
 
442
 
@deprecated_function(one_three)
 
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.
 
367
    """
 
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
 
443
378
def get_prop_change(meta_modified):
444
379
    if meta_modified:
445
380
        return " (properties changed)"
446
381
    else:
447
382
        return  ""
448
383
 
449
 
def get_executable_change(old_is_x, new_is_x):
450
 
    descr = { True:"+x", False:"-x", None:"??" }
451
 
    if old_is_x != new_is_x:
452
 
        return ["%s to %s" % (descr[old_is_x], descr[new_is_x],)]
453
 
    else:
454
 
        return []
455
 
 
456
 
 
457
 
class DiffPath(object):
458
 
    """Base type for command object that compare files"""
459
 
 
460
 
    # The type or contents of the file were unsuitable for diffing
461
 
    CANNOT_DIFF = 'CANNOT_DIFF'
462
 
    # The file has changed in a semantic way
463
 
    CHANGED = 'CHANGED'
464
 
    # The file content may have changed, but there is no semantic change
465
 
    UNCHANGED = 'UNCHANGED'
466
 
 
467
 
    def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8'):
468
 
        """Constructor.
469
 
 
470
 
        :param old_tree: The tree to show as the old tree in the comparison
471
 
        :param new_tree: The tree to show as new in the comparison
472
 
        :param to_file: The file to write comparison data to
473
 
        :param path_encoding: The character encoding to write paths in
474
 
        """
475
 
        self.old_tree = old_tree
476
 
        self.new_tree = new_tree
477
 
        self.to_file = to_file
478
 
        self.path_encoding = path_encoding
479
 
 
480
 
    def finish(self):
481
 
        pass
482
 
 
483
 
    @classmethod
484
 
    def from_diff_tree(klass, diff_tree):
485
 
        return klass(diff_tree.old_tree, diff_tree.new_tree,
486
 
                     diff_tree.to_file, diff_tree.path_encoding)
487
 
 
488
 
    @staticmethod
489
 
    def _diff_many(differs, file_id, old_path, new_path, old_kind, new_kind):
490
 
        for file_differ in differs:
491
 
            result = file_differ.diff(file_id, old_path, new_path, old_kind,
492
 
                                      new_kind)
493
 
            if result is not DiffPath.CANNOT_DIFF:
494
 
                return result
495
 
        else:
496
 
            return DiffPath.CANNOT_DIFF
497
 
 
498
 
 
499
 
class DiffKindChange(object):
500
 
    """Special differ for file kind changes.
501
 
 
502
 
    Represents kind change as deletion + creation.  Uses the other differs
503
 
    to do this.
504
 
    """
505
 
    def __init__(self, differs):
506
 
        self.differs = differs
507
 
 
508
 
    def finish(self):
509
 
        pass
510
 
 
511
 
    @classmethod
512
 
    def from_diff_tree(klass, diff_tree):
513
 
        return klass(diff_tree.differs)
514
 
 
515
 
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
516
 
        """Perform comparison
517
 
 
518
 
        :param file_id: The file_id of the file to compare
519
 
        :param old_path: Path of the file in the old tree
520
 
        :param new_path: Path of the file in the new tree
521
 
        :param old_kind: Old file-kind of the file
522
 
        :param new_kind: New file-kind of the file
523
 
        """
524
 
        if None in (old_kind, new_kind):
525
 
            return DiffPath.CANNOT_DIFF
526
 
        result = DiffPath._diff_many(self.differs, file_id, old_path,
527
 
                                       new_path, old_kind, None)
528
 
        if result is DiffPath.CANNOT_DIFF:
529
 
            return result
530
 
        return DiffPath._diff_many(self.differs, file_id, old_path, new_path,
531
 
                                     None, new_kind)
532
 
 
533
 
 
534
 
class DiffDirectory(DiffPath):
535
 
 
536
 
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
537
 
        """Perform comparison between two directories.  (dummy)
538
 
 
539
 
        """
540
 
        if 'directory' not in (old_kind, new_kind):
541
 
            return self.CANNOT_DIFF
542
 
        if old_kind not in ('directory', None):
543
 
            return self.CANNOT_DIFF
544
 
        if new_kind not in ('directory', None):
545
 
            return self.CANNOT_DIFF
546
 
        return self.CHANGED
547
 
 
548
 
 
549
 
class DiffSymlink(DiffPath):
550
 
 
551
 
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
552
 
        """Perform comparison between two symlinks
553
 
 
554
 
        :param file_id: The file_id of the file to compare
555
 
        :param old_path: Path of the file in the old tree
556
 
        :param new_path: Path of the file in the new tree
557
 
        :param old_kind: Old file-kind of the file
558
 
        :param new_kind: New file-kind of the file
559
 
        """
560
 
        if 'symlink' not in (old_kind, new_kind):
561
 
            return self.CANNOT_DIFF
562
 
        if old_kind == 'symlink':
563
 
            old_target = self.old_tree.get_symlink_target(file_id)
564
 
        elif old_kind is None:
565
 
            old_target = None
566
 
        else:
567
 
            return self.CANNOT_DIFF
568
 
        if new_kind == 'symlink':
569
 
            new_target = self.new_tree.get_symlink_target(file_id)
570
 
        elif new_kind is None:
571
 
            new_target = None
572
 
        else:
573
 
            return self.CANNOT_DIFF
574
 
        return self.diff_symlink(old_target, new_target)
575
 
 
576
 
    def diff_symlink(self, old_target, new_target):
577
 
        if old_target is None:
578
 
            self.to_file.write('=== target is %r\n' % new_target)
579
 
        elif new_target is None:
580
 
            self.to_file.write('=== target was %r\n' % old_target)
581
 
        else:
582
 
            self.to_file.write('=== target changed %r => %r\n' %
583
 
                              (old_target, new_target))
584
 
        return self.CHANGED
585
 
 
586
 
 
587
 
class DiffText(DiffPath):
588
 
 
589
 
    # GNU Patch uses the epoch date to detect files that are being added
590
 
    # or removed in a diff.
591
 
    EPOCH_DATE = '1970-01-01 00:00:00 +0000'
592
 
 
593
 
    def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8',
594
 
                 old_label='', new_label='', text_differ=internal_diff):
595
 
        DiffPath.__init__(self, old_tree, new_tree, to_file, path_encoding)
596
 
        self.text_differ = text_differ
597
 
        self.old_label = old_label
598
 
        self.new_label = new_label
599
 
        self.path_encoding = path_encoding
600
 
 
601
 
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
602
 
        """Compare two files in unified diff format
603
 
 
604
 
        :param file_id: The file_id of the file to compare
605
 
        :param old_path: Path of the file in the old tree
606
 
        :param new_path: Path of the file in the new tree
607
 
        :param old_kind: Old file-kind of the file
608
 
        :param new_kind: New file-kind of the file
609
 
        """
610
 
        if 'file' not in (old_kind, new_kind):
611
 
            return self.CANNOT_DIFF
612
 
        from_file_id = to_file_id = file_id
613
 
        if old_kind == 'file':
614
 
            old_date = _patch_header_date(self.old_tree, file_id, old_path)
615
 
        elif old_kind is None:
616
 
            old_date = self.EPOCH_DATE
617
 
            from_file_id = None
618
 
        else:
619
 
            return self.CANNOT_DIFF
620
 
        if new_kind == 'file':
621
 
            new_date = _patch_header_date(self.new_tree, file_id, new_path)
622
 
        elif new_kind is None:
623
 
            new_date = self.EPOCH_DATE
624
 
            to_file_id = None
625
 
        else:
626
 
            return self.CANNOT_DIFF
627
 
        from_label = '%s%s\t%s' % (self.old_label, old_path, old_date)
628
 
        to_label = '%s%s\t%s' % (self.new_label, new_path, new_date)
629
 
        return self.diff_text(from_file_id, to_file_id, from_label, to_label)
630
 
 
631
 
    def diff_text(self, from_file_id, to_file_id, from_label, to_label):
632
 
        """Diff the content of given files in two trees
633
 
 
634
 
        :param from_file_id: The id of the file in the from tree.  If None,
635
 
            the file is not present in the from tree.
636
 
        :param to_file_id: The id of the file in the to tree.  This may refer
637
 
            to a different file from from_file_id.  If None,
638
 
            the file is not present in the to tree.
639
 
        """
640
 
        def _get_text(tree, file_id):
641
 
            if file_id is not None:
642
 
                return tree.get_file(file_id).readlines()
643
 
            else:
644
 
                return []
645
 
        try:
646
 
            from_text = _get_text(self.old_tree, from_file_id)
647
 
            to_text = _get_text(self.new_tree, to_file_id)
648
 
            self.text_differ(from_label, from_text, to_label, to_text,
649
 
                             self.to_file)
650
 
        except errors.BinaryFile:
651
 
            self.to_file.write(
652
 
                  ("Binary files %s and %s differ\n" %
653
 
                  (from_label, to_label)).encode(self.path_encoding))
654
 
        return self.CHANGED
655
 
 
656
 
 
657
 
class DiffFromTool(DiffPath):
658
 
 
659
 
    def __init__(self, command_template, old_tree, new_tree, to_file,
660
 
                 path_encoding='utf-8'):
661
 
        DiffPath.__init__(self, old_tree, new_tree, to_file, path_encoding)
662
 
        self.command_template = command_template
663
 
        self._root = osutils.mkdtemp(prefix='bzr-diff-')
664
 
 
665
 
    @classmethod
666
 
    def from_string(klass, command_string, old_tree, new_tree, to_file,
667
 
                    path_encoding='utf-8'):
668
 
        command_template = commands.shlex_split_unicode(command_string)
669
 
        command_template.extend(['%(old_path)s', '%(new_path)s'])
670
 
        return klass(command_template, old_tree, new_tree, to_file,
671
 
                     path_encoding)
672
 
 
673
 
    @classmethod
674
 
    def make_from_diff_tree(klass, command_string):
675
 
        def from_diff_tree(diff_tree):
676
 
            return klass.from_string(command_string, diff_tree.old_tree,
677
 
                                     diff_tree.new_tree, diff_tree.to_file)
678
 
        return from_diff_tree
679
 
 
680
 
    def _get_command(self, old_path, new_path):
681
 
        my_map = {'old_path': old_path, 'new_path': new_path}
682
 
        return [t % my_map for t in self.command_template]
683
 
 
684
 
    def _execute(self, old_path, new_path):
685
 
        command = self._get_command(old_path, new_path)
686
 
        try:
687
 
            proc = subprocess.Popen(command, stdout=subprocess.PIPE,
688
 
                                    cwd=self._root)
689
 
        except OSError, e:
690
 
            if e.errno == errno.ENOENT:
691
 
                raise errors.ExecutableMissing(command[0])
692
 
            else:
693
 
                raise
694
 
        self.to_file.write(proc.stdout.read())
695
 
        return proc.wait()
696
 
 
697
 
    def _try_symlink_root(self, tree, prefix):
698
 
        if (getattr(tree, 'abspath', None) is None
699
 
            or not osutils.host_os_dereferences_symlinks()):
700
 
            return False
701
 
        try:
702
 
            os.symlink(tree.abspath(''), osutils.pathjoin(self._root, prefix))
703
 
        except OSError, e:
704
 
            if e.errno != errno.EEXIST:
705
 
                raise
706
 
        return True
707
 
 
708
 
    def _write_file(self, file_id, tree, prefix, relpath):
709
 
        full_path = osutils.pathjoin(self._root, prefix, relpath)
710
 
        if self._try_symlink_root(tree, prefix):
711
 
            return full_path
712
 
        parent_dir = osutils.dirname(full_path)
713
 
        try:
714
 
            os.makedirs(parent_dir)
715
 
        except OSError, e:
716
 
            if e.errno != errno.EEXIST:
717
 
                raise
718
 
        source = tree.get_file(file_id, relpath)
719
 
        try:
720
 
            target = open(full_path, 'wb')
721
 
            try:
722
 
                osutils.pumpfile(source, target)
723
 
            finally:
724
 
                target.close()
725
 
        finally:
726
 
            source.close()
727
 
        osutils.make_readonly(full_path)
728
 
        mtime = tree.get_file_mtime(file_id)
729
 
        os.utime(full_path, (mtime, mtime))
730
 
        return full_path
731
 
 
732
 
    def _prepare_files(self, file_id, old_path, new_path):
733
 
        old_disk_path = self._write_file(file_id, self.old_tree, 'old',
734
 
                                         old_path)
735
 
        new_disk_path = self._write_file(file_id, self.new_tree, 'new',
736
 
                                         new_path)
737
 
        return old_disk_path, new_disk_path
738
 
 
739
 
    def finish(self):
740
 
        osutils.rmtree(self._root)
741
 
 
742
 
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
743
 
        if (old_kind, new_kind) != ('file', 'file'):
744
 
            return DiffPath.CANNOT_DIFF
745
 
        self._prepare_files(file_id, old_path, new_path)
746
 
        self._execute(osutils.pathjoin('old', old_path),
747
 
                      osutils.pathjoin('new', new_path))
748
 
 
749
 
 
750
 
class DiffTree(object):
751
 
    """Provides textual representations of the difference between two trees.
752
 
 
753
 
    A DiffTree examines two trees and where a file-id has altered
754
 
    between them, generates a textual representation of the difference.
755
 
    DiffTree uses a sequence of DiffPath objects which are each
756
 
    given the opportunity to handle a given altered fileid. The list
757
 
    of DiffPath objects can be extended globally by appending to
758
 
    DiffTree.diff_factories, or for a specific diff operation by
759
 
    supplying the extra_factories option to the appropriate method.
760
 
    """
761
 
 
762
 
    # list of factories that can provide instances of DiffPath objects
763
 
    # may be extended by plugins.
764
 
    diff_factories = [DiffSymlink.from_diff_tree,
765
 
                      DiffDirectory.from_diff_tree]
766
 
 
767
 
    def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8',
768
 
                 diff_text=None, extra_factories=None):
769
 
        """Constructor
770
 
 
771
 
        :param old_tree: Tree to show as old in the comparison
772
 
        :param new_tree: Tree to show as new in the comparison
773
 
        :param to_file: File to write comparision to
774
 
        :param path_encoding: Character encoding to write paths in
775
 
        :param diff_text: DiffPath-type object to use as a last resort for
776
 
            diffing text files.
777
 
        :param extra_factories: Factories of DiffPaths to try before any other
778
 
            DiffPaths"""
779
 
        if diff_text is None:
780
 
            diff_text = DiffText(old_tree, new_tree, to_file, path_encoding,
781
 
                                 '', '',  internal_diff)
782
 
        self.old_tree = old_tree
783
 
        self.new_tree = new_tree
784
 
        self.to_file = to_file
785
 
        self.path_encoding = path_encoding
786
 
        self.differs = []
787
 
        if extra_factories is not None:
788
 
            self.differs.extend(f(self) for f in extra_factories)
789
 
        self.differs.extend(f(self) for f in self.diff_factories)
790
 
        self.differs.extend([diff_text, DiffKindChange.from_diff_tree(self)])
791
 
 
792
 
    @classmethod
793
 
    def from_trees_options(klass, old_tree, new_tree, to_file,
794
 
                           path_encoding, external_diff_options, old_label,
795
 
                           new_label, using):
796
 
        """Factory for producing a DiffTree.
797
 
 
798
 
        Designed to accept options used by show_diff_trees.
799
 
        :param old_tree: The tree to show as old in the comparison
800
 
        :param new_tree: The tree to show as new in the comparison
801
 
        :param to_file: File to write comparisons to
802
 
        :param path_encoding: Character encoding to use for writing paths
803
 
        :param external_diff_options: If supplied, use the installed diff
804
 
            binary to perform file comparison, using supplied options.
805
 
        :param old_label: Prefix to use for old file labels
806
 
        :param new_label: Prefix to use for new file labels
807
 
        :param using: Commandline to use to invoke an external diff tool
808
 
        """
809
 
        if using is not None:
810
 
            extra_factories = [DiffFromTool.make_from_diff_tree(using)]
811
 
        else:
812
 
            extra_factories = []
813
 
        if external_diff_options:
814
 
            opts = external_diff_options.split()
815
 
            def diff_file(olab, olines, nlab, nlines, to_file):
816
 
                external_diff(olab, olines, nlab, nlines, to_file, opts)
817
 
        else:
818
 
            diff_file = internal_diff
819
 
        diff_text = DiffText(old_tree, new_tree, to_file, path_encoding,
820
 
                             old_label, new_label, diff_file)
821
 
        return klass(old_tree, new_tree, to_file, path_encoding, diff_text,
822
 
                     extra_factories)
823
 
 
824
 
    def show_diff(self, specific_files, extra_trees=None):
825
 
        """Write tree diff to self.to_file
826
 
 
827
 
        :param sepecific_files: the specific files to compare (recursive)
828
 
        :param extra_trees: extra trees to use for mapping paths to file_ids
829
 
        """
830
 
        try:
831
 
            return self._show_diff(specific_files, extra_trees)
832
 
        finally:
833
 
            for differ in self.differs:
834
 
                differ.finish()
835
 
 
836
 
    def _show_diff(self, specific_files, extra_trees):
837
 
        # TODO: Generation of pseudo-diffs for added/deleted files could
838
 
        # be usefully made into a much faster special case.
839
 
        iterator = self.new_tree.iter_changes(self.old_tree,
840
 
                                               specific_files=specific_files,
841
 
                                               extra_trees=extra_trees,
842
 
                                               require_versioned=True)
843
 
        has_changes = 0
844
 
        def changes_key(change):
845
 
            old_path, new_path = change[1]
846
 
            path = new_path
847
 
            if path is None:
848
 
                path = old_path
849
 
            return path
850
 
        def get_encoded_path(path):
851
 
            if path is not None:
852
 
                return path.encode(self.path_encoding, "replace")
853
 
        for (file_id, paths, changed_content, versioned, parent, name, kind,
854
 
             executable) in sorted(iterator, key=changes_key):
855
 
            # The root does not get diffed, and items with no known kind (that
856
 
            # is, missing) in both trees are skipped as well.
857
 
            if parent == (None, None) or kind == (None, None):
858
 
                continue
859
 
            oldpath, newpath = paths
860
 
            oldpath_encoded = get_encoded_path(paths[0])
861
 
            newpath_encoded = get_encoded_path(paths[1])
862
 
            old_present = (kind[0] is not None and versioned[0])
863
 
            new_present = (kind[1] is not None and versioned[1])
864
 
            renamed = (parent[0], name[0]) != (parent[1], name[1])
865
 
 
866
 
            properties_changed = []
867
 
            properties_changed.extend(get_executable_change(executable[0], executable[1]))
868
 
 
869
 
            if properties_changed:
870
 
                prop_str = " (properties changed: %s)" % (", ".join(properties_changed),)
871
 
            else:
872
 
                prop_str = ""
873
 
 
874
 
            if (old_present, new_present) == (True, False):
875
 
                self.to_file.write("=== removed %s '%s'\n" %
876
 
                                   (kind[0], oldpath_encoded))
877
 
                newpath = oldpath
878
 
            elif (old_present, new_present) == (False, True):
879
 
                self.to_file.write("=== added %s '%s'\n" %
880
 
                                   (kind[1], newpath_encoded))
881
 
                oldpath = newpath
882
 
            elif renamed:
883
 
                self.to_file.write("=== renamed %s '%s' => '%s'%s\n" %
884
 
                    (kind[0], oldpath_encoded, newpath_encoded, prop_str))
885
 
            else:
886
 
                # if it was produced by iter_changes, it must be
887
 
                # modified *somehow*, either content or execute bit.
888
 
                self.to_file.write("=== modified %s '%s'%s\n" % (kind[0],
889
 
                                   newpath_encoded, prop_str))
890
 
            if changed_content:
891
 
                self.diff(file_id, oldpath, newpath)
892
 
                has_changes = 1
893
 
            if renamed:
894
 
                has_changes = 1
895
 
        return has_changes
896
 
 
897
 
    def diff(self, file_id, old_path, new_path):
898
 
        """Perform a diff of a single file
899
 
 
900
 
        :param file_id: file-id of the file
901
 
        :param old_path: The path of the file in the old tree
902
 
        :param new_path: The path of the file in the new tree
903
 
        """
904
 
        try:
905
 
            old_kind = self.old_tree.kind(file_id)
906
 
        except (errors.NoSuchId, errors.NoSuchFile):
907
 
            old_kind = None
908
 
        try:
909
 
            new_kind = self.new_tree.kind(file_id)
910
 
        except (errors.NoSuchId, errors.NoSuchFile):
911
 
            new_kind = None
912
 
 
913
 
        result = DiffPath._diff_many(self.differs, file_id, old_path,
914
 
                                       new_path, old_kind, new_kind)
915
 
        if result is DiffPath.CANNOT_DIFF:
916
 
            error_path = new_path
917
 
            if error_path is None:
918
 
                error_path = old_path
919
 
            raise errors.NoDiffFound(error_path)
 
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)