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

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/delta.py
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
from bzrlib import (
 
18
    errors,
 
19
    osutils,
 
20
    )
18
21
from bzrlib.inventory import InventoryEntry
19
22
from bzrlib.trace import mutter
20
23
from bzrlib.symbol_versioning import deprecated_function, zero_nine
35
38
        (path, id, kind, text_modified, meta_modified)
36
39
    unchanged
37
40
        (path, id, kind)
 
41
    unversioned
 
42
        (path, kind)
38
43
 
39
44
    Each id is listed only once.
40
45
 
53
58
        self.added = []
54
59
        self.removed = []
55
60
        self.renamed = []
 
61
        self.kind_changed = []
56
62
        self.modified = []
57
63
        self.unchanged = []
 
64
        self.unversioned = []
58
65
 
59
66
    def __eq__(self, other):
60
67
        if not isinstance(other, TreeDelta):
63
70
               and self.removed == other.removed \
64
71
               and self.renamed == other.renamed \
65
72
               and self.modified == other.modified \
66
 
               and self.unchanged == other.unchanged
 
73
               and self.unchanged == other.unchanged \
 
74
               and self.kind_changed == other.kind_changed \
 
75
               and self.unversioned == other.unversioned
67
76
 
68
77
    def __ne__(self, other):
69
78
        return not (self == other)
70
79
 
71
80
    def __repr__(self):
72
 
        return "TreeDelta(added=%r, removed=%r, renamed=%r, modified=%r," \
73
 
            " unchanged=%r)" % (self.added, self.removed, self.renamed,
74
 
            self.modified, self.unchanged)
 
81
        return "TreeDelta(added=%r, removed=%r, renamed=%r," \
 
82
            " kind_changed=%r, modified=%r, unchanged=%r," \
 
83
            " unversioned=%r)" % (self.added,
 
84
            self.removed, self.renamed, self.kind_changed, self.modified,
 
85
            self.unchanged, self.unversioned)
75
86
 
76
87
    def has_changed(self):
77
88
        return bool(self.modified
78
89
                    or self.added
79
90
                    or self.removed
80
 
                    or self.renamed)
 
91
                    or self.renamed
 
92
                    or self.kind_changed)
81
93
 
82
94
    def touches_file_id(self, file_id):
83
95
        """Return True if file_id is modified by this delta."""
88
100
        for v in self.renamed:
89
101
            if v[2] == file_id:
90
102
                return True
 
103
        for v in self.kind_changed:
 
104
            if v[1] == file_id:
 
105
                return True
91
106
        return False
92
107
            
93
108
 
94
 
    def show(self, to_file, show_ids=False, show_unchanged=False, short_status=False):
 
109
    def show(self, to_file, show_ids=False, show_unchanged=False,
 
110
             short_status=False):
95
111
        """output this delta in status-like form to to_file."""
96
112
        def show_list(files, short_status_letter=''):
97
113
            for item in files:
106
122
                    path += '*'
107
123
 
108
124
                if show_ids:
109
 
                    print >>to_file, '%s  %-30s %s' % (short_status_letter, path, fid)
 
125
                    print >>to_file, '%s  %-30s %s' % (short_status_letter,
 
126
                        path, fid)
110
127
                else:
111
128
                    print >>to_file, '%s  %s' % (short_status_letter, path)
112
129
            
139
156
                if meta_modified:
140
157
                    newpath += '*'
141
158
                if show_ids:
142
 
                    print >>to_file, '%s  %s => %s %s' % (short_status_letter,
143
 
                                                          oldpath, newpath, fid)
144
 
                else:
145
 
                    print >>to_file, '%s  %s => %s' % (short_status_letter,
146
 
                                                       oldpath, newpath)
147
 
                    
 
159
                    print >>to_file, '%s  %s => %s %s' % (
 
160
                        short_status_letter, oldpath, newpath, fid)
 
161
                else:
 
162
                    print >>to_file, '%s  %s => %s' % (
 
163
                        short_status_letter, oldpath, newpath)
 
164
 
 
165
        if self.kind_changed:
 
166
            if short_status:
 
167
                short_status_letter = 'K'
 
168
            else:
 
169
                print >>to_file, 'kind changed:'
 
170
                short_status_letter = ''
 
171
            for (path, fid, old_kind, new_kind) in self.kind_changed:
 
172
                if show_ids:
 
173
                    suffix = ' '+fid
 
174
                else:
 
175
                    suffix = ''
 
176
                print >>to_file, '%s  %s (%s => %s)%s' % (
 
177
                    short_status_letter, path, old_kind, new_kind, suffix)
 
178
 
148
179
        if self.modified or extra_modified:
149
180
            short_status_letter = 'M'
150
181
            if not short_status:
160
191
            else:
161
192
                show_list(self.unchanged, 'S')
162
193
 
 
194
        if self.unversioned:
 
195
            print >>to_file, 'unknown:'
 
196
            show_list(self.unversioned)
 
197
 
 
198
    def get_changes_as_text(self, show_ids=False, show_unchanged=False,
 
199
             short_status=False):
 
