← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/delta.py

  • Committer: John Arbash Meinel
  • Date: 2007-08-14 19:29:56 UTC
  • mto: This revision was merged to the branch mainline in revision 2698.
  • Revision ID: john@arbash-meinel.com-20070814192956-34h336i5q3m34ods
Switch bzr.dev to 0.91 development

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/delta.py
1
 
# -*- coding: UTF-8 -*-
2
 
 
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
 
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
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
 
 
7
#
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
 
 
12
#
13
13
# You should have received a copy of the GNU General Public License
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
    )
17
21
from bzrlib.inventory import InventoryEntry
18
22
from bzrlib.trace import mutter
 
23
from bzrlib.symbol_versioning import deprecated_function, zero_nine
 
24
 
19
25
 
20
26
class TreeDelta(object):
21
27
    """Describes changes from one tree to another.
32
38
        (path, id, kind, text_modified, meta_modified)
33
39
    unchanged
34
40
        (path, id, kind)
 
41
    unversioned
 
42
        (path, kind)
35
43
 
36
44
    Each id is listed only once.
37
45
 
50
58
        self.added = []
51
59
        self.removed = []
52
60
        self.renamed = []
 
61
        self.kind_changed = []
53
62
        self.modified = []
54
63
        self.unchanged = []
 
64
        self.unversioned = []
55
65
 
56
66
    def __eq__(self, other):
57
67
        if not isinstance(other, TreeDelta):
60
70
               and self.removed == other.removed \
61
71
               and self.renamed == other.renamed \
62
72
               and self.modified == other.modified \
63
 
               and self.unchanged == other.unchanged
 
73
               and self.unchanged == other.unchanged \
 
74
               and self.kind_changed == other.kind_changed \
 
75
               and self.unversioned == other.unversioned
64
76
 
65
77
    def __ne__(self, other):
66
78
        return not (self == other)
67
79
 
68
80
    def __repr__(self):
69
 
        return "TreeDelta(added=%r, removed=%r, renamed=%r, modified=%r," \
70
 
            " unchanged=%r)" % (self.added, self.removed, self.renamed,
71
 
            self.modified, self.unchanged)
 
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)
72
86
 
73
87
    def has_changed(self):
74
88
        return bool(self.modified
75
89
                    or self.added
76
90
                    or self.removed
77
 
                    or self.renamed)
 
91
                    or self.renamed
 
92
                    or self.kind_changed)
78
93
 
79
94
    def touches_file_id(self, file_id):
80
95
        """Return True if file_id is modified by this delta."""
85
100
        for v in self.renamed:
86
101
            if v[2] == file_id:
87
102
                return True
 
103
        for v in self.kind_changed:
 
104
            if v[1] == file_id:
 
105
                return True
88
106
        return False
89
107
            
90
108
 
91
 
    def show(self, to_file, show_ids=False, show_unchanged=False):
92
 
        def show_list(files):
 
109
    def show(self, to_file, show_ids=False, show_unchanged=False,
 
110
             short_status=False, indent=''):
 
111
        """output this delta in status-like form to to_file."""
 
112
        def show_list(files, short_status_letter=''):
93
113
            for item in files:
94
114
                path, fid, kind = item[:3]
95
115
 
102
122
                    path += '*'
103
123
 
104
124
                if show_ids:
105
 
                    print >>to_file, '  %-30s %s' % (path, fid)
 
125
                    print >>to_file, indent + '%s  %-30s %s' % (short_status_letter,
 
126
                        path, fid)
106
127
                else:
107
 
                    print >>to_file, ' ', path
 
128
                    print >>to_file, indent + '%s  %s' % (short_status_letter, path)
108
129
            
109
130
        if self.removed:
110
 
            print >>to_file, 'removed:'
111
 
            show_list(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')
112
136
                
113
137
        if self.added:
114
 
            print >>to_file, 'added:'
115
 
            show_list(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')
116
143
 
117
144
        extra_modified = []
118
145
 
119
146
        if self.renamed:
120
 
            print >>to_file, 'renamed:'
 
147
            short_status_letter = 'R'
 
148
            if not short_status:
 
149
                print >>to_file, indent + 'renamed:'
 
150
                short_status_letter = ''
121
151
            for (oldpath, newpath, fid, kind,
122
152
                 text_modified, meta_modified) in self.renamed:
123
153
                if text_modified or meta_modified:
126
156
                if meta_modified:
127
157
                    newpath += '*'
128
158
                if show_ids:
129
 
                    print >>to_file, '  %s => %s %s' % (oldpath, newpath, fid)
130
 
                else:
131
 
                    print >>to_file, '  %s => %s' % (oldpath, newpath)
132
 
                    
 
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
 
133
179
        if self.modified or extra_modified:
134
 
            print >>to_file, 'modified:'
135
 
            show_list(self.modified)
136
 
            show_list(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
186
            
138
187
        if show_unchanged and self.unchanged:
139
 
            print >>to_file, 'unchanged:'
140
 
            show_list(self.unchanged)
141
 
 
142
 
 
143
 
 
144
 
def compare_trees(old_tree, new_tree, want_unchanged=False, specific_files=None):
145
 
    """Describe changes from one tree to another.
