/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 breezy/delta.py

  • Committer: Jelmer Vernooij
  • Date: 2019-08-12 20:24:50 UTC
  • mto: (7290.1.35 work)
  • mto: This revision was merged to the branch mainline in revision 7405.
  • Revision ID: jelmer@jelmer.uk-20190812202450-vdpamxay6sebo93w
Fix path to brz.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/delta.py
 
1
# Copyright (C) 2005-2010 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
from __future__ import absolute_import
 
18
 
 
19
from breezy import (
 
20
    osutils,
 
21
    )
 
22
from .sixish import (
 
23
    StringIO,
 
24
    )
 
25
from .trace import is_quiet
 
26
 
 
27
 
 
28
class TreeDelta(object):
 
29
    """Describes changes from one tree to another.
 
30
 
 
31
    Contains seven lists:
 
32
 
 
33
    added
 
34
        (path, id, kind)
 
35
    removed
 
36
        (path, id, kind)
 
37
    renamed
 
38
        (oldpath, newpath, id, kind, text_modified, meta_modified)
 
39
    kind_changed
 
40
        (path, id, old_kind, new_kind)
 
41
    modified
 
42
        (path, id, kind, text_modified, meta_modified)
 
43
    unchanged
 
44
        (path, id, kind)
 
45
    unversioned
 
46
        (path, None, kind)
 
47
 
 
48
    Each id is listed only once.
 
49
 
 
50
    Files that are both modified and renamed are listed only in
 
51
    renamed, with the text_modified flag true. The text_modified
 
52
    applies either to the content of the file or the target of the
 
53
    symbolic link, depending of the kind of file.
 
54
 
 
55
    Files are only considered renamed if their name has changed or
 
56
    their parent directory has changed.  Renaming a directory
 
57
    does not count as renaming all its contents.
 
58
 
 
59
    The lists are normally sorted when the delta is created.
 
60
    """
 
61
 
 
62
    def __init__(self):
 
63
        self.added = []
 
64
        self.removed = []
 
65
        self.renamed = []
 
66
        self.kind_changed = []
 
67
        self.modified = []
 
68
        self.unchanged = []
 
69
        self.unversioned = []
 
70
        self.missing = []
 
71
 
 
72
    def __eq__(self, other):
 
73
        if not isinstance(other, TreeDelta):
 
74
            return False
 
75
        return self.added == other.added \
 
76
            and self.removed == other.removed \
 
77
            and self.renamed == other.renamed \
 
78
            and self.modified == other.modified \
 
79
            and self.unchanged == other.unchanged \
 
80
            and self.kind_changed == other.kind_changed \
 
81
            and self.unversioned == other.unversioned
 
82
 
 
83
    def __ne__(self, other):
 
84
        return not (self == other)
 
85
 
 
86
    def __repr__(self):
 
87
        return "TreeDelta(added=%r, removed=%r, renamed=%r," \
 
88
            " kind_changed=%r, modified=%r, unchanged=%r," \
 
89
            " unversioned=%r)" % (self.added,
 
90
                                  self.removed, self.renamed, self.kind_changed, self.modified,
 
91
                                  self.unchanged, self.unversioned)
 
92
 
 
93
    def has_changed(self):
 
94
        return bool(self.modified
 
95
                    or self.added
 
96
                    or self.removed
 
97
                    or self.renamed
 
98
                    or self.kind_changed)
 
99
 
 
100
    def touches_file_id(self, file_id):
 
101
        """Return True if file_id is modified by this delta."""
 
102
        for l in self.added, self.removed, self.modified:
 
103
            for v in l:
 
104
                if v[1] == file_id:
 
105
                    return True
 
106
        for v in self.renamed:
 
107
            if v[2] == file_id:
 
108
                return True
 
109
        for v in self.kind_changed:
 
110
            if v[1] == file_id:
 
111
                return True
 
112
        return False
 
