/b-gtk/fix-viz

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/b-gtk/fix-viz

« back to all changes in this revision

Viewing changes to diff.py

  • Committer: Vincent Ladeuil
  • Date: 2008-06-10 15:25:47 UTC
  • mto: This revision was merged to the branch mainline in revision 504.
  • Revision ID: v.ladeuil+lp@free.fr-20080610152547-dwmil1p8pd0mfpnl
Fix third failing test (thanks to jam).

* tests/test_commit.py:
(TestPendingRevisions.test_pending_revisions_multi_merge): Fix
provided by jam: bzr we now filter the pending merges so that only
the 'heads()' are included. We just ensure that the pending merges
contain the unique tips for the ancestries.

Show diffs side-by-side

added added

removed removed

Lines of Context:
diff.py
30
30
except ImportError:
31
31
    have_gconf = False
32
32
 
33
 
import bzrlib
34
 
 
35
 
from bzrlib.diff import show_diff_trees
 
33
from bzrlib import (
 
34
    merge as _mod_merge,
 
35
    osutils,
 
36
    progress,
 
37
    urlutils,
 
38
    workingtree,
 
39
)
 
40
from bzrlib.diff import show_diff_trees, internal_diff
36
41
from bzrlib.errors import NoSuchFile
 
42
from bzrlib.patches import parse_patches
37
43
from bzrlib.trace import warning
38
 
 
39
 
 
40
 
class DiffWindow(gtk.Window):
41
 
    """Diff window.
42
 
 
43
 
    This object represents and manages a single window containing the
44
 
    differences between two revisions on a branch.
45
 
    """
 
44
from bzrlib.plugins.gtk import _i18n
 
45
from bzrlib.plugins.gtk.window import Window
 
46
from dialog import error_dialog, info_dialog, warning_dialog
 
47
 
 
48
 
 
49
class SelectCancelled(Exception):
 
50
 
 
51
    pass
 
52
 
 
53
 
 
54
class DiffFileView(gtk.ScrolledWindow):
 
55
    """Window for displaying diffs from a diff file"""
46
56
 
47
57
    def __init__(self):
48
 
        gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
49
 
        self.set_border_width(0)
50
 
        self.set_title("bzrk diff")
51
 
 
52
 
        # Use two thirds of the screen by default
53
 
        screen = self.get_screen()
54
 
        monitor = screen.get_monitor_geometry(0)
55
 
        width = int(monitor.width * 0.66)
56
 
        height = int(monitor.height * 0.66)
57
 
        self.set_default_size(width, height)
58
 
 
 
58
        gtk.ScrolledWindow.__init__(self)
59
59
        self.construct()
 
60
        self._diffs = {}
60
61
 
61
62
    def construct(self):
62
 
        """Construct the window contents."""
63
 
        # The   window  consists  of   a  pane   containing:  the
64
 
        # hierarchical list  of files on  the left, and  the diff
65
 
        # for the currently selected file on the right.
66
 
        pane = gtk.HPaned()
67
 
        self.add(pane)
68
 
        pane.show()
69
 
 
70
 
        # The file hierarchy: a scrollable treeview
71
 
        scrollwin = gtk.ScrolledWindow()
72
 
        scrollwin.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
73
 
        scrollwin.set_shadow_type(gtk.SHADOW_IN)
74
 
        pane.pack1(scrollwin)
75
 
        scrollwin.show()
76
 
 
77
 
        self.model = gtk.TreeStore(str, str)
78
 
        self.treeview = gtk.TreeView(self.model)
79
 
        self.treeview.set_headers_visible(False)
80
 
        self.treeview.set_search_column(1)
81
 
        self.treeview.connect("cursor-changed", self._treeview_cursor_cb)
82
 
        scrollwin.add(self.treeview)
83
 
        self.treeview.show()
84
 
 
85
 
        cell = gtk.CellRendererText()
86
 
        cell.set_property("width-chars", 20)
87
 
        column = gtk.TreeViewColumn()
88
 
        column.pack_start(cell, expand=True)
89
 
        column.add_attribute(cell, "text", 0)