146
 
 
147
 
    Returns a TreeDelta with details of added, modified, renamed, and
148
 
    deleted entries.
149
 
 
150
 
    The root entry is specifically exempt.
151
 
 
152
 
    This only considers versioned files.
153
 
 
154
 
    want_unchanged
155
 
        If true, also list files unchanged from one version to
156
 
        the next.
157
 
 
158
 
    specific_files
159
 
        If true, only check for changes to specified names or
160
 
        files within them.
161
 
    """
162
 
 
163
 
    from osutils import is_inside_any
164
 
    
165
 
    old_inv = old_tree.inventory
166
 
    new_inv = new_tree.inventory
 
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()
 
204
 
 
205
@deprecated_function(zero_nine)
 
206
def compare_trees(old_tree, new_tree, want_unchanged=False,
 
207
                  specific_files=None, extra_trees=None,
 
208
                  require_versioned=False):
 
209
    """compare_trees was deprecated in 0.10. Please see Tree.changes_from."""
 
210
    return new_tree.changes_from(old_tree,
 
211
        want_unchanged=want_unchanged,
 
212
        specific_files=specific_files,
 
213
        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
                   require_versioned=False, want_unversioned=False):
 
221
    """Worker function that implements Tree.changes_from."""
167
222
    delta = TreeDelta()
168
 
    mutter('start compare_trees')
169
 
 
170
 
    # TODO: match for specific files can be rather smarter by finding
171
 
    # the IDs of those files up front and then considering only that.
172
 
 
173
 
    for file_id in old_tree:
174
 
        if file_id in new_tree:
175
 
            old_ie = old_inv[file_id]
176
 
            new_ie = new_inv[file_id]
177
 
 
178
 
            kind = old_ie.kind
179
 
            assert kind == new_ie.kind
180
 
            
181
 
            assert kind in InventoryEntry.known_kinds, \
182
 
                   'invalid file kind %r' % kind
183
 
 
184
 
            if kind == 'root_directory':
185
 
                continue
186
 
            
187
 
            if specific_files:
188
 
                if (not is_inside_any(specific_files, old_inv.id2path(file_id)) 
189
 
                    and not is_inside_any(specific_files, new_inv.id2path(file_id))):
190
 
                    continue
191
 
 
192
 
            # temporary hack until all entries are populated before clients 
193
 
            # get them
194
 
            old_path = old_inv.id2path(file_id)
195
 
            new_path = new_inv.id2path(file_id)
196
 
            old_ie._read_tree_state(old_path, old_tree)
197
 
            new_ie._read_tree_state(new_path, new_tree)
198
 
            text_modified, meta_modified = new_ie.detect_changes(old_ie)
199
 
 
200
 
            # TODO: Can possibly avoid calculating path strings if the
201
 
            # two files are unchanged and their names and parents are
202
 
            # the same and the parents are unchanged all the way up.
203
 
            # May not be worthwhile.
204
 
            
205
 
            if (old_ie.name != new_ie.name
206
 
                or old_ie.parent_id != new_ie.parent_id):
207
 
                delta.renamed.append((old_path,
208
 
                                      new_path,
209
 
                                      file_id, kind,
210
 
                                      text_modified, meta_modified))
211
 
            elif text_modified or meta_modified:
212
 
                delta.modified.append((new_path, file_id, kind,
213
 
                                       text_modified, meta_modified))
214
 
            elif want_unchanged:
215
 
                delta.unchanged.append((new_path, file_id, kind))
 
223
    # mutter('start compare_trees')
 
224
 
 
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
            require_versioned=require_versioned,
 
229
            want_unversioned=want_unversioned):
 
230
        if versioned == (False, False):
 
231
            delta.unversioned.append((path[1], None, kind[1]))
 
232
            continue
 
233
        if not include_root and (None, None) == parent_id:
 
234
            continue
 
235
        fully_present = tuple((versioned[x] and kind[x] is not None) for
 
236
                              x in range(2))
 
237
        if fully_present[0] != fully_present[1]:
 
238
            if fully_present[1] is True:
 
239
                delta.added.append((path[1], file_id, kind[1]))
 
240
            else:
 
241
                assert fully_present[0] is True
 
242
                delta.removed.append((path[0], file_id, kind[0]))
 
243
        elif fully_present[0] is False:
 
244
            continue
 
245
        elif name[0] != name[1] or parent_id[0] != parent_id[1]:
 
246
            # If the name changes, or the parent_id changes, we have a rename
 
247
            # (if we move a parent, that doesn't count as a rename for the
 
248
            # file)
 
249
            delta.renamed.append((path[0],
 
250
                                  path[1],
 
251
                                  file_id,
 
252
                                  kind[1],
 
253
                                  content_change,
 
254
                                  (executable[0] != executable[1])))
 
255
        elif kind[0] != kind[1]:
 
256
            delta.kind_changed.append((path[1], file_id, kind[0], kind[1]))
 
257
        elif content_change is True or executable[0] != executable[1]:
 
258
            delta.modified.append((path[1], file_id, kind[1],
 
259
                                   content_change,
 
260
                                   (executable[0] != executable[1])))
216
261
        else:
217
 
            kind = old_inv.get_file_kind(file_id)
218
 
            if kind == 'root_directory':
219
 
                continue
220
 
            old_path = old_inv.id2path(file_id)
221
 
            if specific_files:
222
 
                if not is_inside_any(specific_files, old_path):
223
 
                    continue
224
 
            delta.removed.append((old_path, file_id, kind))
 
262
            delta.unchanged.append((path[1], file_id, kind[1]))
225
263
 
226
 
    mutter('start looking for new files')
227
 
    for file_id in new_inv:
228
 
        if file_id in old_inv or file_id not in new_tree:
229
 
            continue
230
 
        kind = new_inv.get_file_kind(file_id)
231
 
        if kind == 'root_directory':
232
 
            continue
233
 
        new_path = new_inv.id2path(file_id)
234
 
        if specific_files:
235
 
            if not is_inside_any(specific_files, new_path):
236
 
                continue
237
 
        delta.added.append((new_path, file_id, kind))
238
 
            
239
264
    delta.removed.sort()
240
265
    delta.added.sort()
241
266
    delta.renamed.sort()
 
267
    # TODO: jam 20060529 These lists shouldn't need to be sorted
 
268
    #       since we added them in alphabetical order.
242
269
    delta.modified.sort()
243
270
    delta.unchanged.sort()
244
271
 
245
272
    return delta
 
273
 
 
274
 
 
275
class _ChangeReporter(object):
 
276
    """Report changes between two trees"""
 
277
 
 
278
    def __init__(self, output=None, suppress_root_add=True,
 
279
                 output_file=None, unversioned_filter=None):
 
280
        """Constructor
 
