~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/diff.py

  • Committer: Robert Collins
  • Date: 2005-10-02 22:47:02 UTC
  • mto: This revision was merged to the branch mainline in revision 1397.
  • Revision ID: robertc@robertcollins.net-20051002224701-8a8b20b90de559a6
support ghosts in commits

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2004, 2005, 2006 Canonical Ltd.
2
 
#
 
1
# -*- coding: UTF-8 -*-
 
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 errno
18
 
import os
19
 
import re
20
 
import subprocess
21
 
import sys
22
 
import tempfile
23
 
import time
24
 
 
25
 
# compatability - plugins import compare_trees from diff!!!
26
 
# deprecated as of 0.10
 
17
from bzrlib.trace import mutter
 
18
from bzrlib.errors import BzrError
27
19
from bzrlib.delta import compare_trees
28
 
from bzrlib.errors import BzrError
29
 
import bzrlib.errors as errors
30
 
import bzrlib.osutils
31
 
from bzrlib.patiencediff import unified_diff
32
 
import bzrlib.patiencediff
33
 
from bzrlib.symbol_versioning import (deprecated_function,
34
 
        zero_eight)
35
 
from bzrlib.textfile import check_text_lines
36
 
from bzrlib.trace import mutter, warning
37
 
 
38
20
 
39
21
# TODO: Rather than building a changeset object, we should probably
40
22
# invoke callbacks on an object.  That object can either accumulate a
41
23
# list, write them out directly, etc etc.
42
24
 
43
 
def internal_diff(old_filename, oldlines, new_filename, newlines, to_file,
44
 
                  allow_binary=False, sequence_matcher=None,
45
 
                  path_encoding='utf8'):
 
25
def internal_diff(old_label, oldlines, new_label, newlines, to_file):
 
26
    import difflib
 
27
    
46
28
    # FIXME: difflib is wrong if there is no trailing newline.
47
29
    # The syntax used by patch seems to be "\ No newline at
48
30
    # end of file" following the last diff line from that
58
40
    # both sequences are empty.
59
41
    if not oldlines and not newlines:
60
42
        return
61
 
    
62
 
    if allow_binary is False:
63
 
        check_text_lines(oldlines)
64
 
        check_text_lines(newlines)
65
43
 
66
 
    if sequence_matcher is None:
67
 
        sequence_matcher = bzrlib.patiencediff.PatienceSequenceMatcher
68
 
    ud = unified_diff(oldlines, newlines,
69
 
                      fromfile=old_filename.encode(path_encoding),
70
 
                      tofile=new_filename.encode(path_encoding),
71
 
                      sequencematcher=sequence_matcher)
 
44
    ud = difflib.unified_diff(oldlines, newlines,
 
45
                              fromfile=old_label, tofile=new_label)
72
46
 
73
47
    ud = list(ud)
74
48
    # work-around for difflib being too smart for its own good
88
62
    print >>to_file
89
63
 
90
64
 
91
 
def _set_lang_C():
92
 
    """Set the env var LANG=C"""
93
 
    os.environ['LANG'] = 'C'
94
 
 
95
 
 
96
 
def _spawn_external_diff(diffcmd, capture_errors=True):
97
 
    """Spawn the externall diff process, and return the child handle.
98
 
 
99
 
    :param diffcmd: The command list to spawn
100
 
    :param capture_errors: Capture stderr as well as setting LANG=C.
101
 
        This lets us read and understand the output of diff, and respond 
102
 
        to any errors.
103
 
    :return: A Popen object.
104
 
    """
105
 
    if capture_errors:
106
 
        preexec_fn = _set_lang_C
107
 
        stderr = subprocess.PIPE
108
 
    else:
109
 
        preexec_fn = None
110
 
        stderr = None
111
 
 
112
 
    try:
113
 
        pipe = subprocess.Popen(diffcmd,
114
 
                                stdin=subprocess.PIPE,
115
 
                                stdout=subprocess.PIPE,
116
 
                                stderr=stderr,
117
 
                                preexec_fn=preexec_fn)
118
 
    except OSError, e:
119
 
        if e.errno == errno.ENOENT:
120
 
            raise errors.NoDiff(str(e))
121
 
        raise
122
 
 
123
 
    return pipe
124
 
 
125
 
 
126
 
def external_diff(old_filename, oldlines, new_filename, newlines, to_file,
 
65
def external_diff(old_label, oldlines, new_label, newlines, to_file,
127
66
                  diff_opts):
128
67
    """Display a diff by calling out to the external diff program."""
 
68
    import sys
 
69
    
 
70
    if to_file != sys.stdout:
 
71
        raise NotImplementedError("sorry, can't send external diff other than to stdout yet",
 
72
                                  to_file)
 
73
 
129
74
    # make sure our own output is properly ordered before the diff
130
75
    to_file.flush()
131
76
 
132
 
    oldtmp_fd, old_abspath = tempfile.mkstemp(prefix='bzr-diff-old-')
133
 
    newtmp_fd, new_abspath = tempfile.mkstemp(prefix='bzr-diff-new-')
134
 
    oldtmpf = os.fdopen(oldtmp_fd, 'wb')
135
 
    newtmpf = os.fdopen(newtmp_fd, 'wb')
 
77
    from tempfile import NamedTemporaryFile
 
78
    import os
 
79
 
 
80
    oldtmpf = NamedTemporaryFile()
 
81
    newtmpf = NamedTemporaryFile()
136
82
 
137
83
    try:
138
84
        # TODO: perhaps a special case for comparing to or from the empty
145
91
        oldtmpf.writelines(oldlines)
146
92
        newtmpf.writelines(newlines)
147
93
 
148
 
        oldtmpf.close()
149
 
        newtmpf.close()
 
94
        oldtmpf.flush()
 
95
        newtmpf.flush()
150
96
 
151
97
        if not diff_opts:
152
98
            diff_opts = []
153
99
        diffcmd = ['diff',
154
 
                   '--label', old_filename,
155
 
                   old_abspath,
156
 
                   '--label', new_filename,
157
 
                   new_abspath,
158
 
                   '--binary',
159
 
                  ]
 
100
                   '--label', old_label,
 
101
                   oldtmpf.name,
 
102
                   '--label', new_label,
 
103
                   newtmpf.name]
160
104
 
161
105
        # diff only allows one style to be specified; they don't override.
162
106
        # note that some of these take optargs, and the optargs can be
182
126
        if diff_opts:
183
127
            diffcmd.extend(diff_opts)
184
128
 
185
 
        pipe = _spawn_external_diff(diffcmd, capture_errors=True)
186
 
        out,err = pipe.communicate()
187
 
        rc = pipe.returncode
 
129
        rc = os.spawnvp(os.P_WAIT, 'diff', diffcmd)
188
130
        
189
 
        # internal_diff() adds a trailing newline, add one here for consistency
190
 
        out += '\n'
191
 
        if rc == 2:
192
 
            # 'diff' gives retcode == 2 for all sorts of errors
193
 
            # one of those is 'Binary files differ'.
194
 
            # Bad options could also be the problem.
195
 
            # 'Binary files' is not a real error, so we suppress that error
196
 
            lang_c_out = out
197
 
 
198
 
            # Since we got here, we want to make sure to give an i18n error
199
 
            pipe = _spawn_external_diff(diffcmd, capture_errors=False)
200
 
            out, err = pipe.communicate()
201
 
 
202
 
            # Write out the new i18n diff response
203
 
            to_file.write(out+'\n')
204
 
            if pipe.returncode != 2:
205
 
                raise BzrError('external diff failed with exit code 2'
206
 
                               ' when run with LANG=C, but not when run'
207
 
                               ' natively: %r' % (diffcmd,))
