← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/delta.py

[merge] bzr.dev 2255, resolve conflicts, update copyrights

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/delta.py
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
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
from bzrlib import (
18
18
    errors,
19
19
    osutils,
20
20
    )
21
21
from bzrlib.inventory import InventoryEntry
22
 
from bzrlib.trace import mutter, is_quiet
23
 
from bzrlib.symbol_versioning import deprecated_function
 
22
from bzrlib.trace import mutter
 
23
from bzrlib.symbol_versioning import deprecated_function, zero_nine
24
24
 
25
25
 
26
26
class TreeDelta(object):
27
27
    """Describes changes from one tree to another.
28
28
 
29
 
    Contains seven lists:
 
29
    Contains four lists:
30
30
 
31
31
    added
32
32
        (path, id, kind)
34
34
        (path, id, kind)
35
35
    renamed
36
36
        (oldpath, newpath, id, kind, text_modified, meta_modified)
37
 
    kind_changed
38
 
        (path, id, old_kind, new_kind)
39
37
    modified
40
38
        (path, id, kind, text_modified, meta_modified)
41
39
    unchanged
42
40
        (path, id, kind)
43
 
    unversioned
44
 
        (path, None, kind)
45
41
 
46
42
    Each id is listed only once.
47
43
 
60
56
        self.added = []
61
57
        self.removed = []
62
58
        self.renamed = []
63
 
        self.kind_changed = []
64
59
        self.modified = []
65
60
        self.unchanged = []
66
 
        self.unversioned = []
67
61
 
68
62
    def __eq__(self, other):
69
63
        if not isinstance(other, TreeDelta):
72
66
               and self.removed == other.removed \
73
67
               and self.renamed == other.renamed \
74
68
               and self.modified == other.modified \
75
 
               and self.unchanged == other.unchanged \
76
 
               and self.kind_changed == other.kind_changed \
77
 
               and self.unversioned == other.unversioned
 
69
               and self.unchanged == other.unchanged
78
70
 
79
71
    def __ne__(self, other):
80
72
        return not (self == other)
81
73
 
82
74
    def __repr__(self):
83
 
        return "TreeDelta(added=%r, removed=%r, renamed=%r," \
84
 
            " kind_changed=%r, modified=%r, unchanged=%r," \
85
 
            " unversioned=%r)" % (self.added,
86
 
            self.removed, self.renamed, self.kind_changed, self.modified,
87
 
            self.unchanged, self.unversioned)
 
75
        return "TreeDelta(added=%r, removed=%r, renamed=%r, modified=%r," \
 
76
            " unchanged=%r)" % (self.added, self.removed, self.renamed,
 
77
            self.modified, self.unchanged)
88
78
 
89
79
    def has_changed(self):
90
80
        return bool(self.modified
91
81
                    or self.added
92
82
                    or self.removed
93
 
                    or self.renamed
94
 
                    or self.kind_changed)
 
83
                    or self.renamed)
95
84
 
96
85
    def touches_file_id(self, file_id):
97
86
        """Return True if file_id is modified by this delta."""
102
91
        for v in self.renamed:
103
92
            if v[2] == file_id:
104
93
                return True
105
 
        for v in self.kind_changed:
106
 
            if v[1] == file_id:
107
 
                return True
108
94
        return False
109
 
 
110
 
 
111
 
    def show(self, to_file, show_ids=False, show_unchanged=False,
112
 
             short_status=False, indent='',
113
 
             filter=None):
114
 
        """Output this delta in status-like form to to_file.
115
 
 
116
 
        :param to_file: A file-like object where the output is displayed.
117
 
 
118
 
        :param show_ids: Output the file ids if True.
119
 
 
120
 
        :param show_unchanged: Output the unchanged files if True.
121
 
 
122
 
        :param short_status: Single-line status if True.
123
 
 
124
 
        :param indent: Added at the beginning of all output lines (for merged
125
 
            revisions).
126
 
 
127
 
        :param filter: A callable receiving a path and a file id and
128
 
            returning True if the path should be displayed.
