← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/delta.py

  • Committer: Robert Collins
  • Date: 2005-10-06 22:15:52 UTC
  • mfrom: (1185.13.2)
  • mto: This revision was merged to the branch mainline in revision 1420.
  • Revision ID: robertc@robertcollins.net-20051006221552-9b15c96fa504e0ad
merge from upstream

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.
56
50
        self.added = []
57
51
        self.removed = []
58
52
        self.renamed = []
59
 
        self.kind_changed = []
60
53
        self.modified = []
61
54
        self.unchanged = []
62
55
 
67
60
               and self.removed == other.removed \
68
61
               and self.renamed == other.renamed \
69
62
               and self.modified == other.modified \
70
 
               and self.unchanged == other.unchanged \
71
 
               and self.kind_changed == other.kind_changed
 
63
               and self.unchanged == other.unchanged
72
64
 
73
65
    def __ne__(self, other):
74
66
        return not (self == other)
75
67
 
76
68
    def __repr__(self):
77
 
        return "TreeDelta(added=%r, removed=%r, renamed=%r," \
78
 
            " kind_changed=%r, modified=%r, unchanged=%r)" % (self.added,
79
 
            self.removed, self.renamed, self.kind_changed, self.modified,
80
 
            self.unchanged)
 
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
72
 
82
73
    def has_changed(self):
83
74
        return bool(self.modified
84
75
                    or self.added
85
76
                    or self.removed
86
 
                    or self.renamed
87
 
                    or self.kind_changed)
 
77
                    or self.renamed)
88
78
 
89
79
    def touches_file_id(self, file_id):
90
80
        """Return True if file_id is modified by this delta."""
95
85
        for v in self.renamed:
96
86
            if v[2] == file_id:
97
87
                return True
98
 
        for v in self.kind_changed:
99
 
            if v[1] == file_id:
100
 
                return True
101
88
        return False
102
89
            
103
90
 
104
 
    def show(self, to_file, show_ids=False, show_unchanged=False,
105
 
             short_status=False):
106
 
        """output this delta in status-like form to to_file."""
107
 
        def show_list(files, short_status_letter=''):
 
91
    def show(self, to_file, show_ids=False, show_unchanged=False):
 
92
        def show_list(files):
108
93
            for item in files:
109
94
                path, fid, kind = item[:3]
110
95
 
117
102
                    path += '*'
118
103
 
119
104
                if show_ids:
120
 
                    print >>to_file, '%s  %-30s %s' % (short_status_letter,
121
 
                        path, fid)
 
105
                    print >>to_file, '  %-30s %s' % (path, fid)
122
106
                else:
123
 
                    print >>to_file, '%s  %s' % (short_status_letter, path)
 
107
                    print >>to_file, ' ', path
124
108
            
125
109
        if self.removed:
126
 
            if not short_status:
127
 
                print >>to_file, 'removed:'
128
 
                show_list(self.removed)
129
 
            else:
130
 
                show_list(self.removed, 'D')
 
110
            print >>to_file, 'removed:'
 
111
            show_list(self.removed)
131
112
                
132
113
        if self.added:
133
 
            if not short_status:
134
 
                print >>to_file, 'added:'
135
 
                show_list(self.added)
136
 
            else:
137
 
                show_list(self.added, 'A')
138
 
 
139
 
        extra_modified = []
 
114
            print >>to_file, 'added:'
 
115
            show_list(self.added)
140
116
 
141
117
        if self.renamed:
142
 
            short_status_letter = 'R'
143
 
            if not short_status:
144
 
                print >>to_file, 'renamed:'
145
 
                short_status_letter = ''
 
118
            print >>to_file, 'renamed:'
146
119
            for (oldpath, newpath, fid, kind,
147
120
                 text_modified, meta_modified) in self.renamed:
148
 
                if text_modified or meta_modified:
149
 
                    extra_modified.append((newpath, fid, kind,
150
 
                                           text_modified, meta_modified))
151
121
                if meta_modified:
152
122
                    newpath += '*'
153
123
                if show_ids:
154
 
                    print >>to_file, '%s  %s => %s %s' % (
155
 
                        short_status_letter, oldpath, newpath, fid)
156
 
                else:
157
 
                    print >>to_file, '%s  %s => %s' % (
158
 
                        short_status_letter, oldpath, newpath)
159
 
 
160
 
        if self.kind_changed:
161
 
            if short_status:
162
 
                short_status_letter = 'K'
163
 
            else:
164
 
                print >>to_file, 'kind changed:'