281
 
 
282
        :param output: a function with the signature of trace.note, i.e.
 
283
            accepts a format and parameters.
 
284
        :param supress_root_add: If true, adding the root will be ignored
 
285
            (i.e. when a tree has just been initted)
 
286
        :param output_file: If supplied, a file-like object to write to.
 
287
            Only one of output and output_file may be supplied.
 
288
        :param unversioned_filter: A filter function to be called on 
 
289
            unversioned files. This should return True to ignore a path.
 
290
            By default, no filtering takes place.
 
291
        """
 
292
        if output_file is not None:
 
293
            if output is not None:
 
294
                raise BzrError('Cannot specify both output and output_file')
 
295
            def output(fmt, *args):
 
296
                output_file.write((fmt % args) + '\n')
 
297
        self.output = output
 
298
        if self.output is None:
 
299
            from bzrlib import trace
 
300
            self.output = trace.note
 
301
        self.suppress_root_add = suppress_root_add
 
302
        self.modified_map = {'kind changed': 'K',
 
303
                             'unchanged': ' ',
 
304
                             'created': 'N',
 
305
                             'modified': 'M',
 
306
                             'deleted': 'D'}
 
307
        self.versioned_map = {'added': '+', # versioned target
 
308
                              'unchanged': ' ', # versioned in both
 
309
                              'removed': '-', # versioned in source
 
310
                              'unversioned': '?', # versioned in neither
 
311
                              }
 
312
        self.unversioned_filter = unversioned_filter
 
313
 
 
314
    def report(self, file_id, paths, versioned, renamed, modified, exe_change,
 
315
               kind):
 
316
        """Report one change to a file
 