129
 
        """
130
 
 
131
 
        def decorate_path(path, kind, meta_modified=None):
132
 
            if kind == 'directory':
133
 
                path += '/'
134
 
            elif kind == 'symlink':
135
 
                path += '@'
136
 
            if meta_modified:
137
 
                path += '*'
138
 
            return path
139
 
 
140
 
        def show_more_renamed(item):
141
 
            (oldpath, file_id, kind,
142
 
             text_modified, meta_modified, newpath) = item
143
 
            dec_new_path = decorate_path(newpath, kind, meta_modified)
144
 
            to_file.write(' => %s' % dec_new_path)
145
 
            if text_modified or meta_modified:
146
 
                extra_modified.append((newpath, file_id, kind,
147
 
                                       text_modified, meta_modified))
148
 
 
149
 
        def show_more_kind_changed(item):
150
 
            (path, file_id, old_kind, new_kind) = item
151
 
            to_file.write(' (%s => %s)' % (old_kind, new_kind))
152
 
 
153
 
        def show_path(path, file_id, kind, meta_modified,
154
 
                      default_format, with_file_id_format):
155
 
            dec_path = decorate_path(path, kind, meta_modified)
156
 
            if show_ids:
157
 
                to_file.write(with_file_id_format % dec_path)
158
 
            else:
159
 
                to_file.write(default_format % dec_path)
160
 
 
161
 
        def show_list(files, long_status_name, short_status_letter,
162
 
                      default_format='%s', with_file_id_format='%-30s',
163
 
                      show_more=None):
164
 
            if files:
165
 
                header_shown = False
166
 
                if short_status:
167
 
                    prefix = short_status_letter
 
95
            
 
96
 
 
97
    def show(self, to_file, show_ids=False, show_unchanged=False, short_status=False):
 
98
        """output this delta in status-like form to to_file."""
 
99
        def show_list(files, short_status_letter=''):
 
100
            for item in files:
 
101
                path, fid, kind = item[:3]
 
102
 
 
103
                if kind == 'directory':
 
104
                    path += '/'
 
105
                elif kind == 'symlink':
 
106
                    path += '@'
 
107
 
 
108
                if len(item) == 5 and item[4]:
 
109
                    path += '*'
 
110
 
 
111
                if show_ids:
 
112
                    print >>to_file, '%s  %-30s %s' % (short_status_letter, path, fid)
168
113
                else:
169
 
                    prefix = ''
170
 
                prefix = indent + prefix + '  '
171
 
 
172
 
                for item in files:
173
 
                    path, file_id, kind = item[:3]
174
 
                    if (filter is not None and not filter(path, file_id)):
175
 
                        continue
176
 
                    if not header_shown and not short_status:
177
 
                        to_file.write(indent + long_status_name + ':\n')
178
 
                        header_shown = True
179
 
                    meta_modified = None
180
 
                    if len(item) == 5:
181
 
                        meta_modified = item[4]
182
 
 
183
 
                    to_file.write(prefix)
184
 
                    show_path(path, file_id, kind, meta_modified,
185
 
                              default_format, with_file_id_format)
186
 
                    if show_more is not None:
187
 
                        show_more(item)
188
 
                    if show_ids:
189
 
                        to_file.write(' %s' % file_id)
190
 
                    to_file.write('\n')
191
 
 
192
 
        show_list(self.removed, 'removed', 'D')#
193
 
        show_list(self.added, 'added', 'A')
 
114
                    print >>to_file, '%s  %s' % (short_status_letter, path)
 
115
            
 
116
        if self.removed:
 
117
            if not short_status:
 
118
                print >>to_file, 'removed:'
 
119
                show_list(self.removed)
 
120
            else:
 
121
                show_list(self.removed, 'D')
 
122
                
 
123
        if self.added:
 
124
            if not short_status:
 
125
                print >>to_file, 'added:'
 
126
                show_list(self.added)
 
127
            else:
 
128
                show_list(self.added, 'A')
 
129
 
194
130
        extra_modified = []
195
 
        # Reorder self.renamed tuples so that all lists share the same
196
 
        # order for their 3 first fields and that they also begin like
197
 
        # the self.modified tuples
198
 
        renamed = [(p, i, k, tm, mm, np)
199
 
                   for  p, np, i, k, tm, mm  in self.renamed]
200
 
        show_list(renamed, 'renamed', 'R', with_file_id_format='%s',
201
 
                  show_more=show_more_renamed)
202
 
        show_list(self.kind_changed, 'kind changed', 'K',
203
 
                  with_file_id_format='%s',
204
 
                  show_more=show_more_kind_changed)
205
 
        show_list(self.modified + extra_modified, 'modified', 'M')
206
 
        if show_unchanged:
207
 
            show_list(self.unchanged, 'unchanged', 'S')
208
 
 
209
 
        show_list(self.unversioned, 'unknown', ' ')
210
 
 
211
 
    def get_changes_as_text(self, show_ids=False, show_unchanged=False,
212
 
             short_status=False):
213
 
        import StringIO
214
 
        output = StringIO.StringIO()
215
 
        self.show(output, show_ids, show_unchanged, short_status)
216
 
        return output.getvalue()
217
 
 
218
 
 
219
 
def _compare_trees(old_tree, new_tree, want_unchanged, specific_files,
220
 
                   include_root, extra_trees=None,
221
 
                   require_versioned=False, want_unversioned=False):
222
 
    """Worker function that implements Tree.changes_from."""
 
131
 
 
132
        if self.renamed:
 
133
            short_status_letter = 'R'
 
134
            if not short_status:
 
135
                print >>to_file, 'renamed:'
 
136
                short_status_letter = ''
 
137
            for (oldpath, newpath, fid, kind,
 
138
                 text_modified, meta_modified) in self.renamed:
 
139
                if text_modified or meta_modified:
 
140
                    extra_modified.append((newpath, fid, kind,
 
141
                                           text_modified, meta_modified))
 
142
                if meta_modified:
 
143
                    newpath += '*'
 
144
                if show_ids:
 
145
                    print >>to_file, '%s  %s => %s %s' % (short_status_letter,
 
146
                                                          oldpath, newpath, fid)
 
147
                else:
 
148
                    print >>to_file, '%s  %s => %s' % (short_status_letter,
 
149
                                                       oldpath, newpath)
 
150
                    
 
151
        if self.modified or extra_modified:
 
152
            short_status_letter = 'M'
 
153
            if not short_status:
 
154
                print >>to_file, 'modified:'
 
155
                short_status_letter = ''
 
156
            show_list(self.modified, short_status_letter)
 
157
            show_list(extra_modified, short_status_letter)
 
158
            
 
159
        if show_unchanged and self.unchanged:
 
160
            if not short_status:
 
161
                print >>to_file, 'unchanged:'
 
162
                show_list(self.unchanged)
 
163
            else:
 
164
                show_list(self.unchanged, 'S')
 
165
 
 
166
 
 
167
@deprecated_function(zero_nine)
 
168
def compare_trees(old_tree, new_tree, want_unchanged=False,
 
169
                  specific_files=None, extra_trees=None,
 
170
                  require_versioned=False):
 
171
    """compare_trees was deprecated in 0.10. Please see Tree.changes_from."""
 
172
    return new_tree.changes_from(old_tree,
 
173
        want_unchanged=want_unchanged,
 
174
        specific_files=specific_files,
 
175
        extra_trees=extra_trees,
 
176
        require_versioned=require_versioned,
 
177
        include_root=False)
 
178
 
 
179
 
 
180
def _compare_trees(old_tree, new_tree, want_unchanged, specific_file_ids,
 
181
                   include_root):
223
182
    delta = TreeDelta()
224
183
    # mutter('start compare_trees')
225
184
 
226
185
    for (file_id, path, content_change, versioned, parent_id, name, kind,
227
 
         executable) in new_tree.iter_changes(old_tree, want_unchanged,
228
 
            specific_files, extra_trees=extra_trees,
229
 
            require_versioned=require_versioned,
230
 
            want_unversioned=want_unversioned):
231
 
        if versioned == (False, False):
232
 
            delta.unversioned.append((path[1], None, kind[1]))
233
 
            continue
 
186
         executable) in new_tree._iter_changes(old_tree, want_unchanged, 
 
187
                                               specific_file_ids):
234
188
        if not include_root and (None, None) == parent_id:
235
189
            continue
 
190
        assert kind[0] == kind[1] or None in kind
 
191
        # the only 'kind change' permitted is creation/deletion
236
192
        fully_present = tuple((versioned[x] and kind[x] is not None) for
237
193
                              x in range(2))
238
194
        if fully_present[0] != fully_present[1]:
239
195
            if fully_present[1] is True:
240
 
                delta.added.append((path[1], file_id, kind[1]))
 
196
                delta.added.append((path, file_id, kind[1]))
241
197
            else:
242
 
                delta.removed.append((path[0], file_id, kind[0]))
 
198
                assert fully_present[0] is True
 
199
                old_path = old_tree.id2path(file_id)
 
200
                delta.removed.append((old_path, file_id, kind[0]))
243
201
        elif fully_present[0] is False:
244
202
            continue
245
203
        elif name[0] != name[1] or parent_id[0] != parent_id[1]:
246
204
            # If the name changes, or the parent_id changes, we have a rename
247
205
            # (if we move a parent, that doesn't count as a rename for the
248
206
            # file)
249
 
            delta.renamed.append((path[0],
250
 
                                  path[1],
251
 
                                  file_id,
 
207
            old_path = old_tree.id2path(file_id)
 
208
            delta.renamed.append((old_path,
 
209
                                  path,
 
210
                                  file_id, 
252
211
                                  kind[1],
253
 
                                  content_change,
 
212
                                  content_change, 
254
213
                                  (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 or executable[0] != executable[1]:
258
 
            delta.modified.append((path[1], file_id, kind[1],
259
 
                                   content_change,
 
214
        elif content_change is True or executable[0] != executable[1]:
 
215
            delta.modified.append((path, file_id, kind[1],
 
216
                                   content_change, 
260
217
                                   (executable[0] != executable[1])))
261
218
        else:
262
 
            delta.unchanged.append((path[1], file_id, kind[1]))
 
219
            delta.unchanged.append((path, file_id, kind[1]))
263
220
 
264
221
    delta.removed.sort()
265
222
    delta.added.sort()
272
229
    return delta
273
230
 
274
231
 
275
 
class _ChangeReporter(object):
 
232
class ChangeReporter(object):
276
233
    """Report changes between two trees"""
277
234
 
278
 
    def __init__(self, output=None, suppress_root_add=True,
279
 
                 output_file=None, unversioned_filter=None, view_info=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
 
        :param view_info: A tuple of view_name,view_files if only
292
 
            items inside a view are to be reported on, or None for
293
 
            no view filtering.
294
 
        """