90
 
        self.treeview.append_column(column)
91
 
 
92
 
        # The diffs of the  selected file: a scrollable source or
93
 
        # text view
94
 
        scrollwin = gtk.ScrolledWindow()
95
 
        scrollwin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
96
 
        scrollwin.set_shadow_type(gtk.SHADOW_IN)
97
 
        pane.pack2(scrollwin)
98
 
        scrollwin.show()
 
63
        self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
 
64
        self.set_shadow_type(gtk.SHADOW_IN)
99
65
 
100
66
        if have_gtksourceview:
101
67
            self.buffer = gtksourceview.SourceBuffer()
114
80
 
115
81
        sourceview.set_editable(False)
116
82
        sourceview.modify_font(pango.FontDescription("Monospace"))
117
 
        scrollwin.add(sourceview)
 
83
        self.add(sourceview)
118
84
        sourceview.show()
119
85
 
120
 
    def set_diff(self, description, rev_tree, parent_tree):
121
 
        """Set the differences showed by this window.
122
 
 
123
 
        Compares the two trees and populates the window with the
124
 
        differences.
125
 
        """
126
 
        self.rev_tree = rev_tree
127
 
        self.parent_tree = parent_tree
128
 
 
129
 
        self.model.clear()
130
 
        delta = self.rev_tree.changes_from(self.parent_tree)
131
 
 
132
 
        self.model.append(None, [ "Complete Diff", "" ])
133
 
 
134
 
        if len(delta.added):
135
 
            titer = self.model.append(None, [ "Added", None ])
136
 
            for path, id, kind in delta.added:
137
 
                self.model.append(titer, [ path, path ])
138
 
 
139
 
        if len(delta.removed):
140
 
            titer = self.model.append(None, [ "Removed", None ])
141
 
            for path, id, kind in delta.removed:
142
 
                self.model.append(titer, [ path, path ])
143
 
 
144
 
        if len(delta.renamed):
145
 
            titer = self.model.append(None, [ "Renamed", None ])
146
 
            for oldpath, newpath, id, kind, text_modified, meta_modified \
147
 
                    in delta.renamed:
148
 
                self.model.append(titer, [ oldpath, newpath ])
149
 
 
150
 
        if len(delta.modified):
151
 
            titer = self.model.append(None, [ "Modified", None ])
152
 
            for path, id, kind, text_modified, meta_modified in delta.modified:
153
 
                self.model.append(titer, [ path, path ])
154
 
 
155
 
        self.treeview.expand_all()
156
 
        self.set_title(description + " - bzrk diff")
157
 
 
158
 
    def set_file(self, file_path):
159
 
        tv_path = None
160
 
        for data in self.model:
161
 
            for child in data.iterchildren():
162
 
                if child[0] == file_path or child[1] == file_path:
163
 
                    tv_path = child.path
164
 
                    break
165
 
        if tv_path is None:
166
 
            raise NoSuchFile(file_path)
167
 
        self.treeview.set_cursor(tv_path)
168
 
        self.treeview.scroll_to_cell(tv_path)
169
 
 
170
 
    def _treeview_cursor_cb(self, *args):
171
 
        """Callback for when the treeview cursor changes."""
172
 
        (path, col) = self.treeview.get_cursor()
173
 
        specific_files = [ self.model[path][1] ]
174
 
        if specific_files == [ None ]:
175
 
            return
176
 
        elif specific_files == [ "" ]:
177
 
            specific_files = []
178
 
 
179
 
        s = StringIO()
180
 
        show_diff_trees(self.parent_tree, self.rev_tree, s, specific_files)
181
 
        self.buffer.set_text(s.getvalue().decode(sys.getdefaultencoding(), 'replace'))
182
 
 
183
86
    @staticmethod
184
87
    def apply_gedit_colors(lang):
185
88
        """Set style for lang to that specified in gedit configuration.
186
89
 
187
90
        This method needs the gconf module.
188
 
        
 
91
 
189
92
        :param lang: a gtksourceview.SourceLanguage object.
190
93
        """
