/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: Jelmer Vernooij
  • Date: 2008-10-30 13:48:44 UTC
  • Revision ID: jelmer@samba.org-20081030134844-8aayszl9iefcxt1x
Merge trunk, add cia/email fields.

Show diffs side-by-side

added added

removed removed

Lines of Context:
diff.py
1
 
#!/usr/bin/python
2
 
# -*- coding: UTF-8 -*-
3
1
"""Difference window.
4
2
 
5
3
This module contains the code to manage the diff window which shows
6
4
the changes made between two revisions on a branch.
7
5
"""
8
6
 
9
 
__copyright__ = "Copyright © 2005 Canonical Ltd."
 
7
__copyright__ = "Copyright 2005 Canonical Ltd."
10
8
__author__    = "Scott James Remnant <scott@ubuntu.com>"
11
9
 
12
10
 
13
11
from cStringIO import StringIO
14
12
 
 
13
import pygtk
 
14
pygtk.require("2.0")
15
15
import gtk
16
16
import pango
 
17
import os
 
18
import re
17
19
import sys
18
20
 
19
21
try:
21
23
    have_gtksourceview = True
22
24
except ImportError:
23
25
    have_gtksourceview = False
24
 
 
25
 
import bzrlib
26
 
 
27
 
from bzrlib.diff import show_diff_trees
 
26
try:
 
27
    import gconf
 
28
    have_gconf = True
 
29
except ImportError:
 
30
    have_gconf = False
 
31
 
 
32
from bzrlib import (
 
33
    merge as _mod_merge,
 
34
    osutils,
 
35
    progress,
 
36
    urlutils,
 
37
    workingtree,
 
38
)
 
39
from bzrlib.diff import show_diff_trees, internal_diff
28
40
from bzrlib.errors import NoSuchFile
29
 
 
30
 
 
31
 
class DiffWindow(gtk.Window):
32
 
    """Diff window.
33
 
 
34
 
    This object represents and manages a single window containing the
35
 
    differences between two revisions on a branch.
36
 
    """
 
41
from bzrlib.patches import parse_patches
 
42
from bzrlib.trace import warning
 
43
from bzrlib.plugins.gtk import _i18n
 
44
from bzrlib.plugins.gtk.window import Window
 
45
from dialog import error_dialog, info_dialog, warning_dialog
 
46
 
 
47
 
 
48
class SelectCancelled(Exception):
 
49
 
 
50
    pass
 
51
 
 
52
 
 
53
class DiffFileView(gtk.ScrolledWindow):
 
54
    """Window for displaying diffs from a diff file"""
37
55
 
38
56
    def __init__(self):
39
 
        gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
40
 
        self.set_border_width(0)
41
 
        self.set_title("bzrk diff")
42
 
 
43
 
        # Use two thirds of the screen by default
44
 
        screen = self.get_screen()
45
 
        monitor = screen.get_monitor_geometry(0)
46
 
        width = int(monitor.width * 0.66)
47
 
        height = int(monitor.height * 0.66)
48
 
        self.set_default_size(width, height)
49
 
 
 
57
        gtk.ScrolledWindow.__init__(self)
50
58
        self.construct()
 
59
        self._diffs = {}
51
60
 
52
61
    def construct(self):
53
 
        """Construct the window contents."""
54
 
        # The   window  consists  of   a  pane   containing:  the
55
 
        # hierarchical list  of files on  the left, and  the diff
56
 
        # for the currently selected file on the right.
57
 
        pane = gtk.HPaned()
58
 
        self.add(pane)
59
 
        pane.show()
 
62
        self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
 
63
        self.set_shadow_type(gtk.SHADOW_IN)
 
64
 
 
65
        if have_gtksourceview:
 
66
            self.buffer = gtksourceview.SourceBuffer()
 
67
            slm = gtksourceview.SourceLanguagesManager()
 
68
            gsl = slm.get_language_from_mime_type("text/x-patch")
 
69
            if have_gconf:
 
70
                self.apply_gedit_colors(gsl)
 
71
            self.apply_colordiff_colors(gsl)
 
72
            self.buffer.set_language(gsl)
 
73
            self.buffer.set_highlight(True)
 
74
 
 
75
            self.sourceview = gtksourceview.SourceView(self.buffer)
 
76
        else:
 
77
            self.buffer = gtk.TextBuffer()
 
78
            self.sourceview = gtk.TextView(self.buffer)
 
