~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/delta.py

  • Committer: John Arbash Meinel
  • Date: 2006-08-16 22:35:21 UTC
  • mto: This revision was merged to the branch mainline in revision 1942.
  • Revision ID: john@arbash-meinel.com-20060816223521-73357694d4b7df0b
One field was incorrect, need text_sha1 not text_size

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 Canonical
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
 
from bzrlib import (
18
 
    errors,
19
 
    osutils,
20
 
    )
21
17
from bzrlib.inventory import InventoryEntry
22
18
from bzrlib.trace import mutter
23
19
from bzrlib.symbol_versioning import deprecated_function, zero_nine
38
34
        (path, id, kind, text_modified, meta_modified)
39
35
    unchanged
40
36
        (path, id, kind)
41
 
    unversioned
42
 
        (path, kind)
43
37
 
44
38
    Each id is listed only once.
45
39
 
58
52
        self.added = []
59
53
        self.removed = []
60
54
        self.renamed = []
61
 
        self.kind_changed = []
62
55
        self.modified = []
63
56
        self.unchanged = []
64
 
        self.unversioned = []
65
57
 
66
58
    def __eq__(self, other):
67
59
        if not isinstance(other, TreeDelta):
70
62
               and self.removed == other.removed \
71
63
               and self.renamed == other.renamed \
72
64
               and self.modified == other.modified \
73
 
               and self.unchanged == other.unchanged \
74
 
               and self.kind_changed == other.kind_changed \
75
 
               and self.unversioned == other.unversioned
 
65
               and self.unchanged == other.unchanged
76
66
 
77
67
    def __ne__(self, other):
78
68
        return not (self == other)
79
69
 
80
70
    def __repr__(self):
81
 
        return "TreeDelta(added=%r, removed=%r, renamed=%r," \
82
 
            " kind_changed=%r, modified=%r, unchanged=%r," \
83
 
            " unversioned=%r)" % (self.added,
84
 
            self.removed, self.renamed, self.kind_changed, self.modified,
85
 
            self.unchanged, self.unversioned)
 
71
        return "TreeDelta(added=%r, removed=%r, renamed=%r, modified=%r," \
 
72
            " unchanged=%r)" % (self.added, self.removed, self.renamed,
 
73
            self.modified, self.unchanged)
86
74
 
87
75
    def has_changed(self):
88
76
        return bool(self.modified
89
77
                    or self.added
90
78
                    or self.removed
91
 
                    or self.renamed
92
 
                    or self.kind_changed)
 
79
                    or self.renamed)
93
80
 
94
81
    def touches_file_id(self, file_id):
95
82
        """Return True if file_id is modified by this delta."""
100
87
        for v in self.renamed:
101
88
            if v[2] == file_id:
102
89
                return True
103
 
        for v in self.kind_changed:
104
 
            if v[1] == file_id:
105
 
                return True
106
90
        return False
107
91
            
108
92
 
109
 
    def show(self, to_file, show_ids=False, show_unchanged=False,
110
 
             short_status=False, indent=''):
 
93
    def show(self, to_file, show_ids=False, show_unchanged=False):
111
94
        """output this delta in status-like form to to_file."""
112
 
        def show_list(files, short_status_letter=''):
 
95
        def show_list(files):
113
96
            for item in files:
114
97
                path, fid, kind = item[:3]
115
98
 
122
105
                    path += '*'
123
106
 
124
107
                if show_ids:
125
 
                    print >>to_file, indent + '%s  %-30s %s' % (short_status_letter,
126
 
                        path, fid)
 
108
                    print >>to_file, '  %-30s %s' % (path, fid)
127
109
                else:
128
 
                    print >>to_file, indent + '%s  %s' % (short_status_letter, path)
 
110
                    print >>to_file, ' ', path
129
111
            
130
112
        if self.removed:
131
 
            if not short_status:
132
 
                print >>to_file, indent + 'removed:'