113
 
 
114
    def get_changes_as_text(self, show_ids=False, show_unchanged=False,
 
115
                            short_status=False):
 
116
        output = StringIO()
 
117
        report_delta(output, self, short_status, show_ids, show_unchanged)
 
118
        return output.getvalue()
 
119
 
 
120
 
 
121
def _compare_trees(old_tree, new_tree, want_unchanged, specific_files,
 
122
                   include_root, extra_trees=None,
 
123
                   require_versioned=False, want_unversioned=False):
 
124
    """Worker function that implements Tree.changes_from."""
 
125
    delta = TreeDelta()
 
126
    # mutter('start compare_trees')
 
127
 
 
128
    for (file_id, path, content_change, versioned, parent_id, name, kind,
 
129
         executable) in new_tree.iter_changes(old_tree, want_unchanged,
 
130
                                              specific_files, extra_trees=extra_trees,
 
131
                                              require_versioned=require_versioned,
 
132
                                              want_unversioned=want_unversioned):
 
133
        if versioned == (False, False):
 
134
            delta.unversioned.append((path[1], None, kind[1]))
 
135
            continue
 
136
        if not include_root and (None, None) == parent_id:
 
137
            continue
 
138
        fully_present = tuple((versioned[x] and kind[x] is not None) for
 
139
                              x in range(2))
 
140
        if fully_present[0] != fully_present[1]:
 
141
            if fully_present[1] is True:
 
142
                delta.added.append((path[1], file_id, kind[1]))
 
143
            else:
 
144
                delta.removed.append((path[0], file_id, kind[0]))
 
145
        elif fully_present[0] is False:
 
146
            delta.missing.append((path[1], file_id, kind[1]))
 
147
        elif name[0] != name[1] or parent_id[0] != parent_id[1]:
 
148
            # If the name changes, or the parent_id changes, we have a rename
 
149
            # (if we move a parent, that doesn't count as a rename for the
 
150
            # file)
 
151
            delta.renamed.append((path[0],
 
152
                                  path[1],
 
153
                                  file_id,
 
154
                                  kind[1],
 
155
                                  content_change,
 
156
                                  (executable[0] != executable[1])))
 
157
        elif kind[0] != kind[1]:
 
158
            delta.kind_changed.append((path[1], file_id, kind[0], kind[1]))
 
159
        elif content_change or executable[0] != executable[1]:
 
160
            delta.modified.append((path[1], file_id, kind[1],
 
161
                                   content_change,
 
162
                                   (executable[0] != executable[1])))
 
163
        else:
 
164
            delta.unchanged.append((path[1], file_id, kind[1]))
 
165
 
 
166
    delta.removed.sort()
 
167
    delta.added.sort()
 
168
    delta.renamed.sort()
 
169
 
 
170
    def missing_key(change):
 
171
        return (change[0] or '', change[1])
 
172
    delta.missing.sort(key=missing_key)
 
173
    # TODO: jam 20060529 These lists shouldn't need to be sorted
 
174
    #       since we added them in alphabetical order.
 
175
    delta.modified.sort()
 
176
    delta.unchanged.sort()
 
177
    delta.unversioned.sort()
 
178
 
 
179
    return delta
 
180
 
 
181
 
 
182
class _ChangeReporter(object):
 
183
    """Report changes between two trees"""
 
184
 
 
185
    def __init__(self, output=None, suppress_root_add=True,
 
186
                 output_file=None, unversioned_filter=None, view_info=None,
 
187
                 classify=True):
 
188
        """Constructor
 
189
 
 
190
        :param output: a function with the signature of trace.note, i.e.
 
191
            accepts a format and parameters.
 
192
        :param supress_root_add: If true, adding the root will be ignored
 
193
            (i.e. when a tree has just been initted)
 
194
        :param output_file: If supplied, a file-like object to write to.
 
195
            Only one of output and output_file may be supplied.
 
196
        :param unversioned_filter: A filter function to be called on
 
197
            unversioned files. This should return True to ignore a path.
 
198
            By default, no filtering takes place.
 
199
        :param view_info: A tuple of view_name,view_files if only
 
200
            items inside a view are to be reported on, or None for
 
201
            no view filtering.
 
202
        :param classify: Add special symbols to indicate file kind.
 
203
        """
 