317
 
 
318
        :param file_id: The file_id of the file
 
319
        :param path: The old and new paths as generated by Tree._iter_changes.
 
320
        :param versioned: may be 'added', 'removed', 'unchanged', or
 
321
            'unversioned.
 
322
        :param renamed: may be True or False
 
323
        :param modified: may be 'created', 'deleted', 'kind changed',
 
324
            'modified' or 'unchanged'.
 
325
        :param exe_change: True if the execute bit has changed
 
326
        :param kind: A pair of file kinds, as generated by Tree._iter_changes.
 
327
            None indicates no file present.
 
328
        """
 
329
        if paths[1] == '' and versioned == 'added' and self.suppress_root_add:
 
330
            return
 
331
        if versioned == 'unversioned':
 
332
            # skip ignored unversioned files if needed.
 
333
            if self.unversioned_filter is not None:
 
334
                if self.unversioned_filter(paths[1]):
 
335
                    return
 
336
            # dont show a content change in the output.
 
337
            modified = 'unchanged'
 
338
        # we show both paths in the following situations:
 
339
        # the file versioning is unchanged AND
 
340
        # ( the path is different OR
 
341
        #   the kind is different)
 
342
        if (versioned == 'unchanged' and
 
343
            (renamed or modified == 'kind changed')):
 
344
            if renamed:
 
345
                # on a rename, we show old and new
 
346
                old_path, path = paths
 
347
            else:
 
348
                # if its not renamed, we're showing both for kind changes
 
349
                # so only show the new path
 
350
                old_path, path = paths[1], paths[1]
 
351
            # if the file is not missing in the source, we show its kind
 
352
            # when we show two paths.
 
353
            if kind[0] is not None:
 
354
                old_path += osutils.kind_marker(kind[0])
 
355
            old_path += " => "
 
356
        elif versioned == 'removed':
 
357
            # not present in target
 
358
            old_path = ""
 
359
            path = paths[0]
 
360
        else:
 
361
            old_path = ""
 
362
            path = paths[1]
 
363
        if renamed:
 
364
            rename = "R"
 
365
        else:
 
366
            rename = self.versioned_map[versioned]
 
367
        # we show the old kind on the new path when the content is deleted.
 
368
        if modified == 'deleted':
 
369
            path += osutils.kind_marker(kind[0])
 
370
        # otherwise we always show the current kind when there is one
 
371
        elif kind[1] is not None:
 
372
            path += osutils.kind_marker(kind[1])
 
373
        if exe_change:
 
374
            exe = '*'
 
375
        else:
 
376
            exe = ' '
 
377
        self.output("%s%s%s %s%s", rename, self.modified_map[modified], exe,
 
378
                    old_path, path)
 
379
 
 
380
 
 
381
def report_changes(change_iterator, reporter):
 
382
    """Report the changes from a change iterator.
 
383
 
 
384
    This is essentially a translation from low-level to medium-level changes.
 
385
    Further processing may be required to produce a human-readable output.
 
386
    Unfortunately, some tree-changing operations are very complex
 
387
    :change_iterator: an iterator or sequence of changes in the format
 
388
        generated by Tree._iter_changes
 
389
    :param reporter: The _ChangeReporter that will report the changes.
 
390
    """
 
391
    versioned_change_map = {
 
392
        (True, True)  : 'unchanged',
 
393
        (True, False) : 'removed',
 
394
        (False, True) : 'added',
 
395
        (False, False): 'unversioned',
 
396
        }
 
397
    for (file_id, path, content_change, versioned, parent_id, name, kind,
 
398
         executable) in change_iterator:
 
399
        exe_change = False
 
400
        # files are "renamed" if they are moved or if name changes, as long
 
401
        # as it had a value
 
402
        if None not in name and None not in parent_id and\
 
403
            (name[0] != name[1] or parent_id[0] != parent_id[1]):
 
404
            renamed = True
 
405
        else:
 
406
            renamed = False
 
407
        if kind[0] != kind[1]:
 
408
            if kind[0] is None:
 
409
                modified = "created"
 
410
            elif kind[1] is None:
 
411
                modified = "deleted"
 
412
            else:
 
413
                modified = "kind changed"
 
414
        else:
 
415
            if content_change:
 
416
                modified = "modified"
 
417
            else:
 
418
                modified = "unchanged"
 
419
            if kind[1] == "file":
 
420
                exe_change = (executable[0] != executable[1])
 
421
        versioned_change = versioned_change_map[versioned]
 
422
        reporter.report(file_id, path, versioned_change, renamed, modified,
 
423
                        exe_change, kind)