← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/diff.py

  • Committer: Martin Pool
  • Date: 2005-08-30 03:10:32 UTC
  • Revision ID: mbp@sourcefrog.net-20050830031032-92ae5f0abb866ab8
- remove dead code and remove some small errors (pychecker)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/diff.py
 
1
#! /usr/bin/env python
1
2
# -*- coding: UTF-8 -*-
2
3
 
3
4
# This program is free software; you can redistribute it and/or modify
22
23
# invoke callbacks on an object.  That object can either accumulate a
23
24
# list, write them out directly, etc etc.
24
25
 
25
 
def internal_diff(old_filename, oldlines, new_filename, newlines, to_file):
 
26
def internal_diff(old_label, oldlines, new_label, newlines, to_file):
26
27
    import difflib
27
28
    
28
29
    # FIXME: difflib is wrong if there is no trailing newline.
42
43
        return
43
44
 
44
45
    ud = difflib.unified_diff(oldlines, newlines,
45
 
                              fromfile=old_filename+'\t', 
46
 
                              tofile=new_filename+'\t')
 
46
                              fromfile=old_label, tofile=new_label)
47
47
 
48
 
    ud = list(ud)
49
48
    # work-around for difflib being too smart for its own good
50
49
    # if /dev/null is "1,0", patch won't recognize it as /dev/null
51
50
    if not oldlines:
 
51
        ud = list(ud)
52
52
        ud[2] = ud[2].replace('-1,0', '-0,0')
53
53
    elif not newlines:
 
54
        ud = list(ud)
54
55
        ud[2] = ud[2].replace('+1,0', '+0,0')
55
 
    # work around for difflib emitting random spaces after the label
56
 
    ud[0] = ud[0][:-2] + '\n'
57
 
    ud[1] = ud[1][:-2] + '\n'
58
56
 
59
57
    for line in ud:
60
58
        to_file.write(line)
63
61
    print >>to_file
64
62
 
65
63
 
66
 