79
 
 
80
        self.sourceview.set_editable(False)
 
81
        self.sourceview.modify_font(pango.FontDescription("Monospace"))
 
82
        self.add(self.sourceview)
 
83
        self.sourceview.show()
 
84
 
 
85
    @staticmethod
 
86
    def apply_gedit_colors(lang):
 
87
        """Set style for lang to that specified in gedit configuration.
 
88
 
 
89
        This method needs the gconf module.
 
90
 
 
91
        :param lang: a gtksourceview.SourceLanguage object.
 
92
        """
 
93
        GEDIT_SYNTAX_PATH = '/apps/gedit-2/preferences/syntax_highlighting'
 
94
        GEDIT_LANG_PATH = GEDIT_SYNTAX_PATH + '/' + lang.get_id()
 
95
 
 
96
        client = gconf.client_get_default()
 
97
        client.add_dir(GEDIT_LANG_PATH, gconf.CLIENT_PRELOAD_NONE)
 
98
 
 
99
        for tag in lang.get_tags():
 
100
            tag_id = tag.get_id()
 
101
            gconf_key = GEDIT_LANG_PATH + '/' + tag_id
 
102
            style_string = client.get_string(gconf_key)
 
103
 
 
104
            if style_string is None:
 
105
                continue
 
106
 
 
107
            # function to get a bool from a string that's either '0' or '1'
 
108
            string_bool = lambda x: bool(int(x))
 
109
 
 
110
            # style_string is a string like "2/#FFCCAA/#000000/0/1/0/0"
 
111
            # values are: mask, fg, bg, italic, bold, underline, strike
 
112
            # this packs them into (str_value, attr_name, conv_func) tuples
 
113
            items = zip(style_string.split('/'), ['mask', 'foreground',
 
114
                'background', 'italic', 'bold', 'underline', 'strikethrough' ],
 
115
                [ int, gtk.gdk.color_parse, gtk.gdk.color_parse, string_bool,
 
116
                    string_bool, string_bool, string_bool ]
 
117
            )
 
118
 
 
119
            style = gtksourceview.SourceTagStyle()
 
120
 
 
121
            # XXX The mask attribute controls whether the present values of
 
122
            # foreground and background color should in fact be used. Ideally
 
123
            # (and that's what gedit does), one could set all three attributes,
 
124
            # and let the TagStyle object figure out which colors to use.
 
125
            # However, in the GtkSourceview python bindings, the mask attribute
 
126
            # is read-only, and it's derived instead from the colors being
 
127
            # set or not. This means that we have to sometimes refrain from
 
128
            # setting fg or bg colors, depending on the value of the mask.
 
129
            # This code could go away if mask were writable.
 
130
            mask = int(items[0][0])
 
131
            if not (mask & 1): # GTK_SOURCE_TAG_STYLE_USE_BACKGROUND
 
132
                items[2:3] = []
 
133
            if not (mask & 2): # GTK_SOURCE_TAG_STYLE_USE_FOREGROUND
 
134
                items[1:2] = []
 
135
            items[0:1] = [] # skip the mask unconditionally
 
136
 
 
137
            for value, attr, func in items:
 
138
                try:
 
139
                    value = func(value)
 
140
                except ValueError:
 
141
                    warning('gconf key %s contains an invalid value: %s'
 
142
                            % gconf_key, value)
 
143
                else:
 
144
                    setattr(style, attr, value)
 
145
 
 
146
            lang.set_tag_style(tag_id, style)
 
147
 
 
148
    @classmethod
 
149
    def apply_colordiff_colors(klass, lang):
 
150
        """Set style colors for lang using the colordiff configuration file.
 
151
 
 
152
        Both ~/.colordiffrc and ~/.colordiffrc.bzr-gtk are read.
 
153
 
 
154
        :param lang: a "Diff" gtksourceview.SourceLanguage object.
 
155
        """
 
156
        colors = {}
 
157
 
 
158
        for f in ('~/.colordiffrc', '~/.colordiffrc.bzr-gtk'):
 
159
            f = os.path.expanduser(f)
 
160
            if os.path.exists(f):
 
161
                try:
 
162
                    f = file(f)
 
163
                except IOError, e:
 
164
                    warning('could not open file %s: %s' % (f, str(e)))
 
165
                else:
 
166
                    colors.update(klass.parse_colordiffrc(f))
 
167
                    f.close()
 
168
 
 
169
        if not colors:
 