191
94
        GEDIT_SYNTAX_PATH = '/apps/gedit-2/preferences/syntax_highlighting'
243
146
 
244
147
            lang.set_tag_style(tag_id, style)
245
148
 
246
 
    @staticmethod
247
 
    def apply_colordiff_colors(lang):
 
149
    @classmethod
 
150
    def apply_colordiff_colors(klass, lang):
248
151
        """Set style colors for lang using the colordiff configuration file.
249
152
 
250
153
        Both ~/.colordiffrc and ~/.colordiffrc.bzr-gtk are read.
261
164
                except IOError, e:
262
165
                    warning('could not open file %s: %s' % (f, str(e)))
263
166
                else:
264
 
                    colors.update(DiffWindow.parse_colordiffrc(f))
 
167
                    colors.update(klass.parse_colordiffrc(f))
265
168
                    f.close()
266
169
 
267
170
        if not colors:
303
206
    @staticmethod
304
207
    def parse_colordiffrc(fileobj):
305
208
        """Parse fileobj as a colordiff configuration file.
306
 
        
 
209
 
307
210
        :return: A dict with the key -> value pairs.
308
211
        """
309
212
        colors = {}
316
219
            colors[key.strip()] = val.strip()
317
220
        return colors
318
221
 
 
222
    def set_trees(self, rev_tree, parent_tree):
 
223
        self.rev_tree = rev_tree
 
224
        self.parent_tree = parent_tree
 
225
#        self._build_delta()
 
226
 
 
227
#    def _build_delta(self):
 
228
#        self.parent_tree.lock_read()
 
229
#        self.rev_tree.lock_read()
 
230
#        try:
 
231
#            self.delta = iter_changes_to_status(self.parent_tree, self.rev_tree)
 
232
#            self.path_to_status = {}
 
233
#            self.path_to_diff = {}
 
234
#            source_inv = self.parent_tree.inventory
 
235
#            target_inv = self.rev_tree.inventory
 
236
#            for (file_id, real_path, change_type, display_path) in self.delta:
 
237
#                self.path_to_status[real_path] = u'=== %s %s' % (change_type, display_path)
 
238
#                if change_type in ('modified', 'renamed and modified'):
 
239
#                    source_ie = source_inv[file_id]
 
240
#                    target_ie = target_inv[file_id]
 
241
#                    sio = StringIO()
 
242
#                    source_ie.diff(internal_diff, *old path, *old_tree,
 
243
#                                   *new_path, target_ie, self.rev_tree,
 
244
#                                   sio)
 
245
#                    self.path_to_diff[real_path] = 
 
246
#
 
247
#        finally:
 
248
#            self.rev_tree.unlock()
 
249
#            self.parent_tree.unlock()
 
250
 
 
251
    def show_diff(self, specific_files):
 
252
        sections = []
 
253
        if specific_files is None:
 
254
            self.buffer.set_text(self._diffs[None])
 
255
        else:
 
256
            for specific_file in specific_files:
 
257
                sections.append(self._diffs[specific_file])
 
258
            self.buffer.set_text(''.join(sections))
 
259
 
 
260
 
 
261
class DiffView(DiffFileView):
 
262
    """This is the soft and chewy filling for a DiffWindow."""
 
263
 
 
264
    def __init__(self):
 
265
        DiffFileView.__init__(self)
 
266
        self.rev_tree = None
 
267
        self.parent_tree = None
 
268
 
 
269
    def show_diff(self, specific_files):
 
270
        """Show the diff for the specified files"""
 
271
        s = StringIO()
 
272
        show_diff_trees(self.parent_tree, self.rev_tree, s, specific_files,
 
273
                        old_label='', new_label='',
 
274
                        # path_encoding=sys.getdefaultencoding()
 
275
                        # The default is utf-8, but we interpret the file
 
276
                        # contents as getdefaultencoding(), so we should
 
277
                        # probably try to make the paths in the same encoding.
 
278
                        )
 
279
        # str.decode(encoding, 'replace') doesn't do anything. Because if a
 
280
        # character is not valid in 'encoding' there is nothing to replace, the
 
281
        # 'replace' is for 'str.encode()'
 
282
        try:
 
283
            decoded = s.getvalue().decode(sys.getdefaultencoding())
 
284
        except UnicodeDecodeError:
 
285
            try:
 
286
                decoded = s.getvalue().decode('UTF-8')
 
287
            except UnicodeDecodeError:
 
288
                decoded = s.getvalue().decode('iso-8859-1')
 
289
                # This always works, because every byte has a valid
 
290
                # mapping from iso-8859-1 to Unicode
 
291
        # TextBuffer must contain pure UTF-8 data
 
292
        self.buffer.set_text(decoded.encode('UTF-8'))
 
293
 
 
294
 
 
295
class DiffWidget(gtk.HPaned):
 
296
    """Diff widget
 
