/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/diff.py

  • Committer: John Arbash Meinel
  • Date: 2006-07-31 18:41:54 UTC
  • mto: (1900.2.1 bzr.merge.54651)
  • mto: This revision was merged to the branch mainline in revision 1903.
  • Revision ID: john@arbash-meinel.com-20060731184154-1d0a9110ebc2c82b
Update NEWS

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/diff.py
 
1
# Copyright (C) 2004, 2005, 2006 Canonical Ltd.
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
import errno
 
18
import os
 
19
import subprocess
 
20
import sys
 
21
import tempfile
 
22
import time
 
23
 
 
24
# compatability - plugins import compare_trees from diff!!!
 
25
# deprecated as of 0.10
 
26
from bzrlib.delta import compare_trees
 
27
from bzrlib.errors import BzrError
 
28
import bzrlib.errors as errors
 
29
import bzrlib.osutils
 
30
from bzrlib.patiencediff import unified_diff
 
31
import bzrlib.patiencediff
 
32
from bzrlib.symbol_versioning import (deprecated_function,
 
33
        zero_eight)
 
34
from bzrlib.textfile import check_text_lines
 
35
from bzrlib.trace import mutter, warning
 
36
 
 
37
 
 
38
# TODO: Rather than building a changeset object, we should probably
 
39
# invoke callbacks on an object.  That object can either accumulate a
 
40
# list, write them out directly, etc etc.
 
41
 
 
42
def internal_diff(old_filename, oldlines, new_filename, newlines, to_file,
 
43
                  allow_binary=False, sequence_matcher=None,
 
44
                  path_encoding='utf8'):
 
45
    # FIXME: difflib is wrong if there is no trailing newline.
 
46
    # The syntax used by patch seems to be "\ No newline at
 
47
    # end of file" following the last diff line from that
 
48
    # file.  This is not trivial to insert into the
 
49
    # unified_diff output and it might be better to just fix
 
50
    # or replace that function.
 
51
 
 
52
    # In the meantime we at least make sure the patch isn't
 
53
    # mangled.
 
54
 
 
55
 
 
56
    # Special workaround for Python2.3, where difflib fails if
 
57
    # both sequences are empty.
 
58
    if not oldlines and not newlines:
 
59
        return
 
60
    
 
61
    if allow_binary is False:
 
62
        check_text_lines(oldlines)
 
63
        check_text_lines(newlines)
 
64
 
 
65
    if sequence_matcher is None:
 
66
        sequence_matcher = bzrlib.patiencediff.PatienceSequenceMatcher
 
67
    ud = unified_diff(oldlines, newlines,
 
68
                      fromfile=old_filename.encode(path_encoding),
 
69
                      tofile=new_filename.encode(path_encoding),
 
70
                      sequencematcher=sequence_matcher)
 
71
 
 
72
    ud = list(ud)
 
73
    # work-around for difflib being too smart for its own good
 
74
    # if /dev/null is "1,0", patch won't recognize it as /dev/null
 
75
    if not oldlines:
 
76
        ud[2] = ud[2].replace('-1,0', '-0,0')
 
77
    elif not newlines:
 
78
        ud[2] = ud[2].replace('+1,0', '+0,0')
 
79
    # work around for difflib emitting random spaces after the label
 
80
    ud[0] = ud[0][:-2] + '\n'
 
81
    ud[1] = ud[1][:-2] + '\n'
 
82
 
 
83
    for line in ud:
 
84
        to_file.write(line)
 
85
        if not line.endswith('\n'):
 
86
            to_file.write("\n\\ No newline at end of file\n")
 
87
    print >>to_file
 
88
 
 
89
 
 
90
def external_diff(old_filename, oldlines, new_filename, newlines, to_file,
 
91
                  diff_opts):
 
92
    """Display a diff by calling out to the external diff program."""
 
93
    fileno_func = getattr(to_file, 'fileno', None)
 
94
    if fileno_func is not None:
 
95
        fileno = fileno_func()
 
96
        # WORKAROUND: jam 20060731 python2.4 subprocess.py will 
 
97
        #       close too many file descriptors if you pass stdout=sys.stdout
 
98
        #       so if we are about to pass stdout, just pass None
 
99
        if fileno == 1:
 
100
            out_file = None
 
101
        else:
 
102
            out_file = to_file
 
103
        have_fileno = True
 
104
    else:
 
105
        out_file = subprocess.PIPE
 
106
        have_fileno = False
 
107
    
 
108
    # make sure our own output is properly ordered before the diff
 
109
    to_file.flush()
 
110
 
 
111
    oldtmp_fd, old_abspath = tempfile.mkstemp(prefix='bzr-diff-old-')
 
112
    newtmp_fd, new_abspath = tempfile.mkstemp(prefix='bzr-diff-new-')
 