208
 
 
209
 
            first_line = lang_c_out.split('\n', 1)[0]
210
 
            m = re.match('^binary files.*differ$', first_line, re.I)
211
 
            if m is None:
212
 
                raise BzrError('external diff failed with exit code 2;'
213
 
                               ' command: %r' % (diffcmd,))
214
 
            else:
215
 
                # Binary files differ, just return
216
 
                return
217
 
 
218
 
        # If we got to here, we haven't written out the output of diff
219
 
        # do so now
220
 
        to_file.write(out)
221
 
        if rc not in (0, 1):
 
131
        if rc != 0 and rc != 1:
222
132
            # returns 1 if files differ; that's OK
223
133
            if rc < 0:
224
134
                msg = 'signal %d' % (-rc)
225
135
            else:
226
136
                msg = 'exit code %d' % rc
227
137
                
228
 
            raise BzrError('external diff failed with %s; command: %r' 
229
 
                           % (rc, diffcmd))
230
 
 
231
 
 
 
138
            raise BzrError('external diff failed with %s; command: %r' % (rc, diffcmd))
232
139
    finally:
233
140
        oldtmpf.close()                 # and delete
234
141
        newtmpf.close()
235
 
        # Clean up. Warn in case the files couldn't be deleted
236
 
        # (in case windows still holds the file open, but not
237
 
        # if the files have already been deleted)
238
 
        try:
239
 
            os.remove(old_abspath)
240
 
        except OSError, e:
241
 
            if e.errno not in (errno.ENOENT,):
242
 
                warning('Failed to delete temporary file: %s %s',
243
 
                        old_abspath, e)
244
 
        try:
245
 
            os.remove(new_abspath)
246
 
        except OSError:
247
 
            if e.errno not in (errno.ENOENT,):
248
 
                warning('Failed to delete temporary file: %s %s',
249
 
                        new_abspath, e)
250
 
 
251
 
 
252
 
@deprecated_function(zero_eight)
253
 
def show_diff(b, from_spec, specific_files, external_diff_options=None,
254
 
              revision2=None, output=None, b2=None):
 
142
 
 
143
def show_diff(b, revision, specific_files, external_diff_options=None,
 
144
              revision2=None, output=None):
255
145
    """Shortcut for showing the diff to the working tree.
256
146
 
257
 
    Please use show_diff_trees instead.
258
 
 
259
147
    b
260
148
        Branch.
261
149
 
262
150
    revision
263
 
        None for 'basis tree', or otherwise the old revision to compare against.
 
151
        None for each, or otherwise the old revision to compare against.
264
152
    
265
153
    The more general form is show_diff_trees(), where the caller
266
154
    supplies any two trees.
267
155
    """
268
156
    if output is None:
 
157
        import sys
269
158
        output = sys.stdout
270
159
 
271
 
    if from_spec is None:
272
 
        old_tree = b.bzrdir.open_workingtree()
273
 
        if b2 is None:
274
 
            old_tree = old_tree = old_tree.basis_tree()
 
160
    if revision is None:
 
161
        old_tree = b.basis_tree()
275
162
    else:
276
 
        old_tree = b.repository.revision_tree(from_spec.in_history(b).rev_id)
 
163
        old_tree = b.revision_tree(revision.in_history(b).rev_id)
277
164
 
278
165
    if revision2 is None:
279
 
        if b2 is None:
280
 
            new_tree = b.bzrdir.open_workingtree()
281
 
        else:
282
 
            new_tree = b2.bzrdir.open_workingtree()
283
 
    else:
284
 
        new_tree = b.repository.revision_tree(revision2.in_history(b).rev_id)
285
 
 
286
 
    return show_diff_trees(old_tree, new_tree, output, specific_files,
287
 
                           external_diff_options)
288
 
 
289
 
 
290
 