165
 
                short_status_letter = ''
166
 
            for (path, fid, old_kind, new_kind) in self.kind_changed:
167
 
                if show_ids:
168
 
                    suffix = ' '+fid
169
 
                else:
170
 
                    suffix = ''
171
 
                print >>to_file, '%s  %s (%s => %s)%s' % (
172
 
                    short_status_letter, path, old_kind, new_kind, suffix)
173
 
 
174
 
        if self.modified or extra_modified:
175
 
            short_status_letter = 'M'
176
 
            if not short_status:
177
 
                print >>to_file, 'modified:'
178
 
                short_status_letter = ''
179
 
            show_list(self.modified, short_status_letter)
180
 
            show_list(extra_modified, short_status_letter)
 
124
                    print >>to_file, '  %s => %s %s' % (oldpath, newpath, fid)
 
125
                else:
 
126
                    print >>to_file, '  %s => %s' % (oldpath, newpath)
 
127
                    
 
128
        if self.modified:
 
129
            print >>to_file, 'modified:'
 
130
            show_list(self.modified)
181
131
            
182
132
        if show_unchanged and self.unchanged:
183
 
            if not short_status:
184
 
                print >>to_file, 'unchanged:'
185
 
                show_list(self.unchanged)
186
 
            else:
187
 
                show_list(self.unchanged, 'S')
188
 
 
189
 
 
190
 
@deprecated_function(zero_nine)
191
 
def compare_trees(old_tree, new_tree, want_unchanged=False,
192
 
                  specific_files=None, extra_trees=None,
193
 
                  require_versioned=False):
194
 
    """compare_trees was deprecated in 0.10. Please see Tree.changes_from."""
195
 
    return new_tree.changes_from(old_tree,
196
 
        want_unchanged=want_unchanged,
197
 
        specific_files=specific_files,
198
 
        extra_trees=extra_trees,
199
 
        require_versioned=require_versioned,
200
 
        include_root=False)
201
 
 
202
 
 
203
 
def _compare_trees(old_tree, new_tree, want_unchanged, specific_files,
204
 
                   include_root, extra_trees=None):
 
133
            print >>to_file, 'unchanged:'
 
134
            show_list(self.unchanged)
 
135
 
 
136
 
 
137
 
 
138
def compare_trees(old_tree, new_tree, want_unchanged=False, specific_files=None):
 
139
    """Describe changes from one tree to another.
 
140
 
 
141
    Returns a TreeDelta with details of added, modified, renamed, and
 
142
    deleted entries.
 
143
 
 
144
    The root entry is specifically exempt.
 
145
 
 
146
    This only considers versioned files.
 
147
 
 
148
    want_unchanged
 
149
        If true, also list files unchanged from one version to
 
150
        the next.
 
151
 
 
152
    specific_files
 
153
        If true, only check for changes to specified names or
 
154
        files within them.
 
155
    """
 
156
 
 
157
    from osutils import is_inside_any
 
158
    
 
159
    old_inv = old_tree.inventory
 
160
    new_inv = new_tree.inventory
205
161
    delta = TreeDelta()
206
 
    # mutter('start compare_trees')
207
 
 
208
 
    for (file_id, path, content_change, versioned, parent_id, name, kind,
209
 
         executable) in new_tree._iter_changes(old_tree, want_unchanged,
210
 
            specific_files, extra_trees=extra_trees):
211
 
        if not include_root and (None, None) == parent_id:
212
 
            continue
213
 
        fully_present = tuple((versioned[x] and kind[x] is not None) for
214
 
                              x in range(2))
215
 
        if fully_present[0] != fully_present[1]:
216
 
            if fully_present[1] is True:
217
 
                delta.added.append((path, file_id, kind[1]))
218
 
            else:
219
 
                assert fully_present[0] is True
220
 
                old_path = old_tree.id2path(file_id)
221
 
                delta.removed.append((old_path, file_id, kind[0]))
222
 
        elif fully_present[0] is False:
223
 
            continue
224
 
        elif name[0] != name[1] or parent_id[0] != parent_id[1]:
225
 
            # If the name changes, or the parent_id changes, we have a rename
226
 
            # (if we move a parent, that doesn't count as a rename for the
227
 
            # file)
228
 
            old_path = old_tree.id2path(file_id)
229
 
            delta.renamed.append((old_path,
230
 
                                  path,
231
 
                                  file_id, 
232
 
                                  kind[1],
233
 
                                  content_change, 
234
 
                                  (executable[0] != executable[1])))