133
 
                show_list(self.removed)
134
 
            else:
135
 
                show_list(self.removed, 'D')
 
113
            print >>to_file, 'removed:'
 
114
            show_list(self.removed)
136
115
                
137
116
        if self.added:
138
 
            if not short_status:
139
 
                print >>to_file, indent + 'added:'
140
 
                show_list(self.added)
141
 
            else:
142
 
                show_list(self.added, 'A')
 
117
            print >>to_file, 'added:'
 
118
            show_list(self.added)
143
119
 
144
120
        extra_modified = []
145
121
 
146
122
        if self.renamed:
147
 
            short_status_letter = 'R'
148
 
            if not short_status:
149
 
                print >>to_file, indent + 'renamed:'
150
 
                short_status_letter = ''
 
123
            print >>to_file, 'renamed:'
151
124
            for (oldpath, newpath, fid, kind,
152
125
                 text_modified, meta_modified) in self.renamed:
153
126
                if text_modified or meta_modified:
156
129
                if meta_modified:
157
130
                    newpath += '*'
158
131
                if show_ids:
159
 
                    print >>to_file, indent + '%s  %s => %s %s' % (
160
 
                        short_status_letter, oldpath, newpath, fid)
161
 
                else:
162
 
                    print >>to_file, indent + '%s  %s => %s' % (
163
 
                        short_status_letter, oldpath, newpath)
164
 
 
165
 
        if self.kind_changed:
166
 
            if short_status:
167
 
                short_status_letter = 'K'
168
 
            else:
169
 
                print >>to_file, indent + 'kind changed:'
170
 
                short_status_letter = ''
171
 
            for (path, fid, old_kind, new_kind) in self.kind_changed:
172
 
                if show_ids:
173
 
                    suffix = ' '+fid
174
 
                else:
175
 
                    suffix = ''
176
 
                print >>to_file, indent + '%s  %s (%s => %s)%s' % (
177
 
                    short_status_letter, path, old_kind, new_kind, suffix)
178
 
 
 
132
                    print >>to_file, '  %s => %s %s' % (oldpath, newpath, fid)
 
133
                else:
 
134
                    print >>to_file, '  %s => %s' % (oldpath, newpath)
 
135
                    
179
136
        if self.modified or extra_modified:
180
 
            short_status_letter = 'M'
181
 
            if not short_status:
182
 
                print >>to_file, indent + 'modified:'
183
 
                short_status_letter = ''
184
 
            show_list(self.modified, short_status_letter)
185
 
            show_list(extra_modified, short_status_letter)
 
137
            print >>to_file, 'modified:'
 
138
            show_list(self.modified)
 
139
            show_list(extra_modified)
186
140
            
187
141
        if show_unchanged and self.unchanged:
188
 
            if not short_status:
189
 
                print >>to_file, indent + 'unchanged:'
190
 
                show_list(self.unchanged)
191
 
            else:
192
 
                show_list(self.unchanged, 'S')
193
 
 
194
 
        if self.unversioned:
195
 
            print >>to_file, indent + 'unknown:'
196
 
            show_list(self.unversioned)
197
 
 
198
 
    def get_changes_as_text(self, show_ids=False, show_unchanged=False,
199
 
             short_status=False):
200
 
        import StringIO
201
 
        output = StringIO.StringIO()
202
 
        self.show(output, show_ids, show_unchanged, short_status)
203
 
        return output.getvalue()
 
142
            print >>to_file, 'unchanged:'
 
143
            show_list(self.unchanged)
 
144
 
204
145
 
205
146
@deprecated_function(zero_nine)
206
147
def compare_trees(old_tree, new_tree, want_unchanged=False,
211
152
        want_unchanged=want_unchanged,
212
153
        specific_files=specific_files,
213
154
        extra_trees=extra_trees,
214
 
        require_versioned=require_versioned,
215
 
        include_root=False)