def diff_cmd_helper(tree, specific_files, external_diff_options, 
291
 
                    old_revision_spec=None, new_revision_spec=None,
292
 
                    old_label='a/', new_label='b/'):
293
 
    """Helper for cmd_diff.
294
 
 
295
 
   tree 
296
 
        A WorkingTree
297
 
 
298
 
    specific_files
299
 
        The specific files to compare, or None
300
 
 
301
 
    external_diff_options
302
 
        If non-None, run an external diff, and pass it these options
303
 
 
304
 
    old_revision_spec
305
 
        If None, use basis tree as old revision, otherwise use the tree for
306
 
        the specified revision. 
307
 
 
308
 
    new_revision_spec
309
 
        If None, use working tree as new revision, otherwise use the tree for
310
 
        the specified revision.
311
 
    
312
 
    The more general form is show_diff_trees(), where the caller
313
 
    supplies any two trees.
314
 
    """
315
 
    def spec_tree(spec):
316
 
        if tree:
317
 
            revision = spec.in_store(tree.branch)
318
 
        else:
319
 
            revision = spec.in_store(None)
320
 
        revision_id = revision.rev_id
321
 
        branch = revision.branch
322
 
        return branch.repository.revision_tree(revision_id)
323
 
    if old_revision_spec is None:
324
 
        old_tree = tree.basis_tree()
325
 
    else:
326
 
        old_tree = spec_tree(old_revision_spec)
327
 
 
328
 
    if new_revision_spec is None:
329
 
        new_tree = tree
330
 
    else:
331
 
        new_tree = spec_tree(new_revision_spec)
332
 
    if new_tree is not tree:
333
 
        extra_trees = (tree,)
334
 
    else:
335
 
        extra_trees = None
336
 
 
337
 
    return show_diff_trees(old_tree, new_tree, sys.stdout, specific_files,
338
 
                           external_diff_options,
339
 
                           old_label=old_label, new_label=new_label,
340
 
                           extra_trees=extra_trees)
 
166
        new_tree = b.working_tree()
 
167
    else:
 
168
        new_tree = b.revision_tree(revision2.in_history(b).rev_id)
 
169
 
 
170
    show_diff_trees(old_tree, new_tree, output, specific_files,
 
171
                    external_diff_options)
 
172
 
341
173
 
342
174
 
343
175
def show_diff_trees(old_tree, new_tree, to_file, specific_files=None,
344
 
                    external_diff_options=None,
345
 
                    old_label='a/', new_label='b/',
346
 
                    extra_trees=None):
 
176
                    external_diff_options=None):
347
177
    """Show in text form the changes from one tree to another.
348
178
 
349
179
    to_files
351
181
 
352
182
    external_diff_options
353
183
        If set, use an external GNU diff and pass these options.
354
 
 
355
 
    extra_trees
356
 
        If set, more Trees to use for looking up file ids
357
184
    """
358
 
    old_tree.lock_read()
359
 
    try:
360
 
        new_tree.lock_read()
361
 
        try:
362
 
            return _show_diff_trees(old_tree, new_tree, to_file,
363
 
                                    specific_files, external_diff_options,
364
 
                                    old_label=old_label, new_label=new_label,
365
 
                                    extra_trees=extra_trees)
366
 
        finally:
367
 
            new_tree.unlock()
368
 
    finally:
369
 
        old_tree.unlock()
370
 
 
371
 
 
372
 
def _show_diff_trees(old_tree, new_tree, to_file,
373
 
                     specific_files, external_diff_options, 
374
 
                     old_label='a/', new_label='b/', extra_trees=None):
375
 
 
376
 
    # GNU Patch uses the epoch date to detect files that are being added
377
 
    # or removed in a diff.
378
 
    EPOCH_DATE = '1970-01-01 00:00:00 +0000'
 
185
 
 
186
    # TODO: Options to control putting on a prefix or suffix, perhaps as a format string
 
187
    old_label = ''
 