113
    oldtmpf = os.fdopen(oldtmp_fd, 'wb')
 
114
    newtmpf = os.fdopen(newtmp_fd, 'wb')
 
115
 
 
116
    try:
 
117
        # TODO: perhaps a special case for comparing to or from the empty
 
118
        # sequence; can just use /dev/null on Unix
 
119
 
 
120
        # TODO: if either of the files being compared already exists as a
 
121
        # regular named file (e.g. in the working directory) then we can
 
122
        # compare directly to that, rather than copying it.
 
123
 
 
124
        oldtmpf.writelines(oldlines)
 
125
        newtmpf.writelines(newlines)
 
126
 
 
127
        oldtmpf.close()
 
128
        newtmpf.close()
 
129
 
 
130
        if not diff_opts:
 
131
            diff_opts = []
 
132
        diffcmd = ['diff',
 
133
                   '--label', old_filename,
 
134
                   old_abspath,
 
135
                   '--label', new_filename,
 
136
                   new_abspath,
 
137
                   '--binary',
 
138
                  ]
 
139
 
 
140
        # diff only allows one style to be specified; they don't override.
 
141
        # note that some of these take optargs, and the optargs can be
 
142
        # directly appended to the options.
 
143
        # this is only an approximate parser; it doesn't properly understand
 
144
        # the grammar.
 
145
        for s in ['-c', '-u', '-C', '-U',
 
146
                  '-e', '--ed',
 
147
                  '-q', '--brief',
 
148
                  '--normal',
 
149
                  '-n', '--rcs',
 
150
                  '-y', '--side-by-side',
 
151
                  '-D', '--ifdef']:
 
152
            for j in diff_opts:
 
153
                if j.startswith(s):
 
154
                    break
 
155
            else:
 
156
                continue
 
157
            break
 
158
        else:
 
159
            diffcmd.append('-u')
 
160
                  
 
161
        if diff_opts:
 
162
            diffcmd.extend(diff_opts)
 
163
 
 
164
        try:
 
165
            pipe = subprocess.Popen(diffcmd,
 
166
                                    stdin=subprocess.PIPE,
 
167
                                    stdout=out_file)
 
168
        except OSError, e:
 
169
            if e.errno == errno.ENOENT:
 
170
                raise errors.NoDiff(str(e))
 
171
            raise
 
172
        pipe.stdin.close()
 
173
 
 
174
        if not have_fileno:
 
175
            bzrlib.osutils.pumpfile(pipe.stdout, to_file)
 
176
        rc = pipe.wait()
 
177
        
 
178
        if rc != 0 and rc != 1:
 
179
            # returns 1 if files differ; that's OK
 
180
            if rc < 0:
 
181
                msg = 'signal %d' % (-rc)
 
182
            else:
 
183
                msg = 'exit code %d' % rc
 
184
                
 
185
            raise BzrError('external diff failed with %s; command: %r' % (rc, diffcmd))
 
186
    finally:
 
187
        oldtmpf.close()                 # and delete
 
188
        newtmpf.close()
 
189
        # Clean up. Warn in case the files couldn't be deleted
 
190
        # (in case windows still holds the file open, but not
 
191
        # if the files have already been deleted)
 
192
        try:
 
193
            os.remove(old_abspath)
 
194
        except OSError, e:
 
195
            if e.errno not in (errno.ENOENT,):
 
196
                warning('Failed to delete temporary file: %s %s',
 
197
                        old_abspath, e)
 
198
        try:
 
199
            os.remove(new_abspath)
 
200
        except OSError:
 
201
            if e.errno not in (errno.ENOENT,):
 
202
                warning('Failed to delete temporary file: %s %s',
 
203
                        new_abspath, e)
 
204
 
 
205
 
 
206
@deprecated_function(zero_eight)
 
207
def show_diff(b, from_spec, specific_files, external_diff_options=None,
 
208
              revision2=None, output=None, b2=None):
 
209
    """Shortcut for showing the diff to the working tree.
 
210
 
 
211
    Please use show_diff_trees instead.
 
212
 
 
213
    b
 
214
        Branch.
 
215
 
 
216
    revision
 
217
        None for 'basis tree', or otherwise the old revision to compare against.
 
218
    
 
219
    The more general form is show_diff_trees(), where the caller
 
220
    supplies any two trees.
 
221
    """
 
222
    if output is None:
 
223
        output = sys.stdout
 
224
 
 
225
    if from_spec is None:
 
226
        old_tree = b.bzrdir.open_workingtree()
 
227
        if b2 is None:
 
228
            old_tree = old_tree = old_tree.basis_tree()
 
229
    else:
 
230
        old_tree = b.repository.revision_tree(from_spec.in_history(b).rev_id)
 