216
 
 
217
 
 
218
 
def _compare_trees(old_tree, new_tree, want_unchanged, specific_files,
219
 
                   include_root, extra_trees=None,
220
 
                   want_unversioned=False):
221
 
    """Worker function that implements Tree.changes_from."""
 
155
        require_versioned=require_versioned)
 
156
 
 
157
 
 
158
def _compare_trees(old_tree, new_tree, want_unchanged, specific_file_ids):
 
159
 
 
160
    from osutils import is_inside_any
 
161
    
 
162
    old_inv = old_tree.inventory
 
163
    new_inv = new_tree.inventory
222
164
    delta = TreeDelta()
223
165
    # mutter('start compare_trees')
224
166
 
225
 
    for (file_id, path, content_change, versioned, parent_id, name, kind,
226
 
         executable) in new_tree._iter_changes(old_tree, want_unchanged,
227
 
            specific_files, extra_trees=extra_trees,
228
 
            want_unversioned=want_unversioned):
229
 
        if versioned == (False, False):
230
 
            delta.unversioned.append((path[1], None, kind[1]))
231
 
            continue
232
 
        if not include_root and (None, None) == parent_id:
233
 
            continue
234
 
        fully_present = tuple((versioned[x] and kind[x] is not None) for
235
 
                              x in range(2))
236
 
        if fully_present[0] != fully_present[1]:
237
 
            if fully_present[1] is True:
238
 
                delta.added.append((path[1], file_id, kind[1]))
 
167
    # TODO: Rather than iterating over the whole tree and then filtering, we
 
168
    # could diff just the specified files (if any) and their subtrees.  
 
169
 
 
170
    old_files = old_tree.list_files()
 
171
    new_files = new_tree.list_files()
 
172
 
 
173
    more_old = True
 
174
    more_new = True
 
175
 
 
176
    added = {}
 
177
    removed = {}
 
178
 
 
179
    def get_next(iter):
 
180
        try:
 
181
            return iter.next()
 
182
        except StopIteration:
 
183
            return None, None, None, None, None
 
184
    old_path, old_class, old_kind, old_file_id, old_entry = get_next(old_files)
 
185
    new_path, new_class, new_kind, new_file_id, new_entry = get_next(new_files)
 
186
 
 
187
 
 
188
    def check_matching(old_path, old_entry, new_path, new_entry):
 
189
        """We have matched up 2 file_ids, check for changes."""
 
190
        assert old_entry.kind == new_entry.kind
 
191
 
 
192
        if specific_file_ids:
 
193
            if (old_entry.file_id not in specific_file_ids and 
 
194
                new_entry.file_id not in specific_file_ids):
 
195
                return
 
196
 
 
197
        # temporary hack until all entries are populated before clients 
 
198
        # get them
 
199
        old_entry._read_tree_state(old_path, old_tree)
 
200
        new_entry._read_tree_state(new_path, new_tree)
 
201
        text_modified, meta_modified = new_entry.detect_changes(old_entry)
 
202
        
 
203
        # If the name changes, or the parent_id changes, we have a rename
 
204
        # (if we move a parent, that doesn't count as a rename for the file)
 
205
        if (old_entry.name != new_entry.name 
 
206
            or old_entry.parent_id != new_entry.parent_id):
 
207
            delta.renamed.append((old_path,
 
208
                                  new_path,
 
209
                                  old_entry.file_id, old_entry.kind,
 
210
                                  text_modified, meta_modified))
 
211
        elif text_modified or meta_modified:
 
212
            delta.modified.append((new_path, new_entry.file_id, new_entry.kind,
 
213
                                   text_modified, meta_modified))
 
214
        elif want_unchanged:
 
215
            delta.unchanged.append((new_path, new_entry.file_id, new_entry.kind))
 
216
 
 
217
 
 
218
    def handle_old(path, entry):
 