170
            # ~/.colordiffrc does not exist
 
171
            return
 
172
 
 
173
        mapping = {
 
174
                # map GtkSourceView tags to colordiff names
 
175
                # since GSV is richer, accept new names for extra bits,
 
176
                # defaulting to old names if they're not present
 
177
                'Added@32@line': ['newtext'],
 
178
                'Removed@32@line': ['oldtext'],
 
179
                'Location': ['location', 'diffstuff'],
 
180
                'Diff@32@file': ['file', 'diffstuff'],
 
181
                'Special@32@case': ['specialcase', 'diffstuff'],
 
182
        }
 
183
 
 
184
        for tag in lang.get_tags():
 
185
            tag_id = tag.get_id()
 
186
            keys = mapping.get(tag_id, [])
 
187
            color = None
 
188
 
 
189
            for key in keys:
 
190
                color = colors.get(key, None)
 
191
                if color is not None:
 
192
                    break
 
193
 
 
194
            if color is None:
 
195
                continue
 
196
 
 
197
            style = gtksourceview.SourceTagStyle()
 
198
            try:
 
199
                style.foreground = gtk.gdk.color_parse(color)
 
200
            except ValueError:
 
201
                warning('not a valid color: %s' % color)
 
202
            else:
 
203
                lang.set_tag_style(tag_id, style)
 
204
 
 
205
    @staticmethod
 
206
    def parse_colordiffrc(fileobj):
 
207
        """Parse fileobj as a colordiff configuration file.
 
208
 
 
209
        :return: A dict with the key -> value pairs.
 
210
        """
 
211
        colors = {}
 
212
        for line in fileobj:
 
213
            if re.match(r'^\s*#', line):
 
214
                continue
 
215
            if '=' not in line:
 
216
                continue
 
217
            key, val = line.split('=', 1)
 
218
            colors[key.strip()] = val.strip()
 
219
        return colors
 
220
 
 
221
    def set_trees(self, rev_tree, parent_tree):
 
222
        self.rev_tree = rev_tree
 
223
        self.parent_tree = parent_tree
 
224
#        self._build_delta()
 
225
 
 
226
#    def _build_delta(self):
 
227
#        self.parent_tree.lock_read()
 
228
#        self.rev_tree.lock_read()
 
229
#        try:
 
230
#            self.delta = iter_changes_to_status(self.parent_tree, self.rev_tree)
 
231
#            self.path_to_status = {}
 
232
#            self.path_to_diff = {}
 
233
#            source_inv = self.parent_tree.inventory
 
234
#            target_inv = self.rev_tree.inventory
 
235
#            for (file_id, real_path, change_type, display_path) in self.delta:
 
236
#                self.path_to_status[real_path] = u'=== %s %s' % (change_type, display_path)
 
237
#                if change_type in ('modified', 'renamed and modified'):
 
238
#                    source_ie = source_inv[file_id]
 
239
#                    target_ie = target_inv[file_id]
 
240
#                    sio = StringIO()
 
241
#                    source_ie.diff(internal_diff, *old path, *old_tree,
 
242
#                                   *new_path, target_ie, self.rev_tree,
 
243
#                                   sio)
 
244
#                    self.path_to_diff[real_path] = 
 
245
#
 
246
#        finally:
 
247
#            self.rev_tree.unlock()
 
248
#            self.parent_tree.unlock()
 
249
 
 
250
    def show_diff(self, specific_files):
 
251
        sections = []
 
252
        if specific_files is None:
 
253
            self.buffer.set_text(self._diffs[None])
 
254
        else:
 
255
            for specific_file in specific_files:
 
256
                sections.append(self._diffs[specific_file])
 
257
            self.buffer.set_text(''.join(sections))
 
258
 
 
259
 
 
260
class DiffView(DiffFileView):
 
261
    """This is the soft and chewy filling for a DiffWindow."""
 
262
 
 
263
    def __init__(self):
 
264
        DiffFileView.__init__(self)
 
265
        self.rev_tree = None
 
266
        self.parent_tree = None
 
267
 
 
268
    def show_diff(self, specific_files):
 
269
        """Show the diff for the specified files"""
 
270
        s = StringIO()
 
271
        show_diff_trees(self.parent_tree, self.rev_tree, s, specific_files,
 
272
                        old_label='', new_label='',
 
273
                        # path_encoding=sys.getdefaultencoding()
 
274
                        # The default is utf-8, but we interpret the file
 
275
                        # contents as getdefaultencoding(), so we should
 
276
                        # probably try to make the paths in the same encoding.
 
277
                        )
 