231
 
 
232
    if revision2 is None:
 
233
        if b2 is None:
 
234
            new_tree = b.bzrdir.open_workingtree()
 
235
        else:
 
236
            new_tree = b2.bzrdir.open_workingtree()
 
237
    else:
 
238
        new_tree = b.repository.revision_tree(revision2.in_history(b).rev_id)
 
239
 
 
240
    return show_diff_trees(old_tree, new_tree, output, specific_files,
 
241
                           external_diff_options)
 
242
 
 
243
 
 
244
def diff_cmd_helper(tree, specific_files, external_diff_options, 
 
245
                    old_revision_spec=None, new_revision_spec=None,
 
246
                    old_label='a/', new_label='b/'):
 
247
    """Helper for cmd_diff.
 
248
 
 
249
   tree 
 
250
        A WorkingTree
 
251
 
 
252
    specific_files
 
253
        The specific files to compare, or None
 
254
 
 
255
    external_diff_options
 
256
        If non-None, run an external diff, and pass it these options
 
257
 
 
258
    old_revision_spec
 
259
        If None, use basis tree as old revision, otherwise use the tree for
 
260
        the specified revision. 
 
261
 
 
262
    new_revision_spec
 
263
        If None, use working tree as new revision, otherwise use the tree for
 
264
        the specified revision.
 
265
    
 
266
    The more general form is show_diff_trees(), where the caller
 
267
    supplies any two trees.
 
268
    """
 
269
    def spec_tree(spec):
 
270
        if tree:
 
271
            revision = spec.in_store(tree.branch)
 
272
        else:
 
273
            revision = spec.in_store(None)
 
274
        revision_id = revision.rev_id
 
275
        branch = revision.branch
 
276
        return branch.repository.revision_tree(revision_id)
 
277
    if old_revision_spec is None:
 
278
        old_tree = tree.basis_tree()
 
279
    else:
 
280
        old_tree = spec_tree(old_revision_spec)
 
281
 
 
282
    if new_revision_spec is None:
 
283
        new_tree = tree
 
284
    else:
 
285
        new_tree = spec_tree(new_revision_spec)
 
286
    if new_tree is not tree:
 
287
        extra_trees = (tree,)
 
288
    else:
 
289
        extra_trees = None
 
290
 
 
291
    return show_diff_trees(old_tree, new_tree, sys.stdout, specific_files,
 
292
                           external_diff_options,
 
293
                           old_label=old_label, new_label=new_label,
 
294
                           extra_trees=extra_trees)
 
295
 
 
296
 
 
297
def show_diff_trees(old_tree, new_tree, to_file, specific_files=None,
 
298
                    external_diff_options=None,
 
299
                    old_label='a/', new_label='b/',
 
300
                    extra_trees=None):
 
301
    """Show in text form the changes from one tree to another.
 
302
 
 
303
    to_files
 
304
        If set, include only changes to these files.
 
305
 
 
306
    external_diff_options
 
307
        If set, use an external GNU diff and pass these options.
 
308
 
 
309
    extra_trees
 
310
        If set, more Trees to use for looking up file ids
 
311
    """
 
312
    old_tree.lock_read()
 
313
    try:
 
314
        new_tree.lock_read()
 
315
        try:
 
316
            return _show_diff_trees(old_tree, new_tree, to_file,
 
317
                                    specific_files, external_diff_options,
 
318
                                    old_label=old_label, new_label=new_label,
 
319
                                    extra_trees=extra_trees)
 
320
        finally:
 
321
            new_tree.unlock()
 
322
    finally:
 
323
        old_tree.unlock()
 
324
 
 
325
 
 
326
def _show_diff_trees(old_tree, new_tree, to_file,
 
327
                     specific_files, external_diff_options, 
 
328
                     old_label='a/', new_label='b/', extra_trees=None):
 
329
 
 
330
    # GNU Patch uses the epoch date to detect files that are being added
 
331
    # or removed in a diff.
 
332
    EPOCH_DATE = '1970-01-01 00:00:00 +0000'
 
333
 
 
334
    # TODO: Generation of pseudo-diffs for added/deleted files could
 
335
    # be usefully made into a much faster special case.
 
336
 
 
337
    if external_diff_options:
 
338
        assert isinstance(external_diff_options, basestring)
 
339
        opts = external_diff_options.split()
 
340
        def diff_file(olab, olines, nlab, nlines, to_file):
 
341
            external_diff(olab, olines, nlab, nlines, to_file, opts)
 
342
    else:
 
343
        diff_file = internal_diff
 
344
    
 
345
    delta = new_tree.changes_from(old_tree,
 
346
        specific_files=specific_files,
 
347
        extra_trees=extra_trees, require_versioned=True)
 
348
 
 
349
    has_changes = 0
 