297
 
 
298
    """
 
299
    def __init__(self):
 
300
        super(DiffWidget, self).__init__()
 
301
 
 
302
        # The file hierarchy: a scrollable treeview
 
303
        scrollwin = gtk.ScrolledWindow()
 
304
        scrollwin.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
 
305
        scrollwin.set_shadow_type(gtk.SHADOW_IN)
 
306
        self.pack1(scrollwin)
 
307
        scrollwin.show()
 
308
 
 
309
        self.model = gtk.TreeStore(str, str)
 
310
        self.treeview = gtk.TreeView(self.model)
 
311
        self.treeview.set_headers_visible(False)
 
312
        self.treeview.set_search_column(1)
 
313
        self.treeview.connect("cursor-changed", self._treeview_cursor_cb)
 
314
        scrollwin.add(self.treeview)
 
315
        self.treeview.show()
 
316
 
 
317
        cell = gtk.CellRendererText()
 
318
        cell.set_property("width-chars", 20)
 
319
        column = gtk.TreeViewColumn()
 
320
        column.pack_start(cell, expand=True)
 
321
        column.add_attribute(cell, "text", 0)
 
322
        self.treeview.append_column(column)
 
323
 
 
324
    def set_diff_text(self, lines):
 
325
        """Set the current diff from a list of lines
 
326
 
 
327
        :param lines: The diff to show, in unified diff format
 
328
        """
 
329
        # The diffs of the  selected file: a scrollable source or
 
330
        # text view
 
331
 
 
332
    def set_diff_text_sections(self, sections):
 
333
        self.diff_view = DiffFileView()
 
334
        self.diff_view.show()
 
335
        self.pack2(self.diff_view)
 
336
        for oldname, newname, patch in sections:
 
337
            self.diff_view._diffs[newname] = str(patch)
 
338
            if newname is None:
 
339
                newname = ''
 
340
            self.model.append(None, [oldname, newname])
 
341
        self.diff_view.show_diff(None)
 
342
 
 
343
    def set_diff(self, rev_tree, parent_tree):
 
344
        """Set the differences showed by this window.
 
345
 
 
346
        Compares the two trees and populates the window with the
 
347
        differences.
 