295
 
        if output_file is not None:
296
 
            if output is not None:
297
 
                raise BzrError('Cannot specify both output and output_file')
298
 
            def output(fmt, *args):
299
 
                output_file.write((fmt % args) + '\n')
 
235
    def __init__(self, old_inventory, output=None):
 
236
        self.old_inventory = old_inventory
300
237
        self.output = output
301
238
        if self.output is None:
302
239
            from bzrlib import trace
303
240
            self.output = trace.note
304
 
        self.suppress_root_add = suppress_root_add
305
 
        self.modified_map = {'kind changed': 'K',
306
 
                             'unchanged': ' ',
307
 
                             'created': 'N',
308
 
                             'modified': 'M',
309
 
                             'deleted': 'D'}
310
 
        self.versioned_map = {'added': '+', # versioned target
311
 
                              'unchanged': ' ', # versioned in both
312
 
                              'removed': '-', # versioned in source
313
 
                              'unversioned': '?', # versioned in neither
314
 
                              }
315
 
        self.unversioned_filter = unversioned_filter
316
 
        if view_info is None:
317
 
            self.view_name = None
318
 
            self.view_files = []
319
 
        else:
320
 
            self.view_name = view_info[0]
321
 
            self.view_files = view_info[1]
322
 
            self.output("Operating on whole tree but only reporting on "
323
 
                        "'%s' view." % (self.view_name,))