188
    new_label = ''
 
189
 
 
190
    DEVNULL = '/dev/null'
 
191
    # Windows users, don't panic about this filename -- it is a
 
192
    # special signal to GNU patch that the file should be created or
 
193
    # deleted respectively.
379
194
 
380
195
    # TODO: Generation of pseudo-diffs for added/deleted files could
381
196
    # be usefully made into a much faster special case.
388
203
    else:
389
204
        diff_file = internal_diff
390
205
    
391
 
    delta = new_tree.changes_from(old_tree,
392
 
        specific_files=specific_files,
393
 
        extra_trees=extra_trees, require_versioned=True)
394
 
 
395
 
    has_changes = 0
 
206
 
 
207
    delta = compare_trees(old_tree, new_tree, want_unchanged=False,
 
208
                          specific_files=specific_files)
 
209
 
396
210
    for path, file_id, kind in delta.removed:
397
 
        has_changes = 1
398
 
        print >>to_file, '=== removed %s %r' % (kind, path.encode('utf8'))
399
 
        old_name = '%s%s\t%s' % (old_label, path,
400
 
                                 _patch_header_date(old_tree, file_id, path))
401
 
        new_name = '%s%s\t%s' % (new_label, path, EPOCH_DATE)
402
 
        old_tree.inventory[file_id].diff(diff_file, old_name, old_tree,
403
 
                                         new_name, None, None, to_file)
 
211
        print >>to_file, '=== removed %s %r' % (kind, path)
 
212
        if kind == 'file':
 
213
            diff_file(old_label + path,
 
214
                      old_tree.get_file(file_id).readlines(),
 
215
                      DEVNULL, 
 
216
                      [],
 
217
                      to_file)
404
218
    for path, file_id, kind in delta.added:
405
 
        has_changes = 1
406
 
        print >>to_file, '=== added %s %r' % (kind, path.encode('utf8'))
407
 
        old_name = '%s%s\t%s' % (old_label, path, EPOCH_DATE)
408
 
        new_name = '%s%s\t%s' % (new_label, path,
409
 
                                 _patch_header_date(new_tree, file_id, path))
410
 
        new_tree.inventory[file_id].diff(diff_file, new_name, new_tree,
411
 
                                         old_name, None, None, to_file, 
412
 
                                         reverse=True)
413
 
    for (old_path, new_path, file_id, kind,
414
 
         text_modified, meta_modified) in delta.renamed:
415
 
        has_changes = 1
416
 
        prop_str = get_prop_change(meta_modified)
417
 
        print >>to_file, '=== renamed %s %r => %r%s' % (
418
 
                    kind, old_path.encode('utf8'),
419
 
                    new_path.encode('utf8'), prop_str)
420
 
        old_name = '%s%s\t%s' % (old_label, old_path,
421
 
                                 _patch_header_date(old_tree, file_id,
422
 
                                                    old_path))
423
 
        new_name = '%s%s\t%s' % (new_label, new_path,
424
 
                                 _patch_header_date(new_tree, file_id,
425
 
                                                    new_path))