348
        """
 
349
        self.diff_view = DiffView()
 
350
        self.pack2(self.diff_view)
 
351
        self.diff_view.show()
 
352
        self.diff_view.set_trees(rev_tree, parent_tree)
 
353
        self.rev_tree = rev_tree
 
354
        self.parent_tree = parent_tree
 
355
 
 
356
        self.model.clear()
 
357
        delta = self.rev_tree.changes_from(self.parent_tree)
 
358
 
 
359
        self.model.append(None, [ "Complete Diff", "" ])
 
360
 
 
361
        if len(delta.added):
 
362
            titer = self.model.append(None, [ "Added", None ])
 
363
            for path, id, kind in delta.added:
 
364
                self.model.append(titer, [ path, path ])
 
365
 
 
366
        if len(delta.removed):
 
367
            titer = self.model.append(None, [ "Removed", None ])
 
368
            for path, id, kind in delta.removed:
 
369
                self.model.append(titer, [ path, path ])
 
370
 
 
371
        if len(delta.renamed):
 
372
            titer = self.model.append(None, [ "Renamed", None ])
 
373
            for oldpath, newpath, id, kind, text_modified, meta_modified \
 
374
                    in delta.renamed:
 
375
                self.model.append(titer, [ oldpath, newpath ])
 
376
 
 
377
        if len(delta.modified):
 
378
            titer = self.model.append(None, [ "Modified", None ])
 
379
            for path, id, kind, text_modified, meta_modified in delta.modified:
 
380
                self.model.append(titer, [ path, path ])
 
381
 
 
382
        self.treeview.expand_all()
 
383
 
 
384
    def set_file(self, file_path):
 
385
        """Select the current file to display"""
 
386
        tv_path = None
 
387
        for data in self.model:
 
388
            for child in data.iterchildren():
 
389
                if child[0] == file_path or child[1] == file_path:
 
390
                    tv_path = child.path
 
391
                    break
 
392
        if tv_path is None:
 
393
            raise NoSuchFile(file_path)
 
394
        self.treeview.set_cursor(tv_path)
 
395
        self.treeview.scroll_to_cell(tv_path)
 
396
 
 
397
    def _treeview_cursor_cb(self, *args):
 
398
        """Callback for when the treeview cursor changes."""
 
399
        (path, col) = self.treeview.get_cursor()
 
400
        specific_files = [ self.model[path][1] ]
 
401
        if specific_files == [ None ]:
 
402
            return
 
403
        elif specific_files == [ "" ]:
 
404
            specific_files = None
 
405
 
 
406
        self.diff_view.show_diff(specific_files)
 
407
 
 
408
 
 
409
class DiffWindow(Window):
 
410
    """Diff window.
 
411
 
 
412
    This object represents and manages a single window containing the
 
413
    differences between two revisions on a branch.
 
414
    """
 
415
 
 
416
    def __init__(self, parent=None, operations=None):
 
417
        Window.__init__(self, parent)
 
418
        self.set_border_width(0)
 
419
        self.set_title("bzrk diff")
 
420
 
 
421
        # Use two thirds of the screen by default
 
422
        screen = self.get_screen()
 
423
        monitor = screen.get_monitor_geometry(0)
 
424
        width = int(monitor.width * 0.66)
 
425
        height = int(monitor.height * 0.66)
 
426
        self.set_default_size(width, height)
 
427
        self.construct(operations)
 
428
 
 
429
    def construct(self, operations):
 
430
        """Construct the window contents."""
 
431
        self.vbox = gtk.VBox()
 
432
        self.add(self.vbox)
 
433
        self.vbox.show()
 
434
        hbox = self._get_button_bar(operations)
 
435
        if hbox is not None:
 
436
            self.vbox.pack_start(hbox, expand=False, fill=True)
 
437
        self.diff = DiffWidget()
 
438
        self.vbox.add(self.diff)
 
439
        self.diff.show_all()
 
440
 
 
441
    def _get_button_bar(self, operations):
 
442
        """Return a button bar to use.
 
443
 
 
444
        :return: None, meaning that no button bar will be used.
 