204
        if output_file is not None:
 
205
            if output is not None:
 
206
                raise BzrError('Cannot specify both output and output_file')
 
207
 
 
208
            def output(fmt, *args):
 
209
                output_file.write((fmt % args) + '\n')
 
210
        self.output = output
 
211
        if self.output is None:
 
212
            from . import trace
 
213
            self.output = trace.note
 
214
        self.suppress_root_add = suppress_root_add
 
215
        self.modified_map = {'kind changed': 'K',
 
216
                             'unchanged': ' ',
 
217
                             'created': 'N',
 
218
                             'modified': 'M',
 
219
                             'deleted': 'D',
 
220
                             'missing': '!',
 
221
                             }
 
222
        self.versioned_map = {'added': '+',  # versioned target
 
223
                              'unchanged': ' ',  # versioned in both
 
224
                              'removed': '-',  # versioned in source
 
225
                              'unversioned': '?',  # versioned in neither
 
226
                              }
 
227
        self.unversioned_filter = unversioned_filter
 
228
        if classify:
 
229
            self.kind_marker = osutils.kind_marker
 
230
        else:
 
231
            self.kind_marker = lambda kind: ''
 
232
        if view_info is None:
 
233
            self.view_name = None
 
234
            self.view_files = []
 
235
        else:
 
236
            self.view_name = view_info[0]
 
237
            self.view_files = view_info[1]
 
238
            self.output("Operating on whole tree but only reporting on "
 
239
                        "'%s' view." % (self.view_name,))
 
240
 
 
241
    def report(self, file_id, paths, versioned, renamed, modified, exe_change,
 
242
               kind):
 
243
        """Report one change to a file
 
244
 
 
245
        :param file_id: The file_id of the file
 
246
        :param path: The old and new paths as generated by Tree.iter_changes.
 
247
        :param versioned: may be 'added', 'removed', 'unchanged', or
 
248
            'unversioned.
 
249
        :param renamed: may be True or False
 
250
        :param modified: may be 'created', 'deleted', 'kind changed',
 
251
            'modified' or 'unchanged'.
 
252
        :param exe_change: True if the execute bit has changed
 
253
        :param kind: A pair of file kinds, as generated by Tree.iter_changes.
 
254
            None indicates no file present.
 
255
        """
 
256
        if is_quiet():
 
257
            return
 
258
        if paths[1] == '' and versioned == 'added' and self.suppress_root_add:
 
259
            return
 
260
        if self.view_files and not osutils.is_inside_any(self.view_files,
 
261
                                                         paths[1]):
 
262
            return
 
263
        if versioned == 'unversioned':
 
264
            # skip ignored unversioned files if needed.
 
265
            if self.unversioned_filter is not None:
 
266
                if self.unversioned_filter(paths[1]):
 
267
                    return
 
268
            # dont show a content change in the output.
 
269
            modified = 'unchanged'
 
270
        # we show both paths in the following situations:
 
271
        # the file versioning is unchanged AND
 
272
        # ( the path is different OR
 
273
        #   the kind is different)
 
274
        if (versioned == 'unchanged' and
 
275
                (renamed or modified == 'kind changed')):
 
276
            if renamed:
 
277
                # on a rename, we show old and new
 
278
                old_path, path = paths
 
279
            else:
 
280
                # if it's not renamed, we're showing both for kind changes
 
281
                # so only show the new path
 
282
                old_path, path = paths[1], paths[1]
 
283
            # if the file is not missing in the source, we show its kind
 
284
            # when we show two paths.
 
285
            if kind[0] is not None:
 
286
                old_path += self.kind_marker(kind[0])
 