278
        # str.decode(encoding, 'replace') doesn't do anything. Because if a
 
279
        # character is not valid in 'encoding' there is nothing to replace, the
 
280
        # 'replace' is for 'str.encode()'
 
281
        try:
 
282
            decoded = s.getvalue().decode(sys.getdefaultencoding())
 
283
        except UnicodeDecodeError:
 
284
            try:
 
285
                decoded = s.getvalue().decode('UTF-8')
 
286
            except UnicodeDecodeError:
 
287
                decoded = s.getvalue().decode('iso-8859-1')
 
288
                # This always works, because every byte has a valid
 
289
                # mapping from iso-8859-1 to Unicode
 
290
        # TextBuffer must contain pure UTF-8 data
 
291
        self.buffer.set_text(decoded.encode('UTF-8'))
 
292
 
 
293
 
 
294
class DiffWidget(gtk.HPaned):
 
295
    """Diff widget
 
296
 
 
297
    """
 
298
    def __init__(self):
 
299
        super(DiffWidget, self).__init__()
60
300
 
61
301
        # The file hierarchy: a scrollable treeview
62
302
        scrollwin = gtk.ScrolledWindow()
63
303
        scrollwin.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
64
304
        scrollwin.set_shadow_type(gtk.SHADOW_IN)
65
 
        pane.pack1(scrollwin)
 
305
        self.pack1(scrollwin)
66
306
        scrollwin.show()
67
 
 
 
307
        
68
308
        self.model = gtk.TreeStore(str, str)
69
309
        self.treeview = gtk.TreeView(self.model)
70
310
        self.treeview.set_headers_visible(False)
80
320
        column.add_attribute(cell, "text", 0)
81
321
        self.treeview.append_column(column)
82
322
 
 
323
    def set_diff_text(self, lines):
 
324
        """Set the current diff from a list of lines
 
325
 
 
326
        :param lines: The diff to show, in unified diff format
 
327
        """
83
328
        # The diffs of the  selected file: a scrollable source or
84
329
        # text view
85
 
        scrollwin = gtk.ScrolledWindow()
86
 
        scrollwin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
87
 
        scrollwin.set_shadow_type(gtk.SHADOW_IN)
88
 
        pane.pack2(scrollwin)
89
 
        scrollwin.show()
90
 
 
91
 
        if have_gtksourceview:
92
 
            self.buffer = gtksourceview.SourceBuffer()
93
 
            slm = gtksourceview.SourceLanguagesManager()
94
 
            gsl = slm.get_language_from_mime_type("text/x-patch")
95
 
            self.buffer.set_language(gsl)
96
 
            self.buffer.set_highlight(True)
97
 
 
98
 
            sourceview = gtksourceview.SourceView(self.buffer)
99
 
        else:
100
 
            self.buffer = gtk.TextBuffer()
101
 
            sourceview = gtk.TextView(self.buffer)
102
 
 
103
 
        sourceview.set_editable(False)
104
 
        sourceview.modify_font(pango.FontDescription("Monospace"))
105
 
        scrollwin.add(sourceview)
106
 
        sourceview.show()
107
 
 
108
 
    def set_diff(self, description, rev_tree, parent_tree):
 
330
 
 
331
    def set_diff_text_sections(self, sections):
 
332
        if getattr(self, 'diff_view', None) is None:
 
333
            self.diff_view = DiffFileView()
 
334
            self.pack2(self.diff_view)
 
335
        self.diff_view.show()
 
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):
109
344
        """Set the differences showed by this window.
110
345
 
111
346
        Compares the two trees and populates the window with the
112
347
        differences.
113
348
        """
 
349
        if getattr(self, 'diff_view', None) is None:
 
350
            self.diff_view = DiffView()
 
351
            self.pack2(self.diff_view)
 
352
        self.diff_view.show()
 
353
        self.diff_view.set_trees(rev_tree, parent_tree)
114
354
        self.rev_tree = rev_tree
115
355
        self.parent_tree = parent_tree
116
356
 
141
381
                self.model.append(titer, [ path, path ])
142
382
 
143
383
        self.treeview.expand_all()
144
 
        self.set_title(description + " - bzrk diff")
 
384
        self.diff_view.show_diff(None)
145
385
 
146
386
    def set_file(self, file_path):
 
