← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/delta.py

  • Committer: Martin Pool
  • Date: 2006-03-21 12:26:54 UTC
  • mto: This revision was merged to the branch mainline in revision 1621.
  • Revision ID: mbp@sourcefrog.net-20060321122654-514047ed65795a17
New developer commands 'weave-list' and 'weave-join'.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/delta.py
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
2
 
#
 
1
# -*- coding: UTF-8 -*-
 
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
 
    )
21
17
from bzrlib.inventory import InventoryEntry
22
18
from bzrlib.trace import mutter
23
 
from bzrlib.symbol_versioning import deprecated_function, zero_nine
24
 
 
25
19
 
26
20
class TreeDelta(object):
27
21
    """Describes changes from one tree to another.
38
32
        (path, id, kind, text_modified, meta_modified)
39
33
    unchanged
40
34
        (path, id, kind)
41
 
    unversioned
42
 
        (path, kind)
43
35
 
44
36
    Each id is listed only once.
45
37
 
58
50
        self.added = []
59
51
        self.removed = []
60
52
        self.renamed = []
61
 
        self.kind_changed = []
62
53
        self.modified = []
63
54
        self.unchanged = []
64
 
        self.unversioned = []
65
55
 
66
56
    def __eq__(self, other):
67
57
        if not isinstance(other, TreeDelta):
70
60
               and self.removed == other.removed \
71
61
               and self.renamed == other.renamed \
72
62
               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
 
63
               and self.unchanged == other.unchanged
76
64
 
77
65
    def __ne__(self, other):
78
66
        return not (self == other)
79
67
 
80
68
    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)
 
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)
86
72
 
87
73
    def has_changed(self):
88
74
        return bool(self.modified
89
75
                    or self.added
90
76
                    or self.removed
91
 
                    or self.renamed
92
 
                    or self.kind_changed)
 
77
                    or self.renamed)
93
78
 
94
79
    def touches_file_id(self, file_id):
95
80
        """Return True if file_id is modified by this delta."""
100
85
        for v in self.renamed:
101
86
            if v[2] == file_id:
102
87
                return True
103
 
        for v in self.kind_changed:
104
 
            if v[1] == file_id:
105
 
                return True
106
88
        return False
107
89
            
108
90
 
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=''):
 
91
    def show(self, to_file, show_ids=False, show_unchanged=False):
 
92
        def show_list(files):
113
93
            for item in files:
114
94
                path, fid, kind = item[:3]
115
95
 
122
102
                    path += '*'
123
103
 
124
104
                if show_ids:
125
 
                    print >>to_file, indent + '%s  %-30s %s' % (short_status_letter,
126
 
                        path, fid)
 
105
                    print >>to_file, '  %-30s %s' % (path, fid)
127
106
                else:
128
 
                    print >>to_file, indent + '%s  %s' % (short_status_letter, path)
 
107
                    print >>to_file, ' ', path
129
108
            
130
109
        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')
 
110
            print >>to_file, 'removed:'
 
111
            show_list(self.removed)
136
112
                
137
113
        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')
 
114
            print >>to_file, 'added:'
 
115
            show_list(self.added)
143
116
 
144
117
        extra_modified = []
145
118
 
146
119
        if self.renamed:
147
 
            short_status_letter = 'R'
148
 
            if not short_status:
149
 
                print >>to_file, indent + 'renamed:'
150
 
                short_status_letter = ''
 
120
            print >>to_file, 'renamed:'
151
121
            for (oldpath, newpath, fid, kind,
152
122
                 text_modified, meta_modified) in self.renamed:
153
123
                if text_modified or meta_modified:
156
126
                if meta_modified:
157
127
                    newpath += '*'
158
128
                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
 
 
 
129
                    print >>to_file, '  %s => %s %s' % (oldpath, newpath, fid)
 
130
                else:
 
131
                    print >>to_file, '  %s => %s' % (oldpath, newpath)
 
132
                    
179
133
        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)
 
134
            print >>to_file, 'modified:'
 
135
            show_list(self.modified)
 
136
            show_list(extra_modified)
186
137
            
187
138
        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()
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
 
                   want_unversioned=False):
221
 
    """Worker function that implements Tree.changes_from."""
 
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
    old_tree.lock_read()
 
164
    try:
 
165
        new_tree.lock_read()
 
166
        try:
 
167
            return _compare_trees(old_tree, new_tree, want_unchanged,
 
168
                                  specific_files)
 
169
        finally:
 
170
            new_tree.unlock()
 
171
    finally:
 
172
        old_tree.unlock()
 
173
 
 
174
 
 
175
def _compare_trees(old_tree, new_tree, want_unchanged, specific_files):
 
176
 
 
177
    from osutils import is_inside_any
 
178
    
 
179
    old_inv = old_tree.inventory
 
180
    new_inv = new_tree.inventory
222
181
    delta = TreeDelta()
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
 
            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]))
239
 
            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])))
 
182
    mutter('start compare_trees')
 
183
 
 
184
    # TODO: match for specific files can be rather smarter by finding
 
185
    # the IDs of those files up front and then considering only that.
 
186
 
 
187
    for file_id in old_tree:
 
188
        if file_id in new_tree:
 
189
            old_ie = old_inv[file_id]
 
190
            new_ie = new_inv[file_id]
 
191
 
 
192
            kind = old_ie.kind
 
193
            assert kind == new_ie.kind
 
194
            
 
195
            assert kind in InventoryEntry.known_kinds, \
 
196
                   'invalid file kind %r' % kind
 
197
 
 
198
            if kind == 'root_directory':
 
199
                continue
 
200
            
 
201
            if specific_files:
 
202
                if (not is_inside_any(specific_files, old_inv.id2path(file_id)) 
 
203
                    and not is_inside_any(specific_files, new_inv.id2path(file_id))):
 
204
                    continue
 
205
 
 
206
            # temporary hack until all entries are populated before clients 
 
207
            # get them
 
208
            old_path = old_inv.id2path(file_id)
 
209
            new_path = new_inv.id2path(file_id)
 
210
            old_ie._read_tree_state(old_path, old_tree)
 
211
            new_ie._read_tree_state(new_path, new_tree)
 
212
            text_modified, meta_modified = new_ie.detect_changes(old_ie)
 
213
 
 
214
            # TODO: Can possibly avoid calculating path strings if the
 
215
            # two files are unchanged and their names and parents are
 
216
            # the same and the parents are unchanged all the way up.
 
217
            # May not be worthwhile.
 
218
            
 
219
            if (old_ie.name != new_ie.name
 
220
                or old_ie.parent_id != new_ie.parent_id):
 
221
                delta.renamed.append((old_path,
 
222
                                      new_path,
 
223
                                      file_id, kind,
 
224
                                      text_modified, meta_modified))
 
225
            elif text_modified or meta_modified:
 
226
                delta.modified.append((new_path, file_id, kind,
 
227
                                       text_modified, meta_modified))
 
228
            elif want_unchanged:
 
229
                delta.unchanged.append((new_path, file_id, kind))
260
230
        else:
261
 
            delta.unchanged.append((path[1], file_id, kind[1]))
 
231
            kind = old_inv.get_file_kind(file_id)
 
232
            if kind == 'root_directory':
 
233
                continue
 
234
            old_path = old_inv.id2path(file_id)
 
235
            if specific_files:
 
236
                if not is_inside_any(specific_files, old_path):
 
237
                    continue
 
238
            delta.removed.append((old_path, file_id, kind))
262
239
 
 
240
    mutter('start looking for new files')
 
241
    for file_id in new_inv:
 
242
        if file_id in old_inv or file_id not in new_tree:
 
243
            continue
 
244
        kind = new_inv.get_file_kind(file_id)
 
245
        if kind == 'root_directory':
 
246
            continue
 
247
        new_path = new_inv.id2path(file_id)
 
248
        if specific_files:
 
249
            if not is_inside_any(specific_files, new_path):
 
250
                continue
 
251
        delta.added.append((new_path, file_id, kind))
 
252
            
263
253
    delta.removed.sort()
264
254
    delta.added.sort()
265
255
    delta.renamed.sort()
266
 
    # TODO: jam 20060529 These lists shouldn't need to be sorted
267
 
    #       since we added them in alphabetical order.
268
256
    delta.modified.sort()
269
257
    delta.unchanged.sort()
270
258
 
271
259
    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)