← 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: 2005-09-21 15:33:23 UTC
  • mto: (1185.1.37)
  • mto: This revision was merged to the branch mainline in revision 1390.
  • Revision ID: abentley@panoramicfeedback.com-20050921153323-5db674d572d7649d
Fixed bug in distance-from-root graph operation

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/diff.py
22
22
# invoke callbacks on an object.  That object can either accumulate a
23
23
# list, write them out directly, etc etc.
24
24
 
25
 
def internal_diff(old_filename, oldlines, new_filename, newlines, to_file):
 
25
def internal_diff(old_label, oldlines, new_label, newlines, to_file):
26
26
    import difflib
27
27
    
28
28
    # FIXME: difflib is wrong if there is no trailing newline.
42
42
        return
43
43
 
44
44
    ud = difflib.unified_diff(oldlines, newlines,
45
 
                              fromfile=old_filename+'\t', 
46
 
                              tofile=new_filename+'\t')
 
45
                              fromfile=old_label, tofile=new_label)
47
46
 
48
47
    ud = list(ud)
49
48
    # work-around for difflib being too smart for its own good
63
62
    print >>to_file
64
63
 
65
64
 
66
 
def external_diff(old_filename, oldlines, new_filename, newlines, to_file,
 
65
 
 
66
 
 
67
def external_diff(old_label, oldlines, new_label, newlines, to_file,
67
68
                  diff_opts):
68
69
    """Display a diff by calling out to the external diff program."""
69
70
    import sys
98
99
        if not diff_opts:
99
100
            diff_opts = []
100
101
        diffcmd = ['diff',
101
 
                   '--label', old_filename+'\t',
 
102
                   '--label', old_label,
102
103
                   oldtmpf.name,
103
 
                   '--label', new_filename+'\t',
 
104
                   '--label', new_label,
104
105
                   newtmpf.name]
105
106
 
106
107
        # diff only allows one style to be specified; they don't override.
140
141
    finally:
141
142
        oldtmpf.close()                 # and delete
142
143
        newtmpf.close()
143
 
 
144
 
def show_diff(b, from_spec, specific_files, external_diff_options=None,
145
 
              revision2=None, output=None, b2=None):
 
144
    
 
145
 
 
146
 
 
147
def show_diff(b, revision, specific_files, external_diff_options=None,
 
148
              revision2=None, output=None):
146
149
    """Shortcut for showing the diff to the working tree.
147
150
 
148
151
    b
149
152
        Branch.
150
153
 
151
154
    revision
152
 
        None for 'basis tree', or otherwise the old revision to compare against.
 
155
        None for each, or otherwise the old revision to compare against.
153
156
    
154
157
    The more general form is show_diff_trees(), where the caller
155
158
    supplies any two trees.
158
161
        import sys
159
162
        output = sys.stdout
160
163
 
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()
 
164
    if revision is None:
 
165
        old_tree = b.basis_tree()
166
166
    else:
167
 
        old_tree = b.repository.revision_tree(from_spec.in_history(b).rev_id)
 
167
        old_tree = b.revision_tree(revision.in_history(b).rev_id)
168
168
 
169
169
    if revision2 is None:
170
 
        if b2 is None:
171
 
            new_tree = b.working_tree()
172
 
        else:
173
 
            new_tree = b2.working_tree()
 
170
        new_tree = b.working_tree()
174
171
    else:
175
 
        new_tree = b.repository.revision_tree(revision2.in_history(b).rev_id)
 
172
        new_tree = b.revision_tree(revision2.in_history(b).rev_id)
176
173
 
177
 
    return show_diff_trees(old_tree, new_tree, output, specific_files,
178
 
                           external_diff_options)
 
174
    show_diff_trees(old_tree, new_tree, output, specific_files,
 
175
                    external_diff_options)
179
176
 
180
177
 
181
178
 
214
211
    delta = compare_trees(old_tree, new_tree, want_unchanged=False,
215
212
                          specific_files=specific_files)
216
213
 
217
 
    has_changes = 0
218
214
    for path, file_id, kind in delta.removed:
219
 
        has_changes = 1
220
215
        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)
 
216
        if kind == 'file':
 
217
            diff_file(old_label + path,
 
218
                      old_tree.get_file(file_id).readlines(),
 
219
                      DEVNULL, 
 
220
                      [],
 
221
                      to_file)
 
222
 
223
223
    for path, file_id, kind in delta.added:
224
 
        has_changes = 1
225
224
        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)
 
225
        if kind == 'file':
 
226
            diff_file(DEVNULL,
 
227
                      [],
 
228
                      new_label + path,
 
229
                      new_tree.get_file(file_id).readlines(),
 
230
                      to_file)
 
231
 
 
232
    for old_path, new_path, file_id, kind, text_modified in delta.renamed:
 
233
        print >>to_file, '=== renamed %s %r => %r' % (kind, old_path, new_path)
242
234
        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)
 
235
            diff_file(old_label + old_path,
 
236
                      old_tree.get_file(file_id).readlines(),
 
237
                      new_label + new_path,
 
238
                      new_tree.get_file(file_id).readlines(),
 
239
                      to_file)
 
240
 
 
241
    for path, file_id, kind in delta.modified:
 
242
        print >>to_file, '=== modified %s %r' % (kind, path)
 
243
        if kind == 'file':
 
244
            diff_file(old_label + path,
 
245
                      old_tree.get_file(file_id).readlines(),
 
246
                      new_label + path,
 
247
                      new_tree.get_file(file_id).readlines(),
 
248
                      to_file)
 
249
 
 
250
 
 
251
 
 
252
 
 
253