445
        """
 
446
        if operations is None:
 
447
            return None
 
448
        hbox = gtk.HButtonBox()
 
449
        hbox.set_layout(gtk.BUTTONBOX_START)
 
450
        for title, method in operations:
 
451
            merge_button = gtk.Button(title)
 
452
            merge_button.show()
 
453
            merge_button.set_relief(gtk.RELIEF_NONE)
 
454
            merge_button.connect("clicked", method)
 
455
            hbox.pack_start(merge_button, expand=False, fill=True)
 
456
        hbox.show()
 
457
        return hbox
 
458
 
 
459
    def _get_merge_target(self):
 
460
        d = gtk.FileChooserDialog('Merge branch', self,
 
461
                                  gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER,
 
462
                                  buttons=(gtk.STOCK_OK, gtk.RESPONSE_OK,
 
463
                                           gtk.STOCK_CANCEL,
 
464
                                           gtk.RESPONSE_CANCEL,))
 
465
        try:
 
466
            result = d.run()
 
467
            if result != gtk.RESPONSE_OK:
 
468
                raise SelectCancelled()
 
469
            return d.get_current_folder_uri()
 
470
        finally:
 
471
            d.destroy()
 
472
 
 
473
    def _merge_successful(self):
 
474
        # No conflicts found.
 
475
        info_dialog(_i18n('Merge successful'),
 
476
                    _i18n('All changes applied successfully.'))
 
477
 
 
478
    def _conflicts(self):
 
479
        warning_dialog(_i18n('Conflicts encountered'),
 
480
                       _i18n('Please resolve the conflicts manually'
 
481
                             ' before committing.'))
 
482
 
 
483
    def _handle_error(self, e):
 
484
        error_dialog('Error', str(e))
 
485
 
 
486
    def _get_save_path(self, basename):
 
487
        d = gtk.FileChooserDialog('Save As', self,
 
488
                                  gtk.FILE_CHOOSER_ACTION_SAVE,
 
489
                                  buttons=(gtk.STOCK_OK, gtk.RESPONSE_OK,
 
490
                                           gtk.STOCK_CANCEL,
 
491
                                           gtk.RESPONSE_CANCEL,))
 
492
        d.set_current_name(basename)
 
493
        try:
 
494
            result = d.run()
 
495
            if result != gtk.RESPONSE_OK:
 
496
                raise SelectCancelled()
 
497
            return urlutils.local_path_from_url(d.get_uri())
 
498
        finally:
 
499
            d.destroy()
 
500
 
 
501
    def set_diff(self, description, rev_tree, parent_tree):
 
502
        """Set the differences showed by this window.
 
503
 
 
504
        Compares the two trees and populates the window with the
 
505
        differences.
 
506
        """
 
507
        self.diff.set_diff(rev_tree, parent_tree)
 
508
        self.set_title(description + " - bzrk diff")
 
509
 
 
510
    def set_file(self, file_path):
 
511
        self.diff.set_file(file_path)
 
512
 
 
513
 
 
514
class DiffController(object):
 
515
 
 
516
    def __init__(self, path, patch, window=None):
 
517
        self.path = path
 
518
        self.patch = patch
 
519
        if window is None:
 
520
            window = DiffWindow(operations=self._provide_operations())
 
521
            self.initialize_window(window)
 
522
        self.window = window
 
523
 
 
524
    def initialize_window(self, window):
 
525
        window.diff.set_diff_text_sections(self.get_diff_sections())
 
526
        window.set_title(self.path + " - diff")
 
527
 
 
528
    def get_diff_sections(self):
 
529
        yield "Complete Diff", None, ''.join(self.patch)
 
530
        for patch in parse_patches(self.patch):
 
531
            oldname = patch.oldname.split('\t')[0]
 
532
            newname = patch.newname.split('\t')[0]
 
533
            yield oldname, newname, str(patch)
 
534
 
 
535
    def perform_save(self, window):
 
536
        try:
 
537
            save_path = self.window._get_save_path(osutils.basename(self.path))
 
538
        except SelectCancelled:
 
539
            return
 
540
        source = open(self.path, 'rb')
 
541
        try:
 
542
            target = open(save_path, 'wb')
 
543
            try:
 
544
                osutils.pumpfile(source, target)
 
545
            finally:
 
546
                target.close()
 
547
        finally:
 
548
            source.close()
 
549
 
 
550
    def _provide_operations(self):
 
551
        return [('Save', self.perform_save)]
 
552
 
 
553
 
 
554
class MergeDirectiveController(DiffController):
 
555
 
 
556
    def __init__(self, path, directive, window=None):
 
557
        DiffController.__init__(self, path, directive.patch.splitlines(True),
 
558
                                window)
 
559
        self.directive = directive
 
560
        self.merge_target = None
 
561
 
 
562
    def _provide_operations(self):
 
563
        return [('Merge', self.perform_merge), ('Save', self.perform_save)]
 
564
 
 
565
    def perform_merge(self, window):
 
566
        if self.merge_target is None:
 
567
            try:
 
568
                self.merge_target = self.window._get_merge_target()
 
569
            except SelectCancelled:
 
570
                return
 
571
        tree = workingtree.WorkingTree.open(self.merge_target)
 
572
        tree.lock_write()
 
573
        try:
 
574
            try:
 
575
                merger, verified = _mod_merge.Merger.from_mergeable(tree,
 
576
                    self.directive, progress.DummyProgress())
 
577
                merger.check_basis(True)
 
578
                merger.merge_type = _mod_merge.Merge3Merger
 
579
                conflict_count = merger.do_merge()
 
580
                merger.set_pending()
 
581
                if conflict_count == 0:
 
582
                    self.window._merge_successful()
 
583
                else:
 
584
                    self.window._conflicts()
 
585
                    # There are conflicts to be resolved.
 
586
                self.window.destroy()
 
587
            except Exception, e:
 
588
                self.window._handle_error(e)
 
589
        finally:
 
590
            tree.unlock()
 
591
 
 
592
 
 
593
def iter_changes_to_status(source, target):
 
594
    """Determine the differences between trees.
 