219
        """old entry without a new entry match
 
220
 
 
221
        Check to see if a matching new entry was already seen as an
 
222
        added file, and switch the pair into being a rename.
 
223
        Otherwise just mark the old entry being removed.
 
224
        """
 
225
        if entry.file_id in added:
 
226
            # Actually this is a rename, we found a new file_id earlier
 
227
            # at a different location, so it is no-longer added
 
228
            x_new_path, x_new_entry = added.pop(entry.file_id)
 
229
            check_matching(path, entry, x_new_path, x_new_entry)
 
230
        else:
 
231
            # We have an old_file_id which doesn't line up with a new_file_id
 
232
            # So this file looks to be removed
 
233
            assert entry.file_id not in removed
 
234
            removed[entry.file_id] = path, entry
 
235
 
 
236
    def handle_new(path, entry):
 
237
        """new entry without an old entry match
 
238
        
 
239
        Check to see if a matching old entry was already seen as a
 
240
        removal, and change the pair into a rename.
 
241
        Otherwise just mark the new entry as an added file.
 
242
        """
 
243
        if entry.file_id in removed:
 
244
            # We saw this file_id earlier at an old different location
 
245
            # it is no longer removed, just renamed
 
246
            x_old_path, x_old_entry = removed.pop(entry.file_id)
 
247
            check_matching(x_old_path, x_old_entry, path, entry)
 
248
        else:
 
249
            # We have a new file which does not match an old file
 
250
            # mark it as added
 
251
            assert entry.file_id not in added
 
252
            added[entry.file_id] = path, entry
 
253
 
 
254
    while old_path or new_path:
 
255
        # list_files() returns files in alphabetical path sorted order
 
256
        if old_path == new_path:
 
257
            if old_file_id == new_file_id:
 
258
                # This is the common case, the files are in the same place
 
259
                # check if there were any content changes
 
260
 
 
261
                if old_file_id is None:
 
262
                    # We have 2 unversioned files, no deltas possible???
 
263
                    pass
 
264
                else:
 
265
                    check_matching(old_path, old_entry, new_path, new_entry)
239
266
            else:
240
 
                assert fully_present[0] is True
241
 
                delta.removed.append((path[0], file_id, kind[0]))
242
 
        elif fully_present[0] is False:
243
 
            continue
244
 
        elif name[0] != name[1] or parent_id[0] != parent_id[1]:
245
 
            # If the name changes, or the parent_id changes, we have a rename
246
 
            # (if we move a parent, that doesn't count as a rename for the
247
 
            # file)
248
 
            delta.renamed.append((path[0],
249
 
                                  path[1],
250
 
                                  file_id,
251
 
                                  kind[1],
252
 
                                  content_change,
253
 
                                  (executable[0] != executable[1])))
254
 
        elif kind[0] != kind[1]:
255
 
            delta.kind_changed.append((path[1], file_id, kind[0], kind[1]))
256
 
        elif content_change is True or executable[0] != executable[1]:
257
 
            delta.modified.append((path[1], file_id, kind[1],
258
 
                                   content_change,
259
 
                                   (executable[0] != executable[1])))
260
 
        else:
261
 
            delta.unchanged.append((path[1], file_id, kind[1]))
 
267
                # The ids don't match, so we have to handle them both
 
268
                # separately.
 
269
                if old_file_id is not None:
 
270
                    handle_old(old_path, old_entry)
 
271
 
 
272
                if new_file_id is not None:
 
273
                    handle_new(new_path, new_entry)
 
274
 
 
275
            # The two entries were at the same path, so increment both sides
 
276
            old_path, old_class, old_kind, old_file_id, old_entry = get_next(old_files)
 
277
            new_path, new_class, new_kind, new_file_id, new_entry = get_next(new_files)
 
278
        elif new_path is None or (old_path is not None and old_path < new_path):
 
279
            # Assume we don't match, only process old_path
 
280
            if old_file_id is not None:
 