350
    for path, file_id, kind in delta.removed:
 
351
        has_changes = 1
 
352
        print >>to_file, '=== removed %s %r' % (kind, path.encode('utf8'))
 
353
        old_name = '%s%s\t%s' % (old_label, path,
 
354
                                 _patch_header_date(old_tree, file_id, path))
 
355
        new_name = '%s%s\t%s' % (new_label, path, EPOCH_DATE)
 
356
        old_tree.inventory[file_id].diff(diff_file, old_name, old_tree,
 
357
                                         new_name, None, None, to_file)
 
358
    for path, file_id, kind in delta.added:
 
359
        has_changes = 1
 
360
        print >>to_file, '=== added %s %r' % (kind, path.encode('utf8'))
 
361
        old_name = '%s%s\t%s' % (old_label, path, EPOCH_DATE)
 
362
        new_name = '%s%s\t%s' % (new_label, path,
 
363
                                 _patch_header_date(new_tree, file_id, path))
 
364
        new_tree.inventory[file_id].diff(diff_file, new_name, new_tree,
 
365
                                         old_name, None, None, to_file, 
 
366
                                         reverse=True)
 
367
    for (old_path, new_path, file_id, kind,
 
368
         text_modified, meta_modified) in delta.renamed:
 
369
        has_changes = 1
 
370
        prop_str = get_prop_change(meta_modified)
 
371
        print >>to_file, '=== renamed %s %r => %r%s' % (
 
372
                    kind, old_path.encode('utf8'),
 
373
                    new_path.encode('utf8'), prop_str)
 
374
        old_name = '%s%s\t%s' % (old_label, old_path,
 
375
                                 _patch_header_date(old_tree, file_id,
 
376
                                                    old_path))
 
377
        new_name = '%s%s\t%s' % (new_label, new_path,
 
378
                                 _patch_header_date(new_tree, file_id,
 
379
                                                    new_path))
 
380
        _maybe_diff_file_or_symlink(old_name, old_tree, file_id,
 
381
                                    new_name, new_tree,
 
382
                                    text_modified, kind, to_file, diff_file)
 
383
    for path, file_id, kind, text_modified, meta_modified in delta.modified:
 
384
        has_changes = 1
 
385
        prop_str = get_prop_change(meta_modified)
 
386
        print >>to_file, '=== modified %s %r%s' % (kind, path.encode('utf8'), prop_str)
 
387
        old_name = '%s%s\t%s' % (old_label, path,
 
388
                                 _patch_header_date(old_tree, file_id, path))
 
389
        new_name = '%s%s\t%s' % (new_label, path,
 
390
                                 _patch_header_date(new_tree, file_id, path))
 
391
        if text_modified:
 
392
            _maybe_diff_file_or_symlink(old_name, old_tree, file_id,
 
393
                                        new_name, new_tree,
 
394
                                        True, kind, to_file, diff_file)
 
395
 
 
396
    return has_changes
 
397
 
 
398
 
 
399
def _patch_header_date(tree, file_id, path):
 
400
    """Returns a timestamp suitable for use in a patch header."""
 
401
    tm = time.gmtime(tree.get_file_mtime(file_id, path))
 
402
    return time.strftime('%Y-%m-%d %H:%M:%S +0000', tm)
 
403
 
 
404
 
 
405
def _raise_if_nonexistent(paths, old_tree, new_tree):
 
406
    """Complain if paths are not in either inventory or tree.
 
407
 
 
408
    It's OK with the files exist in either tree's inventory, or 
 
409
    if they exist in the tree but are not versioned.
 
410
    
 
411
    This can be used by operations such as bzr status that can accept
 
412
    unknown or ignored files.
 
413
    """
 
414
    mutter("check paths: %r", paths)
 
415
    if not paths:
 
416
        return
 
417
    s = old_tree.filter_unversioned_files(paths)
 
418
    s = new_tree.filter_unversioned_files(s)
 
419
    s = [path for path in s if not new_tree.has_filename(path)]
 
420
    if s:
 
421
        raise errors.PathsDoNotExist(sorted(s))
 
422
 
 
423
 
 
424
def get_prop_change(meta_modified):
 
425
    if meta_modified:
 
426
        return " (properties changed)"
 
427
    else:
 
428
        return  ""
 
429
 
 
430
 
 
431
def _maybe_diff_file_or_symlink(old_path, old_tree, file_id,
 
432
                                new_path, new_tree, text_modified,
 
433
                                kind, to_file, diff_file):
 
434
    if text_modified:
 
435
        new_entry = new_tree.inventory[file_id]
 
436
        old_tree.inventory[file_id].diff(diff_file,
 
437
                                         old_path, old_tree,
 
438
                                         new_path, new_entry, 
 
439
                                         new_tree, to_file)