387
        """Select the current file to display"""
147
388
        tv_path = None
148
389
        for data in self.model:
149
390
            for child in data.iterchildren():
162
403
        if specific_files == [ None ]:
163
404
            return
164
405
        elif specific_files == [ "" ]:
165
 
            specific_files = []
166
 
 
167
 
        s = StringIO()
168
 
        show_diff_trees(self.parent_tree, self.rev_tree, s, specific_files)
169
 
        self.buffer.set_text(s.getvalue().decode(sys.getdefaultencoding(), 'replace'))
 
406
            specific_files = None
 
407
        
 
408
        self.diff_view.show_diff(specific_files)
 
409
    
 
410
    def _on_wraplines_toggled(self, widget=None, wrap=False):
 
411
        """Callback for when the wrap lines checkbutton is toggled"""
 
412
        if wrap or widget.get_active():
 
413
            self.diff_view.sourceview.set_wrap_mode(gtk.WRAP_WORD)
 
414
        else:
 
415
            self.diff_view.sourceview.set_wrap_mode(gtk.WRAP_NONE)
 
416
 
 
417
class DiffWindow(Window):
 
418
    """Diff window.
 
419
 
 
420
    This object represents and manages a single window containing the
 
421
    differences between two revisions on a branch.
 
422
    """
 
423
 
 
424
    def __init__(self, parent=None, operations=None):
 
425
        Window.__init__(self, parent)
 
426
        self.set_border_width(0)
 
427
        self.set_title("bzrk diff")
 
428
 
 
429
        # Use two thirds of the screen by default
 
430
        screen = self.get_screen()
 
431
        monitor = screen.get_monitor_geometry(0)
 
432
        width = int(monitor.width * 0.66)
 
433
        height = int(monitor.height * 0.66)
 
434
        self.set_default_size(width, height)
 
435
        self.construct(operations)
 
436
 
 
437
    def construct(self, operations):
 
438
        """Construct the window contents."""
 
439
        self.vbox = gtk.VBox()
 
440
        self.add(self.vbox)
 
441
        self.vbox.show()
 
442
        self.diff = DiffWidget()
 
443
        self.vbox.pack_end(self.diff, True, True, 0)
 
444
        self.diff.show_all()
 
445
        # Build after DiffWidget to connect signals
 
446
        menubar = self._get_menu_bar()
 
447
        self.vbox.pack_start(menubar, False, False, 0)
 
448
        hbox = self._get_button_bar(operations)
 
449
        if hbox is not None:
 
450
            self.vbox.pack_start(hbox, False, True, 0)
 
451
        
 
452
    
 
453
    def _get_menu_bar(self):
 
454
        menubar = gtk.MenuBar()
 
455
        # View menu
 
456
        mb_view = gtk.MenuItem(_i18n("_View"))
 
457
        mb_view_menu = gtk.Menu()
 
458
        mb_view_wrapsource = gtk.CheckMenuItem(_i18n("Wrap _Long Lines"))
 
459
        mb_view_wrapsource.connect('activate', self.diff._on_wraplines_toggled)
 
460
        mb_view_wrapsource.show()
 
461
        mb_view_menu.append(mb_view_wrapsource)
 
462
        mb_view.show()
 
463
        mb_view.set_submenu(mb_view_menu)
 
464
        mb_view.show()
 
465
        menubar.append(mb_view)
 
466
        menubar.show()
 
467
        return menubar
 
468
    
 
469
    def _get_button_bar(self, operations):
 
470
        """Return a button bar to use.
 
471
 
 
472
        :return: None, meaning that no button bar will be used.
 
473
        """
 
474
        if operations is None:
 
475
            return None
 
476
        hbox = gtk.HButtonBox()
 
477
        hbox.set_layout(gtk.BUTTONBOX_START)
 
478
        for title, method in operations:
 
479
            merge_button = gtk.Button(title)
 
480
            merge_button.show()
 
481
            merge_button.set_relief(gtk.RELIEF_NONE)
 
482
            merge_button.connect("clicked", method)
 
483
            hbox.pack_start(merge_button, expand=False, fill=True)
 
484
        hbox.show()
 
485
        return hbox
 
486
 
 
487
    def _get_merge_target(self):
 
488
        d = gtk.FileChooserDialog('Merge branch', self,
 
489
                                  gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER,
 
490
                                  buttons=(gtk.STOCK_OK, gtk.RESPONSE_OK,
 
491
                                           gtk.STOCK_CANCEL,
 
492
                                           gtk.RESPONSE_CANCEL,))
 
