/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/delta.py

[merge] bzr.dev 2240

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/delta.py
1
 
# Copyright (C) 2005, 2006 Canonical
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
2
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
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 errors
17
18
from bzrlib.inventory import InventoryEntry
18
19
from bzrlib.trace import mutter
19
20
from bzrlib.symbol_versioning import deprecated_function, zero_nine
90
91
        return False
91
92
            
92
93
 
93
 
    def show(self, to_file, show_ids=False, show_unchanged=False):
 
94
    def show(self, to_file, show_ids=False, show_unchanged=False, short_status=False):
94
95
        """output this delta in status-like form to to_file."""
95
 
        def show_list(files):
 
96
        def show_list(files, short_status_letter=''):
96
97
            for item in files:
97
98
                path, fid, kind = item[:3]
98
99
 
105
106
                    path += '*'
106
107
 
107
108
                if show_ids:
108
 
                    print >>to_file, '  %-30s %s' % (path, fid)
 
109
                    print >>to_file, '%s  %-30s %s' % (short_status_letter, path, fid)
109
110
                else:
110
 
                    print >>to_file, ' ', path
 
111
                    print >>to_file, '%s  %s' % (short_status_letter, path)
111
112
            
112
113
        if self.removed:
113
 
            print >>to_file, 'removed:'
114
 
            show_list(self.removed)
 
114
            if not short_status:
 
115
                print >>to_file, 'removed:'
 
116
                show_list(self.removed)
 
117
            else:
 
118
                show_list(self.removed, 'D')
115
119
                
116
120
        if self.added:
117
 
            print >>to_file, 'added:'
118
 
            show_list(self.added)
 
121
            if not short_status:
 
122
                print >>to_file, 'added:'
 
123
                show_list(self.added)
 
124
            else:
 
125
                show_list(self.added, 'A')
119
126
 
120
127
        extra_modified = []
121
128
 
122
129
        if self.renamed:
123
 
            print >>to_file, 'renamed:'
 
130
            short_status_letter = 'R'
 
131
            if not short_status:
 
132
                print >>to_file, 'renamed:'
 
133
                short_status_letter = ''
124
134
            for (oldpath, newpath, fid, kind,
125
135
                 text_modified, meta_modified) in self.renamed:
126
136
                if text_modified or meta_modified:
129
139
                if meta_modified:
130
140
                    newpath += '*'
131
141
                if show_ids:
132
 
                    print >>to_file, '  %s => %s %s' % (oldpath, newpath, fid)
 
142
                    print >>to_file, '%s  %s => %s %s' % (short_status_letter,
 
143
                                                          oldpath, newpath, fid)
133
144
                else:
134
 
                    print >>to_file, '  %s => %s' % (oldpath, newpath)
 
145
                    print >>to_file, '%s  %s => %s' % (short_status_letter,
 
146
                                                       oldpath, newpath)
135
147
                    
136
148
        if self.modified or extra_modified:
137
 
            print >>to_file, 'modified:'
138
 
            show_list(self.modified)
139
 
            show_list(extra_modified)
 
149
            short_status_letter = 'M'
 
150
            if not short_status:
 
151
                print >>to_file, 'modified:'
 
152
                short_status_letter = ''
 
153
            show_list(self.modified, short_status_letter)
 
154
            show_list(extra_modified, short_status_letter)
140
155
            
141
156
        if show_unchanged and self.unchanged:
142
 
            print >>to_file, 'unchanged:'
143
 
            show_list(self.unchanged)
 
157
            if not short_status:
 
158
                print >>to_file, 'unchanged:'
 
159
                show_list(self.unchanged)
 
160
            else:
 
161
                show_list(self.unchanged, 'S')
144
162
 
145
163
 
146
164
@deprecated_function(zero_nine)
152
170
        want_unchanged=want_unchanged,
153
171
        specific_files=specific_files,
154
172
        extra_trees=extra_trees,
155
 
        require_versioned=require_versioned)
 
173
        require_versioned=require_versioned,
 
174
        include_root=False)
156
175
 
157
176
 
158
177
def _compare_trees(old_tree, new_tree, want_unchanged, specific_file_ids,
159
178
                   include_root):
