/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 2255

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 (
 
18
    errors,
 
19
    osutils,
 
20
    )
17
21
from bzrlib.inventory import InventoryEntry
18
22
from bzrlib.trace import mutter
19
23
from bzrlib.symbol_versioning import deprecated_function, zero_nine
90
94
        return False
91
95
            
92
96
 
93
 
    def show(self, to_file, show_ids=False, show_unchanged=False):
 
97
    def show(self, to_file, show_ids=False, show_unchanged=False, short_status=False):
94
98
        """output this delta in status-like form to to_file."""
95
 
        def show_list(files):
 
99
        def show_list(files, short_status_letter=''):
96
100
            for item in files:
97
101
                path, fid, kind = item[:3]
98
102
 
105
109
                    path += '*'
106
110
 
107
111
                if show_ids:
108
 
                    print >>to_file, '  %-30s %s' % (path, fid)
 
112
                    print >>to_file, '%s  %-30s %s' % (short_status_letter, path, fid)
109
113
                else:
110
 
                    print >>to_file, ' ', path
 
114
                    print >>to_file, '%s  %s' % (short_status_letter, path)
111
115
            
112
116
        if self.removed:
113
 
            print >>to_file, 'removed:'
114
 
            show_list(self.removed)
 
117
            if not short_status:
 
118
                print >>to_file, 'removed:'
 
119
                show_list(self.removed)
 
120
            else:
 
121
                show_list(self.removed, 'D')
115
122
                
116
123
        if self.added:
117
 
            print >>to_file, 'added:'
118
 
            show_list(self.added)
 
124
            if not short_status:
 
125
                print >>to_file, 'added:'
 
126
                show_list(self.added)
 
127
            else:
 
128
                show_list(self.added, 'A')
119
129
 
120
130
        extra_modified = []
121
131
 
122
132
        if self.renamed:
123
 
            print >>to_file, 'renamed:'
 
133
            short_status_letter = 'R'
 
134
            if not short_status:
 
135
                print >>to_file, 'renamed:'
 
136
                short_status_letter = ''
124
137
            for (oldpath, newpath, fid, kind,
125
138
                 text_modified, meta_modified) in self.renamed:
126
139
                if text_modified or meta_modified:
129
142
                if meta_modified:
130
143
                    newpath += '*'
131
144
                if show_ids:
132
 
                    print >>to_file, '  %s => %s %s' % (oldpath, newpath, fid)
 
145
                    print >>to_file, '%s  %s => %s %s' % (short_status_letter,
 
146
                                                          oldpath, newpath, fid)
133
147
                else:
134
 
                    print >>to_file, '  %s => %s' % (oldpath, newpath)
 
148
                    print >>to_file, '%s  %s => %s' % (short_status_letter,
 
149
                                                       oldpath, newpath)
135
150
                    
136
151
        if self.modified or extra_modified:
137
 
            print >>to_file, 'modified:'
138
 
            show_list(self.modified)
139
 
            show_list(extra_modified)
 
152
            short_status_letter = 'M'
 
153
            if not short_status:
 
154
                print >>to_file, 'modified:'
 
155
                short_status_letter = ''
 
156
            show_list(self.modified, short_status_letter)
 
157
            show_list(extra_modified, short_status_letter)
140
158
            
141
159
        if show_unchanged and self.unchanged:
142
 
            print >>to_file, 'unchanged:'
143
 
            show_list(self.unchanged)
 
160
            if not short_status:
 
161
                print >>to_file, 'unchanged:'
 
162
                show_list(self.unchanged)
 
163
            else:
 
164
                show_list(self.unchanged, 'S')
144
165
 
145
166
 
146
167
@deprecated_function(zero_nine)
152
173
        want_unchanged=want_unchanged,
153
174
        specific_files=specific_files,
154
175
        extra_trees=extra_trees,
155
 
        require_versioned=require_versioned)
 
176
        require_versioned=require_versioned,
 
177
        include_root=False)
156
178
 
157
179
 
158
180
def _compare_trees(old_tree, new_tree, want_unchanged, specific_file_ids,
159
181
                   include_root):
160
 
 
161
 
    from osutils import is_inside_any
162
 
    
163
 
    old_inv = old_tree.inventory
164
 
    new_inv = new_tree.inventory
165
182
    delta = TreeDelta()
166
183
    # mutter('start compare_trees')
167
184
 
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):
 
185
    for (file_id, path, content_change, versioned, parent_id, name, kind,
 
186
         executable) in new_tree._iter_changes(old_tree, want_unchanged, 
 
187
                                               specific_file_ids):
 
188
        if not include_root and (None, None) == parent_id:
 
189
            continue
 
190
        assert kind[0] == kind[1] or None in kind
 
191
        # the only 'kind change' permitted is creation/deletion
 
192
        fully_present = tuple((versioned[x] and kind[x] is not None) for
 
193
                              x in range(2))
 
194
        if fully_present[0] != fully_present[1]:
 
195
            if fully_present[1] is True:
 
196
                delta.added.append((path, file_id, kind[1]))
 
197
            else:
 
198
                assert fully_present[0] is True
 
199
                old_path = old_tree.id2path(file_id)
 