235
 
        elif kind[0] != kind[1]:
236
 
            delta.kind_changed.append((path, file_id, kind[0], kind[1]))
237
 
        elif content_change is True or executable[0] != executable[1]:
238
 
            delta.modified.append((path, file_id, kind[1],
239
 
                                   content_change, 
240
 
                                   (executable[0] != executable[1])))
 
162
    mutter('start compare_trees')
 
163
 
 
164
    # TODO: match for specific files can be rather smarter by finding
 
165
    # the IDs of those files up front and then considering only that.
 
166
 
 
167
    for file_id in old_tree:
 
168
        if file_id in new_tree:
 
169
            old_ie = old_inv[file_id]
 
170
            new_ie = new_inv[file_id]
 
171
 
 
172
            kind = old_ie.kind
 
173
            assert kind == new_ie.kind
 
174
            
 
175
            assert kind in InventoryEntry.known_kinds, \
 
176
                   'invalid file kind %r' % kind
 
177
 
 
178
            if kind == 'root_directory':
 
179
                continue
 
180
            
 
181
            if specific_files:
 
182
                if (not is_inside_any(specific_files, old_inv.id2path(file_id)) 
 
183
                    and not is_inside_any(specific_files, new_inv.id2path(file_id))):
 
184
                    continue
 
185
 
 
186
            # temporary hack until all entries are populated before clients 
 
187
            # get them
 
188
            old_path = old_inv.id2path(file_id)
 
189
            new_path = new_inv.id2path(file_id)
 
190
            old_ie._read_tree_state(old_path, old_tree)
 
191
            new_ie._read_tree_state(new_path, new_tree)
 
192
            text_modified, meta_modified = new_ie.detect_changes(old_ie)
 
193
 
 
194
            # TODO: Can possibly avoid calculating path strings if the
 
195
            # two files are unchanged and their names and parents are
 
196
            # the same and the parents are unchanged all the way up.
 
197
            # May not be worthwhile.
 
198
            
 
199
            if (old_ie.name != new_ie.name
 
200
                or old_ie.parent_id != new_ie.parent_id):
 
201
                delta.renamed.append((old_path,
 
202
                                      new_path,
 
203
                                      file_id, kind,
 
204
                                      text_modified, meta_modified))
 
205
            elif text_modified or meta_modified:
 
206
                delta.modified.append((new_path, file_id, kind,
 
207
                                       text_modified, meta_modified))
 
208
            elif want_unchanged:
 
209
                delta.unchanged.append((new_path, file_id, kind))
241
210
        else:
242
 
            delta.unchanged.append((path, file_id, kind[1]))
 
211
            kind = old_inv.get_file_kind(file_id)
 
212
            if kind == 'root_directory':
 
213
                continue
 
214
            old_path = old_inv.id2path(file_id)
 
215
            if specific_files:
 
216
                if not is_inside_any(specific_files, old_path):
 
217
                    continue
 
218
            delta.removed.append((old_path, file_id, kind))
243
219
 
 
220
    mutter('start looking for new files')
 
221
    for file_id in new_inv:
 
222
        if file_id in old_inv:
 
223
            continue
 
224
        kind = new_inv.get_file_kind(file_id)
 
225
        if kind == 'root_directory':
 
226
            continue
 
227
        new_path = new_inv.id2path(file_id)
 
228
        if specific_files:
 
229
            if not is_inside_any(specific_files, new_path):
 
230
                continue
 
231
        delta.added.append((new_path, file_id, kind))
 
232
            
244
233
    delta.removed.sort()
245
234
    delta.added.sort()
246
235
    delta.renamed.sort()
247
 
    # TODO: jam 20060529 These lists shouldn't need to be sorted
248
 
    #       since we added them in alphabetical order.
249
236
    delta.modified.sort()
250
237
    delta.unchanged.sort()
251
238
 
252
239
    return delta
253
 
 
254
 
 
255
 
class ChangeReporter(object):
256
 
    """Report changes between two trees"""
257
 
 
258
 
    def __init__(self, old_inventory, output=None, suppress_root_add=True,
259
 
                 output_file=None):
260
 
        """Constructor
261
 
 
262
 
        :param old_inventory: The inventory of the old tree
263
 
        :param output: a function with the signature of trace.note, i.e.
264
 
            accepts a format and parameters.
265
 
        :param supress_root_add: If true, adding the root will be ignored
266
 
            (i.e. when a tree has just been initted)
267
 
        :param output_file: If supplied, a file-like object to write to.
268
 
            Only one of output and output_file may be supplied.
269
 
        """