595
 
 
596
    This is a wrapper around iter_changes which just yields more
 
597
    understandable results.
 
598
 
 
599
    :param source: The source tree (basis tree)
 
600
    :param target: The target tree
 
601
    :return: A list of (file_id, real_path, change_type, display_path)
 
602
    """
 
603
    added = 'added'
 
604
    removed = 'removed'
 
605
    renamed = 'renamed'
 
606
    renamed_and_modified = 'renamed and modified'
 
607
    modified = 'modified'
 
608
    kind_changed = 'kind changed'
 
609
 
 
610
    # TODO: Handle metadata changes
 
611
 
 
612
    status = []
 
613
    target.lock_read()
 
614
    try:
 
615
        source.lock_read()
 
616
        try:
 
617
            for (file_id, paths, changed_content, versioned, parent_ids, names,
 
618
                 kinds, executables) in target.iter_changes(source):
 
619
 
 
620
                # Skip the root entry if it isn't very interesting
 
621
                if parent_ids == (None, None):
 
622
                    continue
 
623
 
 
624
                change_type = None
 
625
                if kinds[0] is None:
 
626
                    source_marker = ''
 
627
                else:
 
628
                    source_marker = osutils.kind_marker(kinds[0])
 
629
                if kinds[1] is None:
 
630
                    assert kinds[0] is not None
 
631
                    marker = osutils.kind_marker(kinds[0])
 
632
                else:
 
633
                    marker = osutils.kind_marker(kinds[1])
 
634
 
 
635
                real_path = paths[1]
 
636
                if real_path is None:
 
637
                    real_path = paths[0]
 
638
                assert real_path is not None
 
639
                display_path = real_path + marker
 
640
 
 
641
                present_source = versioned[0] and kinds[0] is not None
 
642
                present_target = versioned[1] and kinds[1] is not None
 
643
 
 
644
                if present_source != present_target:
 
645
                    if present_target:
 
646
                        change_type = added
 
647
                    else:
 
648
                        assert present_source
 
649
                        change_type = removed
 
650
                elif names[0] != names[1] or parent_ids[0] != parent_ids[1]:
 
651
                    # Renamed
 
652
                    if changed_content or executables[0] != executables[1]:
 
653
                        # and modified
 
654
                        change_type = renamed_and_modified
 
655
                    else:
 
656
                        change_type = renamed
 
657
                    display_path = (paths[0] + source_marker
 
658
                                    + ' => ' + paths[1] + marker)
 
659
                elif kinds[0] != kinds[1]:
 
660
                    change_type = kind_changed
 
661
                    display_path = (paths[0] + source_marker
 
662
                                    + ' => ' + paths[1] + marker)
 
663
                elif changed_content is True or executables[0] != executables[1]:
 
664
                    change_type = modified
 
665
                else:
 
666
                    assert False, "How did we get here?"
 
667
 
 
668
                status.append((file_id, real_path, change_type, display_path))
 
669
        finally:
 
670
            source.unlock()
 
671
    finally:
 
672
        target.unlock()
 
673
 
 
674
    return status