200
        import StringIO
 
201
        output = StringIO.StringIO()
 
202
        self.show(output, show_ids, show_unchanged, short_status)
 
203
        return output.getvalue()
163
204
 
164
205
@deprecated_function(zero_nine)
165
206
def compare_trees(old_tree, new_tree, want_unchanged=False,
174
215
        include_root=False)
175
216
 
176
217
 
177
 
def _compare_trees(old_tree, new_tree, want_unchanged, specific_file_ids,
178
 
                   include_root):
 
218
def _compare_trees(old_tree, new_tree, want_unchanged, specific_files,
 
219
                   include_root, extra_trees=None,
 
220
                   want_unversioned=False):
 
221
    """Worker function that implements Tree.changes_from."""
179
222
    delta = TreeDelta()
180
223
    # mutter('start compare_trees')
181
224
 
182
225
    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):
 
226
         executable) in new_tree._iter_changes(old_tree, want_unchanged,
 
227
            specific_files, extra_trees=extra_trees,
 
228
            want_unversioned=want_unversioned):
 
229
        if versioned == (False, False):
 
230
            delta.unversioned.append((path[1], None, kind[1]))
 
231
            continue
185
232
        if not include_root and (None, None) == parent_id:
186
233
            continue
187
 
        assert kind[0] == kind[1] or None in kind
188
 
        # the only 'kind change' permitted is creation/deletion
189
234
        fully_present = tuple((versioned[x] and kind[x] is not None) for
190
235
                              x in range(2))
191
236
        if fully_present[0] != fully_present[1]:
192
237
            if fully_present[1] is True:
193
 
                delta.added.append((path, file_id, kind[1]))
 
238
                delta.added.append((path[1], file_id, kind[1]))
194
239
            else:
195
240
                assert fully_present[0] is True
196
 
                old_path = old_tree.id2path(file_id)
197
 
                delta.removed.append((old_path, file_id, kind[0]))
 
241
                delta.removed.append((path[0], file_id, kind[0]))
198
242
        elif fully_present[0] is False:
199
243
            continue
200
244
        elif name[0] != name[1] or parent_id[0] != parent_id[1]:
201
245
            # If the name changes, or the parent_id changes, we have a rename
202
246
            # (if we move a parent, that doesn't count as a rename for the
203
247
            # file)
204
 
            old_path = old_tree.id2path(file_id)
