← 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-19 21:34:32 UTC
  • Revision ID: mbp@sourcefrog.net-20050819213432-4fa923a97c45d845
- add schema and example for new inventory form

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
 
190
184
        If set, use an external GNU diff and pass these options.
191
185
    """
192
186
 
193
 
    old_tree.lock_read()
194
 
    try:
195
 
        new_tree.lock_read()
196
 
        try:
197
 
            return _show_diff_trees(old_tree, new_tree, to_file,
198
 
                                    specific_files, external_diff_options)
199
 
        finally:
200
 
            new_tree.unlock()
201
 
    finally:
202
 
        old_tree.unlock()
203
 
 
204
 
 
205
 
def _show_diff_trees(old_tree, new_tree, to_file,
206
 
                     specific_files, external_diff_options):
207
 
 
208
187
    # TODO: Options to control putting on a prefix or suffix, perhaps as a format string
209
188
    old_label = ''
210
189
    new_label = ''
229
208
    delta = compare_trees(old_tree, new_tree, want_unchanged=False,
230
209
                          specific_files=specific_files)
231
210
 
232
 
    has_changes = 0
233
211
    for path, file_id, kind in delta.removed:
234
 
        has_changes = 1
235
 
        print >>to_file, '=== removed %s %r' % (kind, path)
236
 
        old_tree.inventory[file_id].diff(diff_file, old_label + path, old_tree,
237
 
                                         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
 
238
220
    for path, file_id, kind in delta.added:
239
 
        has_changes = 1
240
 
        print >>to_file, '=== added %s %r' % (kind, path)
241
 
        new_tree.inventory[file_id].diff(diff_file, new_label + path, new_tree,
242
 
                                         DEVNULL, None, None, to_file, 
243
 
                                         reverse=True)
244
 
    for (old_path, new_path, file_id, kind,
245
 
         text_modified, meta_modified) in delta.renamed:
246
 
        has_changes = 1
247
 
        prop_str = get_prop_change(meta_modified)
248
 
        print >>to_file, '=== renamed %s %r => %r%s' % (
249
 
                          kind, old_path, new_path, prop_str)
250
 
        _maybe_diff_file_or_symlink(old_label, old_path, old_tree, file_id,
251
 
                                    new_label, new_path, new_tree,
252
 
                                    text_modified, kind, to_file, diff_file)
253
 
    for path, file_id, kind, text_modified, meta_modified in delta.modified:
254
 
        has_changes = 1
255
 
        prop_str = get_prop_change(meta_modified)
256
 
        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)
257
231
        if text_modified:
258
 
            _maybe_diff_file_or_symlink(old_label, path, old_tree, file_id,
259
 
                                        new_label, path, new_tree,
260
 
                                        True, kind, to_file, diff_file)
261
 
    return has_changes
262
 
    
263
 
 
264
 
def get_prop_change(meta_modified):
265
 
    if meta_modified:
266
 
        return " (properties changed)"
267
 
    else:
268
 
        return  ""
269
 
 
270
 
 
271
 
def _maybe_diff_file_or_symlink(old_label, old_path, old_tree, file_id,
272
 
                                new_label, new_path, new_tree, text_modified,
273
 
                                kind, to_file, diff_file):
274
 
    if text_modified:
275
 
        new_entry = new_tree.inventory[file_id]
276
 
        old_tree.inventory[file_id].diff(diff_file,
277
 
                                         old_label + old_path, old_tree,
278
 
                                         new_label + new_path, new_entry, 
279
 
                                         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