/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-06-19 14:40:19 UTC
  • mto: This revision was merged to the branch mainline in revision 1794.
  • Revision ID: john@arbash-meinel.com-20060619144019-873a4a8d252f7896
Refactor import stuff into separate functions. Update news

Show diffs side-by-side

added added

removed removed

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