160
 
 
161
 
    from osutils import is_inside_any
162
 
    
163
 
    old_inv = old_tree.inventory
164
 
    new_inv = new_tree.inventory
165
179
    delta = TreeDelta()
166
180
    # mutter('start compare_trees')
167
181
 
168
 
    # TODO: Rather than iterating over the whole tree and then filtering, we
169
 
    # could diff just the specified files (if any) and their subtrees.  
170
 
 
171
 
    old_files = old_tree.list_files(include_root)
172
 
    new_files = new_tree.list_files(include_root)
173
 
 
174
 
    more_old = True
175
 
    more_new = True
176
 
 
177
 
    added = {}
178
 
    removed = {}
179
 
 
180
 
    def get_next(iter):
181
 
        try:
182
 
            return iter.next()
183
 
        except StopIteration:
184
 
            return None, None, None, None, None
185
 
    old_path, old_class, old_kind, old_file_id, old_entry = get_next(old_files)
186
 
    new_path, new_class, new_kind, new_file_id, new_entry = get_next(new_files)
187
 
 
188
 
 
189
 
    def check_matching(old_path, old_entry, new_path, new_entry):
190
 
        """We have matched up 2 file_ids, check for changes."""
191
 
        assert old_entry.kind == new_entry.kind
192
 
 
193
 
        if specific_file_ids:
194
 
            if (old_entry.file_id not in specific_file_ids and 
195
 
                new_entry.file_id not in specific_file_ids):
196
 
                return
197
 
 
198
 
        # temporary hack until all entries are populated before clients 
199
 
        # get them
200
 
        old_entry._read_tree_state(old_path, old_tree)
201
 
        new_entry._read_tree_state(new_path, new_tree)
202
 
        text_modified, meta_modified = new_entry.detect_changes(old_entry)
203
 
        
204
 
        # If the name changes, or the parent_id changes, we have a rename
205
 
        # (if we move a parent, that doesn't count as a rename for the file)
206
 
        if (old_entry.name != new_entry.name 
207
 
            or old_entry.parent_id != new_entry.parent_id):
 
182
    for (file_id, path, content_change, versioned, parent_id, name, kind,
 
183
         executable) in new_tree._iter_changes(old_tree, want_unchanged, 
 
184
                                               specific_file_ids):
 
185
        if not include_root and (None, None) == parent_id:
 
186
            continue
 
187
        assert kind[0] == kind[1] or None in kind
 
188
        # the only 'kind change' permitted is creation/deletion
 
189
        fully_present = tuple((versioned[x] and kind[x] is not None) for
 
190
                              x in range(2))
 
191
        if fully_present[0] != fully_present[1]:
 
192
            if fully_present[1] is True:
 
193
                delta.added.append((path, file_id, kind[1]))
 
194
            else:
 
195
                assert fully_present[0] is True
 
196
                old_path = old_tree.id2path(file_id)
 
197
                delta.removed.append((old_path, file_id, kind[0]))
 
198
        elif fully_present[0] is False:
 
199
            continue
 
200
        elif name[0] != name[1] or parent_id[0] != parent_id[1]:
 
201
            # If the name changes, or the parent_id changes, we have a rename
 
202
            # (if we move a parent, that doesn't count as a rename for the
 
203
            # file)
 
204
            old_path = old_tree.id2path(file_id)
208
205
            delta.renamed.append((old_path,
209
 
                                  new_path,
210
 
                                  old_entry.file_id, old_entry.kind,
211
 
                                  text_modified, meta_modified))
212
 
        elif text_modified or meta_modified:
213
 
            delta.modified.append((new_path, new_entry.file_id, new_entry.kind,
214
 
                                   text_modified, meta_modified))
215
 
        elif want_unchanged:
216
 
            delta.unchanged.append((new_path, new_entry.file_id, new_entry.kind))
217
 
 
218
 
 
219
 
    def handle_old(path, entry):
220
 
        """old entry without a new entry match
221
 
 
222
 
        Check to see if a matching new entry was already seen as an
223
 
        added file, and switch the pair into being a rename.
224
 
        Otherwise just mark the old entry being removed.
225
 
        """
226
 
        if entry.file_id in added:
227
 
            # Actually this is a rename, we found a new file_id earlier