def external_diff(old_filename, oldlines, new_filename, newlines, to_file,
 
64
 
 
65
 
 
66
def external_diff(old_label, oldlines, new_label, newlines, to_file,
67
67
                  diff_opts):
68
68
    """Display a diff by calling out to the external diff program."""
69
69
    import sys
98
98
        if not diff_opts:
99
99
            diff_opts = []
100
100
        diffcmd = ['diff',
101
 
                   '--label', old_filename+'\t',
 
101
                   '--label', old_label,
102
102
                   oldtmpf.name,
103
 
                   '--label', new_filename+'\t',
 
103
                   '--label', new_label,
104
104
                   newtmpf.name]
105
105
 
106
106
        # diff only allows one style to be specified; they don't override.
140
140
    finally:
141
141
        oldtmpf.close()                 # and delete
142
142
        newtmpf.close()
143
 
 
144
 
def show_diff(b, from_spec, specific_files, external_diff_options=None,
145
 
              revision2=None, output=None, b2=None):
 
143
    
 
144
 
 
145
 
 
146
def show_diff(b, revision, specific_files, external_diff_options=None,
 
147
              revision2=None):
146
148
    """Shortcut for showing the diff to the working tree.
147
149
 
148
150
    b
149
151
        Branch.
150
152
 
151
153
    revision
152
 
        None for 'basis tree', or otherwise the old revision to compare against.
 
154
        None for each, or otherwise the old revision to compare against.
153
155
    
154
156
    The more general form is show_diff_trees(), where the caller
155
157
    supplies any two trees.
156
158
    """
157
 
    if output is None:
158
 
        import sys
159
 
        output = sys.stdout
160
 
 
161
 
    if from_spec is None:
162
 
        if b2 is None:
163
 
            old_tree = b.basis_tree()
164
 
        else:
165
 
            old_tree = b.working_tree()
166
 
    else:
167
 
        old_tree = b.revision_tree(from_spec.in_history(b).rev_id)
168
 
 
169
 
    if revision2 is None:
170
 
        if b2 is None:
171
 
            new_tree = b.working_tree()
172
 
        else:
173
 
            new_tree = b2.working_tree()
174
 
    else:
175
 
        new_tree = b.revision_tree(revision2.in_history(b).rev_id)
176
 
 
177
 
    return show_diff_trees(old_tree, new_tree, output, specific_files,
178
 
                           external_diff_options)
 
159
    import sys
 
160
 
 
161
    if revision == None:
 
162
        old_tree = b.basis_tree()
 
163
    else:
 
164
        old_tree = b.revision_tree(b.lookup_revision(revision))
 
165
 
 
166
    if revision2 == None:
 
167
        new_tree = b.working_tree()
 
168
    else:
 
169
        new_tree = b.revision_tree(b.lookup_revision(revision2))
 
170
 
 
171
    show_diff_trees(old_tree, new_tree, sys.stdout, specific_files,
 
172
                    external_diff_options)
179
173
 
180
174
 
181
175
 
214
208
    delta = compare_trees(old_tree, new_tree, want_unchanged=False,
215
209
                          specific_files=specific_files)
216
210
 
217
 
    has_changes = 0
218
211
    for path, file_id, kind in delta.removed:
219
 
        has_changes = 1
220
 
        print >>to_file, '=== removed %s %r' % (kind, path)
221
 
        old_tree.inventory[file_id].diff(diff_file, old_label + path, old_tree,
222
 
                                         DEVNULL, None, None, to_file)
 
212
        print >>to_file, '*** removed %s %r' % (kind, path)
 
213
        if kind == 'file':
 
214
            diff_file(old_label + path,
 
215
                      old_tree.get_file(file_id).readlines(),
 
216
                      DEVNULL, 
 
217
                      [],
 
218
                      to_file)
 
219
 
223
220
    for path, file_id, kind in delta.added:
224
 
        has_changes = 1
225
 
        print >>to_file, '=== added %s %r' % (kind, path)
226
 
        new_tree.inventory[file_id].diff(diff_file, new_label + path, new_tree,
227
 
                                         DEVNULL, None, None, to_file, 
228
 
                                         reverse=True)
229
 
    for (old_path, new_path, file_id, kind,
230
 
         text_modified, meta_modified) in delta.renamed:
231
 
        has_changes = 1
232
 
        prop_str = get_prop_change(meta_modified)
233
 
        print >>to_file, '=== renamed %s %r => %r%s' % (
234
 
                          kind, old_path, new_path, prop_str)
235
 
        _maybe_diff_file_or_symlink(old_label, old_path, old_tree, file_id,
236
 
                                    new_label, new_path, new_tree,
237
 
                                    text_modified, kind, to_file, diff_file)
238
 
    for path, file_id, kind, text_modified, meta_modified in delta.modified:
239
 
        has_changes = 1
240
 
        prop_str = get_prop_change(meta_modified)
241
 
        print >>to_file, '=== modified %s %r%s' % (kind, path, prop_str)
 
221
        print >>to_file, '*** added %s %r' % (kind, path)
 
222
        if kind == 'file':
 
223
            diff_file(DEVNULL,
 
224
                      [],
 
225
                      new_label + path,
 
226
                      new_tree.get_file(file_id).readlines(),
 
227
                      to_file)
 
228
 
 
229
    for old_path, new_path, file_id, kind, text_modified in delta.renamed:
 
230
        print >>to_file, '*** renamed %s %r => %r' % (kind, old_path, new_path)
242
231
        if text_modified:
243
 
            _maybe_diff_file_or_symlink(old_label, path, old_tree, file_id,
244
 
                                        new_label, path, new_tree,
245
 
                                        True, kind, to_file, diff_file)
246
 
    return has_changes
247
 
    
248
 
 
249
 
def get_prop_change(meta_modified):
250
 
    if meta_modified:
251
 
        return " (properties changed)"
252
 
    else:
253
 
        return  ""
254
 
 
255
 
 
256
 
def _maybe_diff_file_or_symlink(old_label, old_path, old_tree, file_id,
257
 
                                new_label, new_path, new_tree, text_modified,
258
 
                                kind, to_file, diff_file):
259
 
    if text_modified:
260
 
        new_entry = new_tree.inventory[file_id]
261
 
        old_tree.inventory[file_id].diff(diff_file,
262
 
                                         old_label + old_path, old_tree,
263
 
                                         new_label + new_path, new_entry, 
264
 
                                         new_tree, to_file)
 
232
            diff_file(old_label + old_path,
 
233
                      old_tree.get_file(file_id).readlines(),
 
234
                      new_label + new_path,
 
235
                      new_tree.get_file(file_id).readlines(),
 
236
                      to_file)
 
237
 
 
238
    for path, file_id, kind in delta.modified:
 
239
        print >>to_file, '*** modified %s %r' % (kind, path)
 
240
        if kind == 'file':
 
241
            diff_file(old_label + path,
 
242
                      old_tree.get_file(file_id).readlines(),
 
243
                      new_label + path,
 
244
                      new_tree.get_file(file_id).readlines(),
 
245
                      to_file)
 
246
 
 
247
 
 
248
 
 
249
 
 
250