493
        try:
 
494
            result = d.run()
 
495
            if result != gtk.RESPONSE_OK:
 
496
                raise SelectCancelled()
 
497
            return d.get_current_folder_uri()
 
498
        finally:
 
499
            d.destroy()
 
500
 
 
501
    def _merge_successful(self):
 
502
        # No conflicts found.
 
503
        info_dialog(_i18n('Merge successful'),
 
504
                    _i18n('All changes applied successfully.'))
 
505
 
 
506
    def _conflicts(self):
 
507
        warning_dialog(_i18n('Conflicts encountered'),
 
508
                       _i18n('Please resolve the conflicts manually'
 
509
                             ' before committing.'))
 
510
 
 
511
    def _handle_error(self, e):
 
512
        error_dialog('Error', str(e))
 
513
 
 
514
    def _get_save_path(self, basename):
 
515
        d = gtk.FileChooserDialog('Save As', self,
 
516
                                  gtk.FILE_CHOOSER_ACTION_SAVE,
 
517
                                  buttons=(gtk.STOCK_OK, gtk.RESPONSE_OK,
 
518
                                           gtk.STOCK_CANCEL,
 
519
                                           gtk.RESPONSE_CANCEL,))
 
520
        d.set_current_name(basename)
 
521
        try:
 
522
            result = d.run()
 
523
            if result != gtk.RESPONSE_OK:
 
524
                raise SelectCancelled()
 
525
            return urlutils.local_path_from_url(d.get_uri())
 
526
        finally:
 
527
            d.destroy()
 
528
 
 
529
    def set_diff(self, description, rev_tree, parent_tree):
 
530
        """Set the differences showed by this window.
 
531
 
 
532
        Compares the two trees and populates the window with the
 
533
        differences.
 
534
        """
 
535
        self.diff.set_diff(rev_tree, parent_tree)
 
536
        self.set_title(description + " - bzrk diff")
 
537
 
 
538
    def set_file(self, file_path):
 
539
        self.diff.set_file(file_path)
 
540
 
 
541
 
 
542
class DiffController(object):
 
543
 
 
544
    def __init__(self, path, patch, window=None):
 
545
        self.path = path
 
546
        self.patch = patch
 
547
        if window is None:
 
548
            window = DiffWindow(operations=self._provide_operations())
 
549
            self.initialize_window(window)
 
550
        self.window = window
 
551
 
 
552
    def initialize_window(self, window):
 
553
        window.diff.set_diff_text_sections(self.get_diff_sections())
 
554
        window.set_title(self.path + " - diff")
 
555
 
 
556
    def get_diff_sections(self):
 
557
        yield "Complete Diff", None, ''.join(self.patch)
 
558
        for patch in parse_patches(self.patch):
 
559
            oldname = patch.oldname.split('\t')[0]
 
560
            newname = patch.newname.split('\t')[0]
 
561
            yield oldname, newname, str(patch)
 
562
 
 
563
    def perform_save(self, window):
 
564
        try:
 
565
            save_path = self.window._get_save_path(osutils.basename(self.path))
 
566
        except SelectCancelled:
 
567
            return
 
568
        source = open(self.path, 'rb')
 
569
        try:
 
570
            target = open(save_path, 'wb')
 
571
            try:
 
572
                osutils.pumpfile(source, target)
 
573
            finally:
 
574
                target.close()
 
575
        finally:
 
576
            source.close()
 
577
 
 
578
    def _provide_operations(self):
 
579
        return [('Save', self.perform_save)]
 
580
 
 
581
 
 
582
class MergeDirectiveController(DiffController):
 
583
 
 
584
    def __init__(self, path, directive, window=None):
 
585
        DiffController.__init__(self, path, directive.patch.splitlines(True),
 
586
                                window)
 
587
        self.directive = directive
 
588
        self.merge_target = None
 
589
 
 
590
    def _provide_operations(self):
 
591
        return [('Merge', self.perform_merge), ('Save', self.perform_save)]
 
592
 
 
593
    def perform_merge(self, window):
 
594
        if self.merge_target is None:
 
595
            try:
 
596
                self.merge_target = self.window._get_merge_target()
 
597
            except SelectCancelled:
 
598
                return
 
599
        tree = workingtree.WorkingTree.open(self.merge_target)
 