287
            old_path += " => "
 
288
        elif versioned == 'removed':
 
289
            # not present in target
 
290
            old_path = ""
 
291
            path = paths[0]
 
292
        else:
 
293
            old_path = ""
 
294
            path = paths[1]
 
295
        if renamed:
 
296
            rename = "R"
 
297
        else:
 
298
            rename = self.versioned_map[versioned]
 
299
        # we show the old kind on the new path when the content is deleted.
 
300
        if modified == 'deleted':
 
301
            path += self.kind_marker(kind[0])
 
302
        # otherwise we always show the current kind when there is one
 
303
        elif kind[1] is not None:
 
304
            path += self.kind_marker(kind[1])
 
305
        if exe_change:
 
306
            exe = '*'
 
307
        else:
 
308
            exe = ' '
 
309
        self.output("%s%s%s %s%s", rename, self.modified_map[modified], exe,
 
310
                    old_path, path)
 
311
 
 
312
 
 
313
def report_changes(change_iterator, reporter):
 
314
    """Report the changes from a change iterator.
 
315
 
 
316
    This is essentially a translation from low-level to medium-level changes.
 
317
    Further processing may be required to produce a human-readable output.
 
318
    Unfortunately, some tree-changing operations are very complex
 
319
    :change_iterator: an iterator or sequence of changes in the format
 
320
        generated by Tree.iter_changes
 
321
    :param reporter: The _ChangeReporter that will report the changes.
 
322
    """
 
323
    versioned_change_map = {
 
324
        (True, True): 'unchanged',
 
325
        (True, False): 'removed',
 
326
        (False, True): 'added',
 
327
        (False, False): 'unversioned',
 
328
        }
 
329
 
 
330
    def path_key(change):
 
331
        if change[1][0] is not None:
 
332
            path = change[1][0]
 
333
        else:
 
334
            path = change[1][1]
 
335
        return osutils.splitpath(path)
 
336
    for (file_id, path, content_change, versioned, parent_id, name, kind,
 
337
         executable) in sorted(change_iterator, key=path_key):
 
338
        exe_change = False
 
339
        # files are "renamed" if they are moved or if name changes, as long
 
340
        # as it had a value
 
341
        if None not in name and None not in parent_id and\
 
342
                (name[0] != name[1] or parent_id[0] != parent_id[1]):
 
343
            renamed = True
 
344
        else:
 
345
            renamed = False
 
346
        if kind[0] != kind[1]:
 
347
            if kind[0] is None:
 
348
                modified = "created"
 
349
            elif kind[1] is None:
 
350
                modified = "deleted"
 
351
            else:
 
352
                modified = "kind changed"
 
353
        else:
 
354
            if content_change:
 
355
                modified = "modified"
 
356
            elif kind[0] is None:
 
357
                modified = "missing"
 
358
            else:
 
359
                modified = "unchanged"
 
360
            if kind[1] == "file":
 
361
                exe_change = (executable[0] != executable[1])
 
362
        versioned_change = versioned_change_map[versioned]
 
363
        reporter.report(file_id, path, versioned_change, renamed, modified,
 
364
                        exe_change, kind)
 
365
 
 
366
 
 
367
def report_delta(to_file, delta, short_status=False, show_ids=False,
 
368
                 show_unchanged=False, indent='', predicate=None, classify=True):
 
369
    """Output this delta in status-like form to to_file.
 
370
 
 
371
    :param to_file: A file-like object where the output is displayed.
 
372
 
 
373
    :param delta: A TreeDelta containing the changes to be displayed
 
374
 
 
375
    :param short_status: Single-line status if True.
 
376
 
 
377
    :param show_ids: Output the file ids if True.
 
378
 
 
379
    :param show_unchanged: Output the unchanged files if True.
 
380
 
 
381
    :param indent: Added at the beginning of all output lines (for merged
 
382
        revisions).
 
383
 
 
384
    :param predicate: A callable receiving a path and a file id and
 
385
        returning True if the path should be displayed.
 
386
 
 
387
    :param classify: Add special symbols to indicate file kind.
 
388
    """
 