426
 
        _maybe_diff_file_or_symlink(old_name, old_tree, file_id,
427
 
                                    new_name, new_tree,
 
219
        print >>to_file, '=== added %s %r' % (kind, path)
 
220
        if kind == 'file':
 
221
            diff_file(DEVNULL,
 
222
                      [],
 
223
                      new_label + path,
 
224
                      new_tree.get_file(file_id).readlines(),
 
225
                      to_file)
 
226
    for old_path, new_path, file_id, kind, text_modified in delta.renamed:
 
227
        print >>to_file, '=== renamed %s %r => %r' % (kind, old_path, new_path)
 
228
        _maybe_diff_file_or_symlink(old_label, old_path, old_tree, file_id,
 
229
                                    new_label, new_path, new_tree,
428
230
                                    text_modified, kind, to_file, diff_file)
429
 
    for path, file_id, kind, text_modified, meta_modified in delta.modified:
430
 
        has_changes = 1
431
 
        prop_str = get_prop_change(meta_modified)
432
 
        print >>to_file, '=== modified %s %r%s' % (kind, path.encode('utf8'), prop_str)
433
 
        old_name = '%s%s\t%s' % (old_label, path,
434
 
                                 _patch_header_date(old_tree, file_id, path))
435
 
        new_name = '%s%s\t%s' % (new_label, path,
436
 
                                 _patch_header_date(new_tree, file_id, path))
437
 
        if text_modified:
438
 
            _maybe_diff_file_or_symlink(old_name, old_tree, file_id,
439
 
                                        new_name, new_tree,
440
 
                                        True, kind, to_file, diff_file)
441
 
 
442
 
    return has_changes
443
 
 
444
 
 
445
 
def _patch_header_date(tree, file_id, path):
446
 
    """Returns a timestamp suitable for use in a patch header."""
447
 
    tm = time.gmtime(tree.get_file_mtime(file_id, path))
448
 
    return time.strftime('%Y-%m-%d %H:%M:%S +0000', tm)
449
 
 
450
 
 
451
 
def _raise_if_nonexistent(paths, old_tree, new_tree):
452
 
    """Complain if paths are not in either inventory or tree.
453
 
 
454
 
    It's OK with the files exist in either tree's inventory, or 
455
 
    if they exist in the tree but are not versioned.
 
231
    for path, file_id, kind in delta.modified:
 
232
        print >>to_file, '=== modified %s %r' % (kind, path)
 
233
        _maybe_diff_file_or_symlink(old_label, path, old_tree, file_id,
 
234
                                    new_label, path, new_tree,
 
235
                                    True, kind, to_file, diff_file)
456
236
    
457
 
    This can be used by operations such as bzr status that can accept
458
 
    unknown or ignored files.
459
 
    """
460
 
    mutter("check paths: %r", paths)
461
 
    if not paths:
462
 
        return
463
 
    s = old_tree.filter_unversioned_files(paths)
464
 
    s = new_tree.filter_unversioned_files(s)
465
 
    s = [path for path in s if not new_tree.has_filename(path)]
466
 
    if s:
467
 
        raise errors.PathsDoNotExist(sorted(s))
468
 
 
469
 
 
470
 
def get_prop_change(meta_modified):
471
 
    if meta_modified:
472
 
        return " (properties changed)"
473
 
    else:
474
 
        return  ""
475
 
 
476
 
 
477
 
def _maybe_diff_file_or_symlink(old_path, old_tree, file_id,
478
 
                                new_path, new_tree, text_modified,
 
237
 
 
238
def _maybe_diff_file_or_symlink(old_label, old_path, old_tree, file_id,
 
239
                                new_label, new_path, new_tree, text_modified,
479
240
                                kind, to_file, diff_file):
480
241
    if text_modified:
481
 
        new_entry = new_tree.inventory[file_id]
482
 
        old_tree.inventory[file_id].diff(diff_file,
483
 
                                         old_path, old_tree,
484
 
                                         new_path, new_entry, 
485
 
                                         new_tree, to_file)
 
242
        if kind == 'file':
 
243
            diff_file(old_label + old_path,
 
244
                      old_tree.get_file(file_id).readlines(),
 
245
                      new_label + new_path,
 
246
                      new_tree.get_file(file_id).readlines(),
 
247
                      to_file)
 
248
        elif kind == 'symlink':
 
249
            _diff_symlink(old_tree, new_tree, file_id, to_file)
 
250
            
 
251
def _diff_symlink(old_tree, new_tree, file_id, to_file):
 
252
    t1 = old_tree.get_symlink_target(file_id)
 
253
    t2 = new_tree.get_symlink_target(file_id)
 
254
    print >>to_file, '=== target changed %r => %r' % (t1, t2)