281
                handle_old(old_path, old_entry)
 
282
            # old_path came first, so increment it, trying to match up
 
283
            old_path, old_class, old_kind, old_file_id, old_entry = get_next(old_files)
 
284
        elif new_path is not None:
 
285
            # new_path came first, so increment it, trying to match up
 
286
            if new_file_id is not None:
 
287
                handle_new(new_path, new_entry)
 
288
            new_path, new_class, new_kind, new_file_id, new_entry = get_next(new_files)
 
289
 
 
290
    # Now we have a set of added and removed files, mark them all
 
291
    for old_path, old_entry in removed.itervalues():
 
292
        if specific_file_ids:
 
293
            if not old_entry.file_id in specific_file_ids:
 
294
                continue
 
295
        delta.removed.append((old_path, old_entry.file_id, old_entry.kind))
 
296
    for new_path, new_entry in added.itervalues():
 
297
        if specific_file_ids:
 
298
            if not new_entry.file_id in specific_file_ids:
 
299
                continue
 
300
        delta.added.append((new_path, new_entry.file_id, new_entry.kind))
262
301
 
263
302
    delta.removed.sort()
264
303
    delta.added.sort()
269
308
    delta.unchanged.sort()
270
309
 
271
310
    return delta
272
 
 
273
 
 
274
 
class _ChangeReporter(object):
275
 
    """Report changes between two trees"""
276
 
 
277
 
    def __init__(self, output=None, suppress_root_add=True,
278
 
                 output_file=None, unversioned_filter=None):
279
 
        """Constructor
280
 
 
281
 
        :param output: a function with the signature of trace.note, i.e.
282
 
            accepts a format and parameters.
283
 
        :param supress_root_add: If true, adding the root will be ignored
284
 
            (i.e. when a tree has just been initted)
285
 
        :param output_file: If supplied, a file-like object to write to.
286
 
            Only one of output and output_file may be supplied.
287
 
        :param unversioned_filter: A filter function to be called on 
288
 
            unversioned files. This should return True to ignore a path.
289
 
            By default, no filtering takes place.
290
 
        """
291
 
        if output_file is not None:
292
 
            if output is not None:
293
 
                raise BzrError('Cannot specify both output and output_file')
294
 
            def output(fmt, *args):
295
 
                output_file.write((fmt % args) + '\n')
296
 
        self.output = output
297
 
        if self.output is None:
298
 
            from bzrlib import trace
299
 
            self.output = trace.note
300
 
        self.suppress_root_add = suppress_root_add
301
 
        self.modified_map = {'kind changed': 'K',
302
 
                             'unchanged': ' ',
303
 
                             'created': 'N',
304
 
                             'modified': 'M',
305
 
                             'deleted': 'D'}
306
 
        self.versioned_map = {'added': '+', # versioned target
307
 
                              'unchanged': ' ', # versioned in both
308
 
                              'removed': '-', # versioned in source
309
 
                              'unversioned': '?', # versioned in neither
310
 
                              }
311
 
        self.unversioned_filter = unversioned_filter
312
 
 
313
 
    def report(self, file_id, paths, versioned, renamed, modified, exe_change,
314
 
               kind):
315
 
        """Report one change to a file
316
 
 
317
 
        :param file_id: The file_id of the file
318
 
        :param path: The old and new paths as generated by Tree._iter_changes.
319
 
        :param versioned: may be 'added', 'removed', 'unchanged', or
320
 
            'unversioned.
321
 
        :param renamed: may be True or False
322
 
        :param modified: may be 'created', 'deleted', 'kind changed',
323
 
            'modified' or 'unchanged'.
324
 
        :param exe_change: True if the execute bit has changed
325
 
        :param kind: A pair of file kinds, as generated by Tree._iter_changes.
326
 
            None indicates no file present.
327
 
        """
328
 
        if paths[1] == '' and versioned == 'added' and self.suppress_root_add:
329
 
            return