389
 
 
390
    def decorate_path(path, kind, meta_modified=None):
 
391
        if not classify:
 
392
            return path
 
393
        if kind == 'directory':
 
394
            path += '/'
 
395
        elif kind == 'symlink':
 
396
            path += '@'
 
397
        if meta_modified:
 
398
            path += '*'
 
399
        return path
 
400
 
 
401
    def show_more_renamed(item):
 
402
        (oldpath, file_id, kind,
 
403
         text_modified, meta_modified, newpath) = item
 
404
        dec_new_path = decorate_path(newpath, kind, meta_modified)
 
405
        to_file.write(' => %s' % dec_new_path)
 
406
        if text_modified or meta_modified:
 
407
            extra_modified.append((newpath, file_id, kind,
 
408
                                   text_modified, meta_modified))
 
409
 
 
410
    def show_more_kind_changed(item):
 
411
        (path, file_id, old_kind, new_kind) = item
 
412
        to_file.write(' (%s => %s)' % (old_kind, new_kind))
 
413
 
 
414
    def show_path(path, file_id, kind, meta_modified,
 
415
                  default_format, with_file_id_format):
 
416
        dec_path = decorate_path(path, kind, meta_modified)
 
417
        if show_ids:
 
418
            to_file.write(with_file_id_format % dec_path)
 
419
        else:
 
420
            to_file.write(default_format % dec_path)
 
421
 
 
422
    def show_list(files, long_status_name, short_status_letter,
 
423
                  default_format='%s', with_file_id_format='%-30s',
 
424
                  show_more=None):
 
425
        if files:
 
426
            header_shown = False
 
427
            if short_status:
 
428
                prefix = short_status_letter
 
429
            else:
 
430
                prefix = ''
 
431
            prefix = indent + prefix + '  '
 
432
 
 
433
            for item in files:
 
434
                path, file_id, kind = item[:3]
 
435
                if (predicate is not None and not predicate(path, file_id)):
 
436
                    continue
 
437
                if not header_shown and not short_status:
 
438
                    to_file.write(indent + long_status_name + ':\n')
 
439
                    header_shown = True
 
440
                meta_modified = None
 
441
                if len(item) == 5:
 
442
                    meta_modified = item[4]
 
443
 
 
444
                to_file.write(prefix)
 
445
                show_path(path, file_id, kind, meta_modified,
 
446
                          default_format, with_file_id_format)
 
447
                if show_more is not None:
 
448
                    show_more(item)
 
449
                if show_ids:
 
450
                    to_file.write(' %s' % file_id.decode('utf-8'))
 
451
                to_file.write('\n')
 
452
 
 
453
    show_list(delta.removed, 'removed', 'D')
 
454
    show_list(delta.added, 'added', 'A')
 
455
    show_list(delta.missing, 'missing', '!')
 
456
    extra_modified = []
 
457
    # Reorder delta.renamed tuples so that all lists share the same
 
458
    # order for their 3 first fields and that they also begin like
 
459
    # the delta.modified tuples
 
460
    renamed = [(p, i, k, tm, mm, np)
 
461
               for p, np, i, k, tm, mm in delta.renamed]
 
462
    show_list(renamed, 'renamed', 'R', with_file_id_format='%s',
 
463
              show_more=show_more_renamed)
 
464
    show_list(delta.kind_changed, 'kind changed', 'K',
 
465
              with_file_id_format='%s',
 
466
              show_more=show_more_kind_changed)
 
467
    show_list(delta.modified + extra_modified, 'modified', 'M')
 
468
    if show_unchanged:
 
469
        show_list(delta.unchanged, 'unchanged', 'S')
 
470
 
 
471
    show_list(delta.unversioned, 'unknown', ' ')