200
                delta.removed.append((old_path, file_id, kind[0]))
 
201
        elif fully_present[0] is False:
 
202
            continue
 
203
        elif name[0] != name[1] or parent_id[0] != parent_id[1]:
 
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
 
206
            # file)
 
207
            old_path = old_tree.id2path(file_id)
208
208
            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))
 
209
                                  path,
 
210
                                  file_id, 
 
211
                                  kind[1],
 
212
                                  content_change, 
 
213
                                  (executable[0] != executable[1])))
 
214
        elif content_change is True or executable[0] != executable[1]:
 
215
            delta.modified.append((path, file_id, kind[1],
 
216
                                   content_change, 
 
217
                                   (executable[0] != executable[1])))
 
218
        else:
 
219
            delta.unchanged.append((path, file_id, kind[1]))
302
220
 
303
221
    delta.removed.sort()
304
222
    delta.added.sort()
309
227
    delta.unchanged.sort()
310
228
 
311
229
    return delta
 
230
 
 
231
 
 
232
class ChangeReporter(object):
 
233
    """Report changes between two trees"""
 
234
 
 
235
    def __init__(self, old_inventory, output=None):
 
236
        self.old_inventory = old_inventory
 
237
        self.output = output
 
238
        if self.output is None:
 
239
            from bzrlib import trace
 
240
            self.output = trace.note
 
241
 
 
242
    def report(self, file_id, path, versioned, renamed, modified, exe_change,
 
243
               kind):
 
244
        """Report one change to a file
 
245
 
 
246
        :param file_id: The file_id of the file
 
247
        :param path: The path the file has (or would have) in the tree (as
 
248
            generated by Tree._iter_changes)
 
249
        :param versioned: may be 'added', 'removed', or 'unchanged'
 
250
        :param renamed: may be True or False
 
251
        :param modified: may be 'created', 'deleted', 'kind changed',
 
252
            'modified' or 'unchanged'.
 
253
        :param exe_change: True if the execute bit has changed
 
254
        :param kind: A pair of file kinds, as generated by Tree._iter_changes.
 
255
            None indicates no file present.
 
256
        """
 
257
        modified_map = {'kind changed': 'K',
 
258
                        'unchanged': ' ',
 
259
                        'created': 'N',
 
260
                        'modified': 'M',
 
261
                        'deleted': 'D'}
 
262
        versioned_map = {'added': '+',
 
263
                         'unchanged': ' ',
 
264
                         'removed': '-'}
 
265
        old_path = ""
 
266
        if renamed:
 
267
            old_path = self.old_inventory.id2path(file_id)
 
268
            rename = "R"
 
269
        else:
 
270
            rename = versioned_map[versioned]
 
271
        if modified == 'kind changed':
 
272
            if old_path == "":
 
273
                old_path = path
 
274
        if modified == 'deleted':
 
275
            path += osutils.kind_marker(kind[0])
 
276
        else:
 
277
            path += osutils.kind_marker(kind[1])
 
278
        if old_path != "":
 
279
            old_path += "%s => " % osutils.kind_marker(kind[0])
 
280
        if exe_change:
 
281
            exe = '*'
 
282
        else:
 
283
            exe = ' '
 
284
        self.output("%s%s%s %s%s", rename, modified_map[modified], exe,
 
285
                    old_path, path)
 
286
 
 
287
 
 
288
def report_changes(change_iterator, reporter):
 
289
    """Report the changes from a change iterator.
 
290
 
 
291
    This is essentially a translation from low-level to medium-level changes.
 
292
    Further processing may be required to produce a human-readable output.
 
293
    Unfortunately, some tree-changing operations are very complex
 
294
    :change_iterator: an iterator or sequence of changes in the format
 
295
        generated by Tree._iter_changes
 
296
    :param reporter: The ChangeReporter that will report the changes.
 
297
    """
 
298
    for (file_id, path, content_change, versioned, parent_id, name, kind,
 
299
         executable) in change_iterator:
 
300
        exe_change = False
 
301
        # files are "renamed" if they are moved or if name changes, as long
 
302
        # as it had a value
 
303
        if None not in name and (name[0] != name[1] or
 
304
                                 parent_id[0] != parent_id[1]):
 
305
            renamed = True
 
306
        else:
 
307
            renamed = False
 
308
        if kind[0] != kind[1]:
 
309
            if kind[0] is None:
 
310
                modified = "created"
 
311
            elif kind[1] is None:
 
312
                modified = "deleted"
 
313
            else:
 
314
                modified = "kind changed"
 
315
        else:
 
316
            if content_change:
 
317
                modified = "modified"
 
318
            else:
 
319
                modified = "unchanged"
 
320
            if kind[1] == "file":
 
321
                exe_change = (executable[0] != executable[1])
 
322
        if versioned[0] != versioned[1]:
 
323
            if versioned[0]:
 
324
                versioned_change = "removed"
 
325
            else:
 
326
                versioned_change = "added"
 
327
        else:
 
328
            versioned_change = "unchanged"
 
329
        reporter.report(file_id, path, versioned_change, renamed, modified,
 
330
                        exe_change, kind)