324
241
 
325
 
    def report(self, file_id, paths, versioned, renamed, modified, exe_change,
 
242
    def report(self, file_id, path, versioned, renamed, modified, exe_change,
326
243
               kind):
327
244
        """Report one change to a file
328
245
 
329
246
        :param file_id: The file_id of the file
330
 
        :param path: The old and new paths as generated by Tree.iter_changes.
331
 
        :param versioned: may be 'added', 'removed', 'unchanged', or
332
 
            'unversioned.
 
247
        :param path: The path the file has (or would have) in the tree (as
 
248
            generated by Tree._iter_changes)
 
249
        :param versioned: may be 'added', 'removed', or 'unchanged'
333
250
        :param renamed: may be True or False
334
251
        :param modified: may be 'created', 'deleted', 'kind changed',
335
252
            'modified' or 'unchanged'.
336
253
        :param exe_change: True if the execute bit has changed
337
 
        :param kind: A pair of file kinds, as generated by Tree.iter_changes.
 
254
        :param kind: A pair of file kinds, as generated by Tree._iter_changes.
338
255
            None indicates no file present.
339
256
        """
340
 
        if is_quiet():
341
 
            return
342
 
        if paths[1] == '' and versioned == 'added' and self.suppress_root_add:
343
 
            return
344
 
        if self.view_files and not osutils.is_inside_any(self.view_files,
345
 
            paths[1]):
346
 
            return
347
 
        if versioned == 'unversioned':
348
 
            # skip ignored unversioned files if needed.
349
 
            if self.unversioned_filter is not None:
350
 
                if self.unversioned_filter(paths[1]):
351
 
                    return
352
 
            # dont show a content change in the output.
353
 
            modified = 'unchanged'
354
 
        # we show both paths in the following situations:
355
 
        # the file versioning is unchanged AND
356
 
        # ( the path is different OR
357
 
        #   the kind is different)
358
 
        if (versioned == 'unchanged' and
359
 
            (renamed or modified == 'kind changed')):
360
 
            if renamed:
361
 
                # on a rename, we show old and new
362
 
                old_path, path = paths
363
 
            else:
364
 
                # if it's not renamed, we're showing both for kind changes
365
 
                # so only show the new path
366
 
                old_path, path = paths[1], paths[1]
367
 
            # if the file is not missing in the source, we show its kind
368
 
            # when we show two paths.
369
 
            if kind[0] is not None:
370
 
                old_path += osutils.kind_marker(kind[0])
371
 
            old_path += " => "
372
 
        elif versioned == 'removed':
373
 
            # not present in target
374
 
            old_path = ""
375
 
            path = paths[0]
376
 
        else:
377
 
            old_path = ""
378
 
            path = paths[1]
 
257
        modified_map = {'kind changed': 'K',
 
258
                        'unchanged': ' ',
 
259
                        'created': 'N',
 
260
                        'modified': 'M',
 
261
                        'deleted': 'D'}
 
262
        versioned_map = {'added': '+',
 
263
                         'unchanged': ' ',
 
264
                         'removed': '-'}
 
265
        old_path = ""
379
266
        if renamed:
 
267
            old_path = self.old_inventory.id2path(file_id)
380
268
            rename = "R"
381
269
        else:
382
 
            rename = self.versioned_map[versioned]
383
 
        # we show the old kind on the new path when the content is deleted.
 
270
            rename = versioned_map[versioned]
 
271
        if modified == 'kind changed':
 
272
            if old_path == "":
 
273
                old_path = path
384
274
        if modified == 'deleted':
385
275
            path += osutils.kind_marker(kind[0])
386
 
        # otherwise we always show the current kind when there is one
387
 
        elif kind[1] is not None:
 
276
        else:
388
277
            path += osutils.kind_marker(kind[1])
 
278
        if old_path != "":
 
279
            old_path += "%s => " % osutils.kind_marker(kind[0])
389
280
        if exe_change:
390
281
            exe = '*'
391
282
        else:
392
283
            exe = ' '
393
 
        self.output("%s%s%s %s%s", rename, self.modified_map[modified], exe,
 
284
        self.output("%s%s%s %s%s", rename, modified_map[modified], exe,
394
285
                    old_path, path)
395
286
 
396
287
 
401
292
    Further processing may be required to produce a human-readable output.
402
293
    Unfortunately, some tree-changing operations are very complex
403
294
    :change_iterator: an iterator or sequence of changes in the format
404
 
        generated by Tree.iter_changes
405
 
    :param reporter: The _ChangeReporter that will report the changes.
 
295
        generated by Tree._iter_changes
 
296
    :param reporter: The ChangeReporter that will report the changes.
406
297
    """
407
 
    versioned_change_map = {
408
 
        (True, True)  : 'unchanged',
409
 
        (True, False) : 'removed',
410
 
        (False, True) : 'added',
411
 
        (False, False): 'unversioned',
412
 
        }
413
298
    for (file_id, path, content_change, versioned, parent_id, name, kind,
414
299
         executable) in change_iterator:
415
300
        exe_change = False
416
301
        # files are "renamed" if they are moved or if name changes, as long
417
302
        # as it had a value
418
 
        if None not in name and None not in parent_id and\
419
 
            (name[0] != name[1] or parent_id[0] != parent_id[1]):
 
303
        if None not in name and (name[0] != name[1] or
 
304
                                 parent_id[0] != parent_id[1]):
420
305
            renamed = True
421
306
        else:
422
307
            renamed = False
434
319
                modified = "unchanged"
435
320
            if kind[1] == "file":
436
321
                exe_change = (executable[0] != executable[1])
437
 
        versioned_change = versioned_change_map[versioned]
 
322
        if versioned[0] != versioned[1]:
 
323
            if versioned[0]:
 
324
                versioned_change = "removed"
 
325
            else:
 
326
                versioned_change = "added"
 
327
        else:
 
328
            versioned_change = "unchanged"
438
329
        reporter.report(file_id, path, versioned_change, renamed, modified,
439
330
                        exe_change, kind)