← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/delta.py

Don't ignore bzrlib/plugins -- really bad idea because they can have bad 
old plugins lying around!

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/delta.py
1
 
# Copyright (C) 2005, 2006 Canonical
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
17
from bzrlib.inventory import InventoryEntry
18
18
from bzrlib.trace import mutter
19
 
from bzrlib.symbol_versioning import deprecated_function, zero_nine
20
 
 
21
19
 
22
20
class TreeDelta(object):
23
21
    """Describes changes from one tree to another.
91
89
            
92
90
 
93
91
    def show(self, to_file, show_ids=False, show_unchanged=False):
94
 
        """output this delta in status-like form to to_file."""
95
92
        def show_list(files):
96
93
            for item in files:
97
94
                path, fid, kind = item[:3]
143
140
            show_list(self.unchanged)
144
141
 
145
142
 
146
 
@deprecated_function(zero_nine)
147
 
def compare_trees(old_tree, new_tree, want_unchanged=False,
148
 
                  specific_files=None, extra_trees=None,
149
 
                  require_versioned=False):
150
 
    """compare_trees was deprecated in 0.10. Please see Tree.changes_from."""
151
 
    return new_tree.changes_from(old_tree,
152
 
        want_unchanged=want_unchanged,
153
 
        specific_files=specific_files,
154
 
        extra_trees=extra_trees,
155
 
        require_versioned=require_versioned)
156
 
 
157
 
 
158
 
def _compare_trees(old_tree, new_tree, want_unchanged, specific_file_ids):
 
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
    """
159
162
 
160
163
    from osutils import is_inside_any
161
164
    
162
165
    old_inv = old_tree.inventory
163
166
    new_inv = new_tree.inventory
164
167
    delta = TreeDelta()
165
 
    # mutter('start compare_trees')
166
 
 
167
 
    # TODO: Rather than iterating over the whole tree and then filtering, we
168
 
    # could diff just the specified files (if any) and their subtrees.  
169
 
 
170
 
    old_files = old_tree.list_files()
171
 
    new_files = new_tree.list_files()
172
 
 
173
 
    more_old = True
174
 
    more_new = True
175
 
 
176
 
    added = {}
177
 
    removed = {}
178
 
 
179
 
    def get_next(iter):
180
 
        try:
181
 
            return iter.next()
182
 
        except StopIteration:
183
 
            return None, None, None, None, None
184
 
    old_path, old_class, old_kind, old_file_id, old_entry = get_next(old_files)
185
 
    new_path, new_class, new_kind, new_file_id, new_entry = get_next(new_files)
186
 
 
187
 
 
188
 
    def check_matching(old_path, old_entry, new_path, new_entry):
189
 
        """We have matched up 2 file_ids, check for changes."""
190
 
        assert old_entry.kind == new_entry.kind
191
 
 
192
 
        if specific_file_ids:
193
 
            if (old_entry.file_id not in specific_file_ids and 
194
 
                new_entry.file_id not in specific_file_ids):
195
 
                return
196
 
 
197
 
        # temporary hack until all entries are populated before clients 
198
 
        # get them
199
 
        old_entry._read_tree_state(old_path, old_tree)
200
 
        new_entry._read_tree_state(new_path, new_tree)
201
 
        text_modified, meta_modified = new_entry.detect_changes(old_entry)
202
 
        
203
 
        # If the name changes, or the parent_id changes, we have a rename
204
 
        # (if we move a parent, that doesn't count as a rename for the file)
205
 
        if (old_entry.name != new_entry.name 
206
 
            or old_entry.parent_id != new_entry.parent_id):
207
 
            delta.renamed.append((old_path,
208
 
                                  new_path,
209
 
                                  old_entry.file_id, old_entry.kind,
210
 
                                  text_modified, meta_modified))
211
 
        elif text_modified or meta_modified:
212
 
            delta.modified.append((new_path, new_entry.file_id, new_entry.kind,
213
 
                                   text_modified, meta_modified))
214
 
        elif want_unchanged:
215
 
            delta.unchanged.append((new_path, new_entry.file_id, new_entry.kind))
216
 
 
217
 
 
218
 
    def handle_old(path, entry):
219
 
        """old entry without a new entry match
220
 
 
221
 
        Check to see if a matching new entry was already seen as an
222
 
        added file, and switch the pair into being a rename.
223
 
        Otherwise just mark the old entry being removed.
224
 
        """
225
 
        if entry.file_id in added:
226
 
            # Actually this is a rename, we found a new file_id earlier
227
 
            # at a different location, so it is no-longer added
228
 
            x_new_path, x_new_entry = added.pop(entry.file_id)
229
 
            check_matching(path, entry, x_new_path, x_new_entry)
230
 
        else:
231
 
            # We have an old_file_id which doesn't line up with a new_file_id
232
 
            # So this file looks to be removed
233
 
            assert entry.file_id not in removed
234
 
            removed[entry.file_id] = path, entry
235
 
 
236
 
    def handle_new(path, entry):
237
 
        """new entry without an old entry match
238
 
        
239
 
        Check to see if a matching old entry was already seen as a
240
 
        removal, and change the pair into a rename.
241
 
        Otherwise just mark the new entry as an added file.
242
 
        """
243
 
        if entry.file_id in removed:
244
 
            # We saw this file_id earlier at an old different location
245
 
            # it is no longer removed, just renamed
246
 
            x_old_path, x_old_entry = removed.pop(entry.file_id)
247
 
            check_matching(x_old_path, x_old_entry, path, entry)
248
 
        else:
249
 
            # We have a new file which does not match an old file
250
 
            # mark it as added
251
 
            assert entry.file_id not in added
252
 
            added[entry.file_id] = path, entry
253
 
 
254
 
    while old_path or new_path:
255
 
        # list_files() returns files in alphabetical path sorted order
256
 
        if old_path == new_path:
257
 
            if old_file_id == new_file_id:
258
 
                # This is the common case, the files are in the same place
259
 
                # check if there were any content changes
260
 
 
261
 
                if old_file_id is None:
262
 
                    # We have 2 unversioned files, no deltas possible???
263
 
                    pass
264
 
                else:
265
 
                    check_matching(old_path, old_entry, new_path, new_entry)
266
 
            else:
267
 
                # The ids don't match, so we have to handle them both
268
 
                # separately.
269
 
                if old_file_id is not None:
270
 
                    handle_old(old_path, old_entry)
271
 
 
272
 
                if new_file_id is not None:
273
 
                    handle_new(new_path, new_entry)
274
 
 
275
 
            # The two entries were at the same path, so increment both sides
276
 
            old_path, old_class, old_kind, old_file_id, old_entry = get_next(old_files)
277
 
            new_path, new_class, new_kind, new_file_id, new_entry = get_next(new_files)
278
 
        elif new_path is None or (old_path is not None and old_path < new_path):
279
 
            # Assume we don't match, only process old_path
280
 
            if old_file_id is not None:
281
 
                handle_old(old_path, old_entry)
282
 
            # old_path came first, so increment it, trying to match up
283
 
            old_path, old_class, old_kind, old_file_id, old_entry = get_next(old_files)
284
 
        elif new_path is not None:
285
 
            # new_path came first, so increment it, trying to match up
286
 
            if new_file_id is not None:
287
 
                handle_new(new_path, new_entry)
288
 
            new_path, new_class, new_kind, new_file_id, new_entry = get_next(new_files)
289
 
 
290
 
    # Now we have a set of added and removed files, mark them all
291
 
    for old_path, old_entry in removed.itervalues():
292
 
        if specific_file_ids:
293
 
            if not old_entry.file_id in specific_file_ids:
294
 
                continue
295
 
        delta.removed.append((old_path, old_entry.file_id, old_entry.kind))
296
 
    for new_path, new_entry in added.itervalues():
297
 
        if specific_file_ids:
298
 
            if not new_entry.file_id in specific_file_ids:
299
 
                continue
300
 
        delta.added.append((new_path, new_entry.file_id, new_entry.kind))
301
 
 
 
168
    mutter('start compare_trees')
 
169
 
 
170
    # TODO: match for specific files can be rather smarter by finding
 
171
    # the IDs of those files up front and then considering only that.
 
172
 
 
173
    for file_id in old_tree:
 
174
        if file_id in new_tree:
 
175
            old_ie = old_inv[file_id]
 
176
            new_ie = new_inv[file_id]
 
177
 
 
178
            kind = old_ie.kind
 
179
            assert kind == new_ie.kind
 
180
            
 
181
            assert kind in InventoryEntry.known_kinds, \
 
182
                   'invalid file kind %r' % kind
 
183
 
 
184
            if kind == 'root_directory':
 
185
                continue
 
186
            
 
187
            if specific_files:
 
188
                if (not is_inside_any(specific_files, old_inv.id2path(file_id)) 
 
189
                    and not is_inside_any(specific_files, new_inv.id2path(file_id))):
 
190
                    continue
 
191
 
 
192
            # temporary hack until all entries are populated before clients 
 
193
            # get them
 
194
            old_path = old_inv.id2path(file_id)
 
195
            new_path = new_inv.id2path(file_id)
 
196
            old_ie._read_tree_state(old_path, old_tree)
 
197
            new_ie._read_tree_state(new_path, new_tree)
 
198
            text_modified, meta_modified = new_ie.detect_changes(old_ie)
 
199
 
 
200
            # TODO: Can possibly avoid calculating path strings if the
 
201
            # two files are unchanged and their names and parents are
 
202
            # the same and the parents are unchanged all the way up.
 
203
            # May not be worthwhile.
 
204
            
 
205
            if (old_ie.name != new_ie.name
 
206
                or old_ie.parent_id != new_ie.parent_id):
 
207
                delta.renamed.append((old_path,
 
208
                                      new_path,
 
209
                                      file_id, kind,
 
210
                                      text_modified, meta_modified))
 
211
            elif text_modified or meta_modified:
 
212
                delta.modified.append((new_path, file_id, kind,
 
213
                                       text_modified, meta_modified))
 
214
            elif want_unchanged:
 
215
                delta.unchanged.append((new_path, file_id, kind))
 
216
        else:
 
217
            kind = old_inv.get_file_kind(file_id)
 
218
            if kind == 'root_directory':
 
219
                continue
 
220
            old_path = old_inv.id2path(file_id)
 
221
            if specific_files:
 
222
                if not is_inside_any(specific_files, old_path):
 
223
                    continue
 
224
            delta.removed.append((old_path, file_id, kind))
 
225
 
 
226
    mutter('start looking for new files')
 
227
    for file_id in new_inv:
 
228
        if file_id in old_inv or file_id not in new_tree:
 
229
            continue
 
230
        kind = new_inv.get_file_kind(file_id)
 
231
        if kind == 'root_directory':
 
232
            continue
 
233
        new_path = new_inv.id2path(file_id)
 
234
        if specific_files:
 
235
            if not is_inside_any(specific_files, new_path):
 
236
                continue
 
237
        delta.added.append((new_path, file_id, kind))
 
238
            
302
239
    delta.removed.sort()
303
240
    delta.added.sort()
304
241
    delta.renamed.sort()
305
 
    # TODO: jam 20060529 These lists shouldn't need to be sorted
306
 
    #       since we added them in alphabetical order.
307
242
    delta.modified.sort()
308
243
    delta.unchanged.sort()
309
244