205
 
            delta.renamed.append((old_path,
206
 
                                  path,
207
 
                                  file_id, 
 
248
            delta.renamed.append((path[0],
 
249
                                  path[1],
 
250
                                  file_id,
208
251
                                  kind[1],
209
 
                                  content_change, 
 
252
                                  content_change,
210
253
                                  (executable[0] != executable[1])))
 
254
        elif kind[0] != kind[1]:
 
255
            delta.kind_changed.append((path[1], file_id, kind[0], kind[1]))
211
256
        elif content_change is True or executable[0] != executable[1]:
212
 
            delta.modified.append((path, file_id, kind[1],
213
 
                                   content_change, 
 
257
            delta.modified.append((path[1], file_id, kind[1],
 
258
                                   content_change,
214
259
                                   (executable[0] != executable[1])))
215
260
        else:
216
 
            delta.unchanged.append((path, file_id, kind[1]))
 
261
            delta.unchanged.append((path[1], file_id, kind[1]))
217
262
 
218
263
    delta.removed.sort()
219
264
    delta.added.sort()
224
269
    delta.unchanged.sort()
225
270
 
226
271
    return delta
 
272
 
 
273
 
 
274
class _ChangeReporter(object):
 
275
    """Report changes between two trees"""
 
276
 
 
277
    def __init__(self, output=None, suppress_root_add=True,
 
278
                 output_file=None, unversioned_filter=None):
 
279
        """Constructor
 
280
 
 
281
        :param output: a function with the signature of trace.note, i.e.
 
282
            accepts a format and parameters.
 
283
        :param supress_root_add: If true, adding the root will be ignored
 
284
            (i.e. when a tree has just been initted)
 
285
        :param output_file: If supplied, a file-like object to write to.
 
286
            Only one of output and output_file may be supplied.
 
287
        :param unversioned_filter: A filter function to be called on 
 
288
            unversioned files. This should return True to ignore a path.
 
289
            By default, no filtering takes place.
 
290
        """
 
291
        if output_file is not None:
 
292
            if output is not None:
 
293
                raise BzrError('Cannot specify both output and output_file')
 
294
            def output(fmt, *args):
 
295
                output_file.write((fmt % args) + '\n')
 
296
        self.output = output
 
297
        if self.output is None:
 
298
            from bzrlib import trace
 
299
            self.output = trace.note
 
300
        self.suppress_root_add = suppress_root_add
 
301
        self.modified_map = {'kind changed': 'K',
 
302
                             'unchanged': ' ',
 
303
                             'created': 'N',
 
304
                             'modified': 'M',
 
305
                             'deleted': 'D'}
 
306
        self.versioned_map = {'added': '+', # versioned target
 
307
                              'unchanged': ' ', # versioned in both
 
308
                              'removed': '-', # versioned in source
 
309
                              'unversioned': '?', # versioned in neither
 
310
                              }
 
311
        self.unversioned_filter = unversioned_filter
 
312
 
 
313
    def report(self, file_id, paths, versioned, renamed, modified, exe_change,
 
314
               kind):
 
315
        """Report one change to a file
 
316
 
 
317
        :param file_id: The file_id of the file
 
318
        :param path: The old and new paths as generated by Tree._iter_changes.
 
319
        :param versioned: may be 'added', 'removed', 'unchanged', or
 
320
            'unversioned.
 
321
        :param renamed: may be True or False
 
322
        :param modified: may be 'created', 'deleted', 'kind changed',
 
323
            'modified' or 'unchanged'.
 
324
        :param exe_change: True if the execute bit has changed
 
325
        :param kind: A pair of file kinds, as generated by Tree._iter_changes.
 
326
            None indicates no file present.
 
327
        """
 
328
        if paths[1] == '' and versioned == 'added' and self.suppress_root_add:
 
329
            return
 
330
        if versioned == 'unversioned':
 
331
            # skip ignored unversioned files if needed.
 
332
            if self.unversioned_filter is not None:
 
333
                if self.unversioned_filter(paths[1]):
 
334
                    return
 
335
            # dont show a content change in the output.
 
336
            modified = 'unchanged'
 
337
        # we show both paths in the following situations:
 
338
        # the file versioning is unchanged AND
 
339
        # ( the path is different OR
 
340
        #   the kind is different)
 
341
        if (versioned == 'unchanged' and
 
342
            (renamed or modified == 'kind changed')):
 
343
            if renamed:
 
344
                # on a rename, we show old and new
 
345
                old_path, path = paths
 
346
            else:
 
347
                # if its not renamed, we're showing both for kind changes
 
348
                # so only show the new path
 
349
                old_path, path = paths[1], paths[1]
 
350
            # if the file is not missing in the source, we show its kind
 
351
            # when we show two paths.
 
352
            if kind[0] is not None:
 
353
                old_path += osutils.kind_marker(kind[0])
 
354
            old_path += " => "
 
355
        elif versioned == 'removed':
 
356
            # not present in target
 
357
            old_path = ""
 
358
            path = paths[0]
 
359
        else:
 
360
            old_path = ""
 
361
            path = paths[1]
 
362
        if renamed:
 
363
            rename = "R"
 
364
        else:
 
365
            rename = self.versioned_map[versioned]
 
366
        # we show the old kind on the new path when the content is deleted.
 
367
        if modified == 'deleted':
 
368
            path += osutils.kind_marker(kind[0])
 
369
        # otherwise we always show the current kind when there is one
 
370
        elif kind[1] is not None:
 
371
            path += osutils.kind_marker(kind[1])
 
372
        if exe_change:
 
373
            exe = '*'
 
374
        else:
 
375
            exe = ' '
 
376
        self.output("%s%s%s %s%s", rename, self.modified_map[modified], exe,
 
377
                    old_path, path)
 
378
 
 
379
 
 
380
def report_changes(change_iterator, reporter):
 
381
    """Report the changes from a change iterator.
 
382
 
 
383
    This is essentially a translation from low-level to medium-level changes.
 
384
    Further processing may be required to produce a human-readable output.
 
385
    Unfortunately, some tree-changing operations are very complex
 
386
    :change_iterator: an iterator or sequence of changes in the format
 
387
        generated by Tree._iter_changes
 
388
    :param reporter: The _ChangeReporter that will report the changes.
 
389
    """
 
390
    versioned_change_map = {
 
391
        (True, True)  : 'unchanged',
 
392
        (True, False) : 'removed',
 
393
        (False, True) : 'added',
 
394
        (False, False): 'unversioned',
 
395
        }
 
396
    for (file_id, path, content_change, versioned, parent_id, name, kind,
 
397
         executable) in change_iterator:
 
398
        exe_change = False
 
399
        # files are "renamed" if they are moved or if name changes, as long
 
400
        # as it had a value
 
401
        if None not in name and None not in parent_id and\
 
402
            (name[0] != name[1] or parent_id[0] != parent_id[1]):
 
403
            renamed = True
 
404
        else:
 
405
            renamed = False
 
406
        if kind[0] != kind[1]:
 
407
            if kind[0] is None:
 
408
                modified = "created"
 
409
            elif kind[1] is None:
 
410
                modified = "deleted"
 
411
            else:
 
412
                modified = "kind changed"
 
413
        else:
 
414
            if content_change:
 
415
                modified = "modified"
 
416
            else:
 
417
                modified = "unchanged"
 
418
            if kind[1] == "file":
 
419
                exe_change = (executable[0] != executable[1])
 
420
        versioned_change = versioned_change_map[versioned]
 
421
        reporter.report(file_id, path, versioned_change, renamed, modified,
 
422
                        exe_change, kind)