228
 
            # at a different location, so it is no-longer added
229
 
            x_new_path, x_new_entry = added.pop(entry.file_id)
230
 
            check_matching(path, entry, x_new_path, x_new_entry)
231
 
        else:
232
 
            # We have an old_file_id which doesn't line up with a new_file_id
233
 
            # So this file looks to be removed
234
 
            assert entry.file_id not in removed
235
 
            removed[entry.file_id] = path, entry
236
 
 
237
 
    def handle_new(path, entry):
238
 
        """new entry without an old entry match
239
 
        
240
 
        Check to see if a matching old entry was already seen as a
241
 
        removal, and change the pair into a rename.
242
 
        Otherwise just mark the new entry as an added file.
243
 
        """
244
 
        if entry.file_id in removed:
245
 
            # We saw this file_id earlier at an old different location
246
 
            # it is no longer removed, just renamed
247
 
            x_old_path, x_old_entry = removed.pop(entry.file_id)
248
 
            check_matching(x_old_path, x_old_entry, path, entry)
249
 
        else:
250
 
            # We have a new file which does not match an old file
251
 
            # mark it as added
252
 
            assert entry.file_id not in added
253
 
            added[entry.file_id] = path, entry
254
 
 
255
 
    while old_path is not None or new_path is not None:
256
 
        # list_files() returns files in alphabetical path sorted order
257
 
        if old_path == new_path:
258
 
            if old_file_id == new_file_id:
259
 
                # This is the common case, the files are in the same place
260
 
                # check if there were any content changes
261
 
 
262
 
                if old_file_id is None:
263
 
                    # We have 2 unversioned files, no deltas possible???
264
 
                    pass
265
 
                else:
266
 
                    check_matching(old_path, old_entry, new_path, new_entry)
267
 
            else:
268
 
                # The ids don't match, so we have to handle them both
269
 
                # separately.
270
 
                if old_file_id is not None:
271
 
                    handle_old(old_path, old_entry)
272
 
 
273
 
                if new_file_id is not None:
274
 
                    handle_new(new_path, new_entry)
275
 
 
276
 
            # The two entries were at the same path, so increment both sides
277
 
            old_path, old_class, old_kind, old_file_id, old_entry = get_next(old_files)
278
 
            new_path, new_class, new_kind, new_file_id, new_entry = get_next(new_files)
279
 
        elif new_path is None or (old_path is not None and old_path < new_path):
280
 
            # Assume we don't match, only process old_path
281
 
            if old_file_id is not None:
282
 
                handle_old(old_path, old_entry)
283
 
            # old_path came first, so increment it, trying to match up
284
 
            old_path, old_class, old_kind, old_file_id, old_entry = get_next(old_files)
285
 
        elif new_path is not None:
286
 
            # new_path came first, so increment it, trying to match up
287
 
            if new_file_id is not None:
288
 
                handle_new(new_path, new_entry)
289
 
            new_path, new_class, new_kind, new_file_id, new_entry = get_next(new_files)
290
 
 
291
 
    # Now we have a set of added and removed files, mark them all
292
 
    for old_path, old_entry in removed.itervalues():
293
 
        if specific_file_ids:
294
 
            if not old_entry.file_id in specific_file_ids:
295
 
                continue
296
 
        delta.removed.append((old_path, old_entry.file_id, old_entry.kind))
297
 
    for new_path, new_entry in added.itervalues():
298
 
        if specific_file_ids:
299
 
            if not new_entry.file_id in specific_file_ids:
300
 
                continue
301
 
        delta.added.append((new_path, new_entry.file_id, new_entry.kind))
 
206
                                  path,
 
207
                                  file_id, 
 
208
                                  kind[1],
 
209
                                  content_change, 
 
210
                                  (executable[0] != executable[1])))
 
211
        elif content_change is True or executable[0] != executable[1]:
 
212
            delta.modified.append((path, file_id, kind[1],
 
213
                                   content_change, 
 
214
                                   (executable[0] != executable[1])))
 
215
        else:
 
216
            delta.unchanged.append((path, file_id, kind[1]))
302
217
 
303
218
    delta.removed.sort()
304
219
    delta.added.sort()