← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/delta.py

Fix BzrDir.create_workingtree for NULL_REVISION

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/delta.py
1
 
# -*- coding: UTF-8 -*-
2
 
 
 
1
# Copyright (C) 2005, 2006 Canonical
 
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
 
19
21
 
20
22
class TreeDelta(object):
21
23
    """Describes changes from one tree to another.
89
91
            
90
92
 
91
93
    def show(self, to_file, show_ids=False, show_unchanged=False):
 
94
        """output this delta in status-like form to to_file."""
92
95
        def show_list(files):
93
96
            for item in files:
94
97
                path, fid, kind = item[:3]
140
143
            show_list(self.unchanged)
141
144
 
142
145
 
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
 
    """
 
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):
162
159
 
163
160
    from osutils import is_inside_any
164
161
    
165
162
    old_inv = old_tree.inventory
166
163
    new_inv = new_tree.inventory
167
164
    delta = TreeDelta()
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
 
            
 
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
 
239
302
    delta.removed.sort()
240
303
    delta.added.sort()
241
304
    delta.renamed.sort()
 
305
    # TODO: jam 20060529 These lists shouldn't need to be sorted
 
306
    #       since we added them in alphabetical order.
242
307
    delta.modified.sort()
243
308
    delta.unchanged.sort()
244
309