600
        tree.lock_write()
 
601
        try:
 
602
            try:
 
603
                merger, verified = _mod_merge.Merger.from_mergeable(tree,
 
604
                    self.directive, progress.DummyProgress())
 
605
                merger.check_basis(True)
 
606
                merger.merge_type = _mod_merge.Merge3Merger
 
607
                conflict_count = merger.do_merge()
 
608
                merger.set_pending()
 
609
                if conflict_count == 0:
 
610
                    self.window._merge_successful()
 
611
                else:
 
612
                    self.window._conflicts()
 
613
                    # There are conflicts to be resolved.
 
614
                self.window.destroy()
 
615
            except Exception, e:
 
616
                self.window._handle_error(e)
 
617
        finally:
 
618
            tree.unlock()
 
619
 
 
620
 
 
621
def iter_changes_to_status(source, target):
 
622
    """Determine the differences between trees.
 
623
 
 
624
    This is a wrapper around iter_changes which just yields more
 
625
    understandable results.
 
626
 
 
627
    :param source: The source tree (basis tree)
 
628
    :param target: The target tree
 
629
    :return: A list of (file_id, real_path, change_type, display_path)
 
630
    """
 
631
    added = 'added'
 
632
    removed = 'removed'
 
633
    renamed = 'renamed'
 
634
    renamed_and_modified = 'renamed and modified'
 
635
    modified = 'modified'
 
636
    kind_changed = 'kind changed'
 
637
    missing = 'missing'
 
638
 
 
639
    # TODO: Handle metadata changes
 
640
 
 
641
    status = []
 
642
    target.lock_read()
 
643
    try:
 
644
        source.lock_read()
 
645
        try:
 
646
            for (file_id, paths, changed_content, versioned, parent_ids, names,
 
647
                 kinds, executables) in target.iter_changes(source):
 
648
 
 
649
                # Skip the root entry if it isn't very interesting
 
650
                if parent_ids == (None, None):
 
651
                    continue
 
652
 
 
653
                change_type = None
 
654
                if kinds[0] is None:
 
655
                    source_marker = ''
 
656
                else:
 
657
                    source_marker = osutils.kind_marker(kinds[0])
 
658
 
 
659
                if kinds[1] is None:
 
660
                    if kinds[0] is None:
 
661
                        # We assume bzr will flag only files in that case,
 
662
                        # there may be a bzr bug there as only files seems to
 
663
                        # not receive any kind.
 
664
                        marker = osutils.kind_marker('file')
 
665
                    else:
 
666
                        marker = osutils.kind_marker(kinds[0])
 
667
                else:
 
668
                    marker = osutils.kind_marker(kinds[1])
 
669
 
 
670
                real_path = paths[1]
 
671
                if real_path is None:
 
672
                    real_path = paths[0]
 
673
                assert real_path is not None
 
674
 
 
675
                present_source = versioned[0] and kinds[0] is not None
 
676
                present_target = versioned[1] and kinds[1] is not None
 
677
 
 
678
                if kinds[0] is None and kinds[1] is None:
 
679
                    change_type = missing
 
680
                    display_path = real_path + marker
 
681
                elif present_source != present_target:
 
682
                    if present_target:
 
683
                        change_type = added
 
684
                    else:
 
685
                        assert present_source
 
686
                        change_type = removed
 
687
                    display_path = real_path + marker
 
688
                elif names[0] != names[1] or parent_ids[0] != parent_ids[1]:
 
689
                    # Renamed
 
690
                    if changed_content or executables[0] != executables[1]:
 
691
                        # and modified
 
692
                        change_type = renamed_and_modified
 
693
                    else:
 
694
                        change_type = renamed
 
695
                    display_path = (paths[0] + source_marker
 
696
                                    + ' => ' + paths[1] + marker)
 
697
                elif kinds[0] != kinds[1]:
 
698
                    change_type = kind_changed
 
699
                    display_path = (paths[0] + source_marker
 
700
                                    + ' => ' + paths[1] + marker)
 
701
                elif changed_content or executables[0] != executables[1]:
 
702
                    change_type = modified
 
703
                    display_path = real_path + marker
 
704
                else:
 
705
                    assert False, "How did we get here?"
 
706
 
 
707
                status.append((file_id, real_path, change_type, display_path))
 
708
        finally:
 
709
            source.unlock()
 
710
    finally:
 
711
        target.unlock()
 
712
 
 
713
    return status