330
 
        if versioned == 'unversioned':
331
 
            # skip ignored unversioned files if needed.
332
 
            if self.unversioned_filter is not None:
333
 
                if self.unversioned_filter(paths[1]):
334
 
                    return
335
 
            # dont show a content change in the output.
336
 
            modified = 'unchanged'
337
 
        # we show both paths in the following situations:
338
 
        # the file versioning is unchanged AND
339
 
        # ( the path is different OR
340
 
        #   the kind is different)
341
 
        if (versioned == 'unchanged' and
342
 
            (renamed or modified == 'kind changed')):
343
 
            if renamed:
344
 
                # on a rename, we show old and new
345
 
                old_path, path = paths
346
 
            else:
347
 
                # if its not renamed, we're showing both for kind changes
348
 
                # so only show the new path
349
 
                old_path, path = paths[1], paths[1]
350
 
            # if the file is not missing in the source, we show its kind
351
 
            # when we show two paths.
352
 
            if kind[0] is not None:
353
 
                old_path += osutils.kind_marker(kind[0])
354
 
            old_path += " => "
355
 
        elif versioned == 'removed':
356
 
            # not present in target
357
 
            old_path = ""
358
 
            path = paths[0]
359
 
        else:
360
 
            old_path = ""
361
 
            path = paths[1]
362
 
        if renamed:
363
 
            rename = "R"
364
 
        else:
365
 
            rename = self.versioned_map[versioned]
366
 
        # we show the old kind on the new path when the content is deleted.
367
 
        if modified == 'deleted':
368
 
            path += osutils.kind_marker(kind[0])
369
 
        # otherwise we always show the current kind when there is one
370
 
        elif kind[1] is not None:
371
 
            path += osutils.kind_marker(kind[1])
372
 
        if exe_change:
373
 
            exe = '*'
374
 
        else:
375
 
            exe = ' '
376
 
        self.output("%s%s%s %s%s", rename, self.modified_map[modified], exe,
377
 
                    old_path, path)
378
 
 
379
 
 
380
 
def report_changes(change_iterator, reporter):
381
 
    """Report the changes from a change iterator.
382
 
 
383
 
    This is essentially a translation from low-level to medium-level changes.
384
 
    Further processing may be required to produce a human-readable output.
385
 
    Unfortunately, some tree-changing operations are very complex
386
 
    :change_iterator: an iterator or sequence of changes in the format
387
 
        generated by Tree._iter_changes
388
 
    :param reporter: The _ChangeReporter that will report the changes.
389
 
    """
390
 
    versioned_change_map = {
391
 
        (True, True)  : 'unchanged',
392
 
        (True, False) : 'removed',
393
 
        (False, True) : 'added',
394
 
        (False, False): 'unversioned',
395
 
        }
396
 
    for (file_id, path, content_change, versioned, parent_id, name, kind,
397
 
         executable) in change_iterator:
398
 
        exe_change = False
399
 
        # files are "renamed" if they are moved or if name changes, as long
400
 
        # as it had a value
401
 
        if None not in name and None not in parent_id and\
402
 
            (name[0] != name[1] or parent_id[0] != parent_id[1]):
403
 
            renamed = True
404
 
        else:
405
 
            renamed = False
406
 
        if kind[0] != kind[1]:
407
 
            if kind[0] is None:
408
 
                modified = "created"
409
 
            elif kind[1] is None:
410
 
                modified = "deleted"
411
 
            else:
412
 
                modified = "kind changed"
413
 
        else:
414
 
            if content_change:
415
 
                modified = "modified"
416
 
            else:
417
 
                modified = "unchanged"
418
 
            if kind[1] == "file":
419
 
                exe_change = (executable[0] != executable[1])
420
 
        versioned_change = versioned_change_map[versioned]
421
 
        reporter.report(file_id, path, versioned_change, renamed, modified,
422
 
                        exe_change, kind)