← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/delta.py

  • Committer: Patch Queue Manager
  • Date: 2012-02-25 15:28:53 UTC
  • mfrom: (6475.1.1 bzr.dev)
  • Revision ID: pqm@pqm.ubuntu.com-20120225152853-nz1w2gsfv7lc1yq4
(jelmer) Update documentation to mention command hooks landed in bzr 2.6
 rather than 2.5. (Brian de Alwis)

Show diffs side-by-side

added added

removed removed

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