270
 
        self.old_inventory = old_inventory
271
 
        if output_file is not None:
272
 
            if output is not None:
273
 
                raise BzrError('Cannot specify both output and output_file')
274
 
            def output(fmt, *args):
275
 
                output_file.write((fmt % args) + '\n')
276
 
        self.output = output
277
 
        if self.output is None:
278
 
            from bzrlib import trace
279
 
            self.output = trace.note
280
 
        self.suppress_root_add = suppress_root_add
281
 
 
282
 
    def report(self, file_id, path, versioned, renamed, modified, exe_change,
283
 
               kind):
284
 
        """Report one change to a file
285
 
 
286
 
        :param file_id: The file_id of the file
287
 
        :param path: The path the file has (or would have) in the tree (as
288
 
            generated by Tree._iter_changes)
289
 
        :param versioned: may be 'added', 'removed', or 'unchanged'
290
 
        :param renamed: may be True or False
291
 
        :param modified: may be 'created', 'deleted', 'kind changed',
292
 
            'modified' or 'unchanged'.
293
 
        :param exe_change: True if the execute bit has changed
294
 
        :param kind: A pair of file kinds, as generated by Tree._iter_changes.
295
 
            None indicates no file present.
296
 
        """
297
 
        if path == '' and versioned == 'added' and self.suppress_root_add:
298
 
            return
299
 
        modified_map = {'kind changed': 'K',
300
 
                        'unchanged': ' ',
301
 
                        'created': 'N',
302
 
                        'modified': 'M',
303
 
                        'deleted': 'D'}
304
 
        versioned_map = {'added': '+',
305
 
                         'unchanged': ' ',
306
 
                         'removed': '-'}
307
 
        old_path = ""
308
 
        if renamed:
309
 
            old_path = self.old_inventory.id2path(file_id)
310
 
            rename = "R"
311
 
        else:
312
 
            rename = versioned_map[versioned]
313
 
        if modified == 'kind changed':
314
 
            if old_path == "":
315
 
                old_path = path
316
 
        if modified == 'deleted':
317
 
            path += osutils.kind_marker(kind[0])
318
 
        elif kind[1] is not None:
319
 
            path += osutils.kind_marker(kind[1])
320
 
        if old_path != "":
321
 
            if kind[0] is not None:
322
 
                old_path += osutils.kind_marker(kind[0])
323
 
            old_path += " => "
324
 
        if exe_change:
325
 
            exe = '*'
326
 
        else:
327
 
            exe = ' '
328
 
        self.output("%s%s%s %s%s", rename, modified_map[modified], exe,
329
 
                    old_path, path)
330
 
 
331
 
 
332
 
def report_changes(change_iterator, reporter):
333
 
    """Report the changes from a change iterator.
334
 
 
335
 
    This is essentially a translation from low-level to medium-level changes.
336
 
    Further processing may be required to produce a human-readable output.
337
 
    Unfortunately, some tree-changing operations are very complex
338
 
    :change_iterator: an iterator or sequence of changes in the format
339
 
        generated by Tree._iter_changes
340
 
    :param reporter: The ChangeReporter that will report the changes.
341
 
    """
342
 
    for (file_id, path, content_change, versioned, parent_id, name, kind,
343
 
         executable) in change_iterator:
344
 
        exe_change = False
345
 
        # files are "renamed" if they are moved or if name changes, as long
346
 
        # as it had a value
347
 
        if None not in name and None not in parent_id and\
348
 
            (name[0] != name[1] or parent_id[0] != parent_id[1]):
349
 
            renamed = True
350
 
        else:
351
 
            renamed = False
352
 
        if kind[0] != kind[1]:
353
 
            if kind[0] is None:
354
 
                modified = "created"
355
 
            elif kind[1] is None:
356
 
                modified = "deleted"
357
 
            else:
358
 
                modified = "kind changed"
359
 
        else:
360
 
            if content_change:
361
 
                modified = "modified"
362
 
            else:
363
 
                modified = "unchanged"
364
 
            if kind[1] == "file":
365
 
                exe_change = (executable[0] != executable[1])
366
 
        if versioned[0] != versioned[1]:
367
 
            if versioned[0]:
368
 
                versioned_change = "removed"
369
 
            else:
370
 
                versioned_change = "added"
371
 
        else:
372
 
            versioned_change = "unchanged"
373
 
        reporter.report(file_id, path, versioned_change, renamed, modified,
374
 
                        exe_change, kind)