/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: John Ferlito
  • Date: 2009-10-06 13:57:12 UTC
  • mto: This revision was merged to the branch mainline in revision 668.
  • Revision ID: johnf@inodes.org-20091006135712-22vfb36os1toe5qb
Encoding key is now deprecated in the FreeDesktop standard

Show diffs side-by-side

added added

removed removed

Lines of Context:
diff.py
5
5
"""
6
6
 
7
7
__copyright__ = "Copyright 2005 Canonical Ltd."
8
 
__author__ = "Scott James Remnant <scott@ubuntu.com>"
 
8
__author__    = "Scott James Remnant <scott@ubuntu.com>"
9
9
 
10
10
 
11
11
from cStringIO import StringIO
12
12
 
 
13
import pygtk
 
14
pygtk.require("2.0")
 
15
import gtk
 
16
import pango
 
17
import os
 
18
import re
13
19
import sys
14
 
import inspect
 
20
from xml.etree.ElementTree import Element, SubElement, tostring
15
21
 
16
 
from gi.repository import Gtk
17
 
from gi.repository import Pango
18
22
try:
19
 
    from gi.repository import GtkSource
 
23
    import gtksourceview2
20
24
    have_gtksourceview = True
21
25
except ImportError:
22
26
    have_gtksourceview = False
 
27
try:
 
28
    import gconf
 
29
    have_gconf = True
 
30
except ImportError:
 
31
    have_gconf = False
23
32
 
24
33
from bzrlib import (
25
 
    errors,
26
34
    merge as _mod_merge,
27
35
    osutils,
 
36
    progress,
28
37
    urlutils,
29
38
    workingtree,
30
 
    )
31
 
from bzrlib.diff import show_diff_trees
 
39
)
 
40
from bzrlib.diff import show_diff_trees, internal_diff
 
41
from bzrlib.errors import NoSuchFile
32
42
from bzrlib.patches import parse_patches
33
 
from bzrlib.plugins.gtk.dialog import (
34
 
    error_dialog,
35
 
    info_dialog,
36
 
    warning_dialog,
37
 
    )
38
 
from bzrlib.plugins.gtk.i18n import _i18n
 
43
from bzrlib.trace import warning
 
44
from bzrlib.plugins.gtk import _i18n
39
45
from bzrlib.plugins.gtk.window import Window
 
46
from dialog import error_dialog, info_dialog, warning_dialog
40
47
 
41
48
 
42
49
def fallback_guess_language(slm, content_type):
52
59
    pass
53
60
 
54
61
 
55
 
class DiffFileView(Gtk.ScrolledWindow):
 
62
class DiffFileView(gtk.ScrolledWindow):
56
63
    """Window for displaying diffs from a diff file"""
57
64
 
58
 
    SHOW_WIDGETS = True
59
 
 
60
65
    def __init__(self):
61
 
        super(DiffFileView, self).__init__()
 
66
        gtk.ScrolledWindow.__init__(self)
62
67
        self.construct()
63
68
        self._diffs = {}
64
69
 
65
70
    def construct(self):
66
 
        self.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
67
 
        self.set_shadow_type(Gtk.ShadowType.IN)
 
71
        self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
 
72
        self.set_shadow_type(gtk.SHADOW_IN)
68
73
 
69
74
        if have_gtksourceview:
70
 
            self.buffer = GtkSource.Buffer()
71
 
            lang_manager = GtkSource.LanguageManager.get_default()
72
 
            language = lang_manager.guess_language(None, "text/x-patch")
73
 
            self.buffer.set_language(language)
 
75
            self.buffer = gtksourceview2.Buffer()
 
76
            slm = gtksourceview2.LanguageManager()
 
77
            guess_language = getattr(gtksourceview2.LanguageManager, 
 
78
                "guess_language", fallback_guess_language)
 
79
            gsl = guess_language(slm, content_type="text/x-patch")
 
80
            if have_gconf:
 
81
                self.apply_gedit_colors(self.buffer)
 
82
            self.apply_colordiff_colors(self.buffer)
 
83
            self.buffer.set_language(gsl)
74
84
            self.buffer.set_highlight_syntax(True)
75
 
            self.sourceview = GtkSource.View(buffer=self.buffer)
 
85
 
 
86
            self.sourceview = gtksourceview2.View(self.buffer)
76
87
        else:
77
 
            self.buffer = Gtk.TextBuffer()
78
 
            self.sourceview = Gtk.TextView(self.buffer)
 
88
            self.buffer = gtk.TextBuffer()
 
89
            self.sourceview = gtk.TextView(self.buffer)
79
90
 
80
91
        self.sourceview.set_editable(False)
81
 
        self.sourceview.override_font(Pango.FontDescription("Monospace"))
 
92
        self.sourceview.modify_font(pango.FontDescription("Monospace"))
82
93
        self.add(self.sourceview)
83
 
        if self.SHOW_WIDGETS:
84
 
            self.sourceview.show()
 
94
        self.sourceview.show()
 
95
 
 
96
    @staticmethod
 
97
    def apply_gedit_colors(buf):
 
98
        """Set style to that specified in gedit configuration.
 
99
 
 
100
        This method needs the gconf module.
 
101
 
 
102
        :param buf: a gtksourceview2.Buffer object.
 
103
        """
 
104
        GEDIT_SCHEME_PATH = '/apps/gedit-2/preferences/editor/colors/scheme'
 
105
 
 
106
        client = gconf.client_get_default()
 
107
        style_scheme_name = client.get_string(GEDIT_SCHEME_PATH)
 
108
        if style_scheme_name is not None:
 
109
            style_scheme = gtksourceview2.StyleSchemeManager().get_scheme(style_scheme_name)
 
110
            
 
111
            buf.set_style_scheme(style_scheme)
 
112
 
 
113
    @classmethod
 
114
    def apply_colordiff_colors(klass, buf):
 
115
        """Set style colors for lang using the colordiff configuration file.
 
116
 
 
117
        Both ~/.colordiffrc and ~/.colordiffrc.bzr-gtk are read.
 
118
 
 
119
        :param buf: a "Diff" gtksourceview2.Buffer object.
 
120
        """
 
121
        scheme_manager = gtksourceview2.StyleSchemeManager()
 
122
        style_scheme = scheme_manager.get_scheme('colordiff')
 
123
        
 
124
        # if style scheme not found, we'll generate it from colordiffrc
 
125
        # TODO: reload if colordiffrc has changed.
 
126
        if style_scheme is None:
 
127
            colors = {}
 
128
 
 
129
            for f in ('~/.colordiffrc', '~/.colordiffrc.bzr-gtk'):
 
130
                f = os.path.expanduser(f)
 
131
                if os.path.exists(f):
 
132
                    try:
 
133
                        f = file(f)
 
134
                    except IOError, e:
 
135
                        warning('could not open file %s: %s' % (f, str(e)))
 
136
                    else:
 
137
                        colors.update(klass.parse_colordiffrc(f))
 
138
                        f.close()
 
139
 
 
140
            if not colors:
 
141
                # ~/.colordiffrc does not exist
 
142
                return
 
143
            
 
144
            mapping = {
 
145
                # map GtkSourceView2 scheme styles to colordiff names
 
146
                # since GSV is richer, accept new names for extra bits,
 
147
                # defaulting to old names if they're not present
 
148
                'diff:added-line': ['newtext'],
 
149
                'diff:removed-line': ['oldtext'],
 
150
                'diff:location': ['location', 'diffstuff'],
 
151
                'diff:file': ['file', 'diffstuff'],
 
152
                'diff:special-case': ['specialcase', 'diffstuff'],
 
153
            }
 
154
            
 
155
            converted_colors = {}
 
156
            for name, values in mapping.items():
 
157
                color = None
 
158
                for value in values:
 
159
                    color = colors.get(value, None)
 
160
                    if color is not None:
 
161
                        break
 
162
                if color is None:
 
163
                    continue
 
164
                converted_colors[name] = color
 
165
            
 
166
            # some xml magic to produce needed style scheme description
 
167
            e_style_scheme = Element('style-scheme')
 
168
            e_style_scheme.set('id', 'colordiff')
 
169
            e_style_scheme.set('_name', 'ColorDiff')
 
170
            e_style_scheme.set('version', '1.0')
 
171
            for name, color in converted_colors.items():
 
172
                style = SubElement(e_style_scheme, 'style')
 
173
                style.set('name', name)
 
174
                style.set('foreground', '#%s' % color)
 
175
            
 
176
            scheme_xml = tostring(e_style_scheme, 'UTF-8')
 
177
            if not os.path.exists(os.path.expanduser('~/.local/share/gtksourceview-2.0/styles')):
 
178
                os.makedirs(os.path.expanduser('~/.local/share/gtksourceview-2.0/styles'))
 
179
            file(os.path.expanduser('~/.local/share/gtksourceview-2.0/styles/colordiff.xml'), 'w').write(scheme_xml)
 
180
            
 
181
            scheme_manager.force_rescan()
 
182
            style_scheme = scheme_manager.get_scheme('colordiff')
 
183
        
 
184
        buf.set_style_scheme(style_scheme)
 
185
 
 
186
    @staticmethod
 
187
    def parse_colordiffrc(fileobj):
 
188
        """Parse fileobj as a colordiff configuration file.
 
189
 
 
190
        :return: A dict with the key -> value pairs.
 
191
        """
 
192
        colors = {}
 
193
        for line in fileobj:
 
194
            if re.match(r'^\s*#', line):
 
195
                continue
 
196
            if '=' not in line:
 
197
                continue
 
198
            key, val = line.split('=', 1)
 
199
            colors[key.strip()] = val.strip()
 
200
        return colors
85
201
 
86
202
    def set_trees(self, rev_tree, parent_tree):
87
203
        self.rev_tree = rev_tree
92
208
#        self.parent_tree.lock_read()
93
209
#        self.rev_tree.lock_read()
94
210
#        try:
95
 
#            self.delta = iter_changes_to_status(
96
 
#               self.parent_tree, self.rev_tree)
 
211
#            self.delta = iter_changes_to_status(self.parent_tree, self.rev_tree)
97
212
#            self.path_to_status = {}
98
213
#            self.path_to_diff = {}
99
214
#            source_inv = self.parent_tree.inventory
100
215
#            target_inv = self.rev_tree.inventory
101
216
#            for (file_id, real_path, change_type, display_path) in self.delta:
102
 
#                self.path_to_status[real_path] = u'=== %s %s' % (
103
 
#                    change_type, display_path)
 
217
#                self.path_to_status[real_path] = u'=== %s %s' % (change_type, display_path)
104
218
#                if change_type in ('modified', 'renamed and modified'):
105
219
#                    source_ie = source_inv[file_id]
106
220
#                    target_ie = target_inv[file_id]
108
222
#                    source_ie.diff(internal_diff, *old path, *old_tree,
109
223
#                                   *new_path, target_ie, self.rev_tree,
110
224
#                                   sio)
111
 
#                    self.path_to_diff[real_path] =
 
225
#                    self.path_to_diff[real_path] = 
112
226
#
113
227
#        finally:
114
228
#            self.rev_tree.unlock()
128
242
    """This is the soft and chewy filling for a DiffWindow."""
129
243
 
130
244
    def __init__(self):
131
 
        super(DiffView, self).__init__()
 
245
        DiffFileView.__init__(self)
132
246
        self.rev_tree = None
133
247
        self.parent_tree = None
134
248
 
158
272
        self.buffer.set_text(decoded.encode('UTF-8'))
159
273
 
160
274
 
161
 
class DiffWidget(Gtk.HPaned):
 
275
class DiffWidget(gtk.HPaned):
162
276
    """Diff widget
163
277
 
164
278
    """
165
 
 
166
 
    SHOW_WIDGETS = True
167
 
 
168
279
    def __init__(self):
169
280
        super(DiffWidget, self).__init__()
170
281
 
171
282
        # The file hierarchy: a scrollable treeview
172
 
        scrollwin = Gtk.ScrolledWindow()
173
 
        scrollwin.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
174
 
        scrollwin.set_shadow_type(Gtk.ShadowType.IN)
 
283
        scrollwin = gtk.ScrolledWindow()
 
284
        scrollwin.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
 
285
        scrollwin.set_shadow_type(gtk.SHADOW_IN)
175
286
        self.pack1(scrollwin)
176
 
        if self.SHOW_WIDGETS:
177
 
            scrollwin.show()
178
 
 
179
 
        self.model = Gtk.TreeStore(str, str)
180
 
        self.treeview = Gtk.TreeView(model=self.model)
 
287
        scrollwin.show()
 
288
        
 
289
        self.model = gtk.TreeStore(str, str)
 
290
        self.treeview = gtk.TreeView(self.model)
181
291
        self.treeview.set_headers_visible(False)
182
292
        self.treeview.set_search_column(1)
183
293
        self.treeview.connect("cursor-changed", self._treeview_cursor_cb)
184
294
        scrollwin.add(self.treeview)
185
 
        if self.SHOW_WIDGETS:
186
 
            self.treeview.show()
 
295
        self.treeview.show()
187
296
 
188
 
        cell = Gtk.CellRendererText()
 
297
        cell = gtk.CellRendererText()
189
298
        cell.set_property("width-chars", 20)
190
 
        column = Gtk.TreeViewColumn()
191
 
        column.pack_start(cell, True)
 
299
        column = gtk.TreeViewColumn()
 
300
        column.pack_start(cell, expand=True)
192
301
        column.add_attribute(cell, "text", 0)
193
302
        self.treeview.append_column(column)
194
303
 
204
313
        if getattr(self, 'diff_view', None) is None:
205
314
            self.diff_view = DiffFileView()
206
315
            self.pack2(self.diff_view)
207
 
        if self.SHOW_WIDGETS:
208
 
            self.diff_view.show()
 
316
        self.diff_view.show()
209
317
        for oldname, newname, patch in sections:
210
318
            self.diff_view._diffs[newname] = str(patch)
211
319
            if newname is None:
222
330
        if getattr(self, 'diff_view', None) is None:
223
331
            self.diff_view = DiffView()
224
332
            self.pack2(self.diff_view)
225
 
        if self.SHOW_WIDGETS:
226
 
            self.diff_view.show()
 
333
        self.diff_view.show()
227
334
        self.diff_view.set_trees(rev_tree, parent_tree)
228
335
        self.rev_tree = rev_tree
229
336
        self.parent_tree = parent_tree
231
338
        self.model.clear()
232
339
        delta = self.rev_tree.changes_from(self.parent_tree)
233
340
 
234
 
        self.model.append(None, ["Complete Diff", ""])
 
341
        self.model.append(None, [ "Complete Diff", "" ])
235
342
 
236
343
        if len(delta.added):
237
 
            titer = self.model.append(None, ["Added", None])
 
344
            titer = self.model.append(None, [ "Added", None ])
238
345
            for path, id, kind in delta.added:
239
 
                self.model.append(titer, [path, path])
 
346
                self.model.append(titer, [ path, path ])
240
347
 
241
348
        if len(delta.removed):
242
 
            titer = self.model.append(None, ["Removed", None])
 
349
            titer = self.model.append(None, [ "Removed", None ])
243
350
            for path, id, kind in delta.removed:
244
 
                self.model.append(titer, [path, path])
 
351
                self.model.append(titer, [ path, path ])
245
352
 
246
353
        if len(delta.renamed):
247
 
            titer = self.model.append(None, ["Renamed", None])
 
354
            titer = self.model.append(None, [ "Renamed", None ])
248
355
            for oldpath, newpath, id, kind, text_modified, meta_modified \
249
356
                    in delta.renamed:
250
 
                self.model.append(titer, [oldpath, newpath])
 
357
                self.model.append(titer, [ oldpath, newpath ])
251
358
 
252
359
        if len(delta.modified):
253
 
            titer = self.model.append(None, ["Modified", None])
 
360
            titer = self.model.append(None, [ "Modified", None ])
254
361
            for path, id, kind, text_modified, meta_modified in delta.modified:
255
 
                self.model.append(titer, [path, path])
 
362
                self.model.append(titer, [ path, path ])
256
363
 
257
364
        self.treeview.expand_all()
258
365
        self.diff_view.show_diff(None)
266
373
                    tv_path = child.path
267
374
                    break
268
375
        if tv_path is None:
269
 
            raise errors.NoSuchFile(file_path)
270
 
        self.treeview.set_cursor(tv_path, None, False)
 
376
            raise NoSuchFile(file_path)
 
377
        self.treeview.set_cursor(tv_path)
271
378
        self.treeview.scroll_to_cell(tv_path)
272
379
 
273
380
    def _treeview_cursor_cb(self, *args):
274
381
        """Callback for when the treeview cursor changes."""
275
382
        (path, col) = self.treeview.get_cursor()
276
 
        if path is None:
277
 
            return
278
 
        specific_files = [self.model[path][1]]
279
 
        if specific_files == [None]:
280
 
            return
281
 
        elif specific_files == [""]:
 
383
        specific_files = [ self.model[path][1] ]
 
384
        if specific_files == [ None ]:
 
385
            return
 
386
        elif specific_files == [ "" ]:
282
387
            specific_files = None
283
 
 
 
388
        
284
389
        self.diff_view.show_diff(specific_files)
285
 
 
 
390
    
286
391
    def _on_wraplines_toggled(self, widget=None, wrap=False):
287
392
        """Callback for when the wrap lines checkbutton is toggled"""
288
393
        if wrap or widget.get_active():
289
 
            self.diff_view.sourceview.set_wrap_mode(Gtk.WrapMode.WORD)
 
394
            self.diff_view.sourceview.set_wrap_mode(gtk.WRAP_WORD)
290
395
        else:
291
 
            self.diff_view.sourceview.set_wrap_mode(Gtk.WrapMode.NONE)
292
 
 
 
396
            self.diff_view.sourceview.set_wrap_mode(gtk.WRAP_NONE)
293
397
 
294
398
class DiffWindow(Window):
295
399
    """Diff window.
298
402
    differences between two revisions on a branch.
299
403
    """
300
404
 
301
 
    SHOW_WIDGETS = True
302
 
 
303
405
    def __init__(self, parent=None, operations=None):
304
 
        super(DiffWindow, self).__init__(parent=parent)
 
406
        Window.__init__(self, parent)
305
407
        self.set_border_width(0)
306
 
        self.set_title("bzr diff")
 
408
        self.set_title("bzrk diff")
307
409
 
308
410
        # Use two thirds of the screen by default
309
411
        screen = self.get_screen()
315
417
 
316
418
    def construct(self, operations):
317
419
        """Construct the window contents."""
318
 
        self.vbox = Gtk.VBox()
 
420
        self.vbox = gtk.VBox()
319
421
        self.add(self.vbox)
320
 
        if self.SHOW_WIDGETS:
321
 
            self.vbox.show()
 
422
        self.vbox.show()
322
423
        self.diff = DiffWidget()
323
424
        self.vbox.pack_end(self.diff, True, True, 0)
324
 
        if self.SHOW_WIDGETS:
325
 
            self.diff.show_all()
 
425
        self.diff.show_all()
326
426
        # Build after DiffWidget to connect signals
327
427
        menubar = self._get_menu_bar()
328
428
        self.vbox.pack_start(menubar, False, False, 0)
329
429
        hbox = self._get_button_bar(operations)
330
430
        if hbox is not None:
331
431
            self.vbox.pack_start(hbox, False, True, 0)
332
 
 
 
432
        
 
433
    
333
434
    def _get_menu_bar(self):
334
 
        menubar = Gtk.MenuBar()
 
435
        menubar = gtk.MenuBar()
335
436
        # View menu
336
 
        mb_view = Gtk.MenuItem.new_with_mnemonic(_i18n("_View"))
337
 
        mb_view_menu = Gtk.Menu()
338
 
        mb_view_wrapsource = Gtk.CheckMenuItem.new_with_mnemonic(
339
 
            _i18n("Wrap _Long Lines"))
 
437
        mb_view = gtk.MenuItem(_i18n("_View"))
 
438
        mb_view_menu = gtk.Menu()
 
439
        mb_view_wrapsource = gtk.CheckMenuItem(_i18n("Wrap _Long Lines"))
340
440
        mb_view_wrapsource.connect('activate', self.diff._on_wraplines_toggled)
 
441
        mb_view_wrapsource.show()
341
442
        mb_view_menu.append(mb_view_wrapsource)
 
443
        mb_view.show()
342
444
        mb_view.set_submenu(mb_view_menu)
 
445
        mb_view.show()
343
446
        menubar.append(mb_view)
344
 
        if self.SHOW_WIDGETS:
345
 
            menubar.show_all()
 
447
        menubar.show()
346
448
        return menubar
347
 
 
 
449
    
348
450
    def _get_button_bar(self, operations):
349
451
        """Return a button bar to use.
350
452
 
352
454
        """
353
455
        if operations is None:
354
456
            return None
355
 
        hbox = Gtk.HButtonBox()
356
 
        hbox.set_layout(Gtk.ButtonBoxStyle.START)
 
457
        hbox = gtk.HButtonBox()
 
458
        hbox.set_layout(gtk.BUTTONBOX_START)
357
459
        for title, method in operations:
358
 
            merge_button = Gtk.Button(title)
359
 
            if self.SHOW_WIDGETS:
360
 
                merge_button.show()
361
 
            merge_button.set_relief(Gtk.ReliefStyle.NONE)
 
460
            merge_button = gtk.Button(title)
 
461
            merge_button.show()
 
462
            merge_button.set_relief(gtk.RELIEF_NONE)
362
463
            merge_button.connect("clicked", method)
363
 
            hbox.pack_start(merge_button, False, True, 0)
364
 
        if self.SHOW_WIDGETS:
365
 
            hbox.show()
 
464
            hbox.pack_start(merge_button, expand=False, fill=True)
 
465
        hbox.show()
366
466
        return hbox
367
467
 
368
468
    def _get_merge_target(self):
369
 
        d = Gtk.FileChooserDialog('Merge branch', self,
370
 
                                  Gtk.FileChooserAction.SELECT_FOLDER,
371
 
                                  buttons=(Gtk.STOCK_OK, Gtk.ResponseType.OK,
372
 
                                           Gtk.STOCK_CANCEL,
373
 
                                           Gtk.ResponseType.CANCEL,))
 
469
        d = gtk.FileChooserDialog('Merge branch', self,
 
470
                                  gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER,
 
471
                                  buttons=(gtk.STOCK_OK, gtk.RESPONSE_OK,
 
472
                                           gtk.STOCK_CANCEL,
 
473
                                           gtk.RESPONSE_CANCEL,))
374
474
        try:
375
475
            result = d.run()
376
 
            if result != Gtk.ResponseType.OK:
 
476
            if result != gtk.RESPONSE_OK:
377
477
                raise SelectCancelled()
378
478
            return d.get_current_folder_uri()
379
479
        finally:
393
493
        error_dialog('Error', str(e))
394
494
 
395
495
    def _get_save_path(self, basename):
396
 
        d = Gtk.FileChooserDialog('Save As', self,
397
 
                                  Gtk.FileChooserAction.SAVE,
398
 
                                  buttons=(Gtk.STOCK_OK, Gtk.ResponseType.OK,
399
 
                                           Gtk.STOCK_CANCEL,
400
 
                                           Gtk.ResponseType.CANCEL,))
 
496
        d = gtk.FileChooserDialog('Save As', self,
 
497
                                  gtk.FILE_CHOOSER_ACTION_SAVE,
 
498
                                  buttons=(gtk.STOCK_OK, gtk.RESPONSE_OK,
 
499
                                           gtk.STOCK_CANCEL,
 
500
                                           gtk.RESPONSE_CANCEL,))
401
501
        d.set_current_name(basename)
402
502
        try:
403
503
            result = d.run()
404
 
            if result != Gtk.ResponseType.OK:
 
504
            if result != gtk.RESPONSE_OK:
405
505
                raise SelectCancelled()
406
506
            return urlutils.local_path_from_url(d.get_uri())
407
507
        finally:
422
522
 
423
523
class DiffController(object):
424
524
 
425
 
    def __init__(self, path, patch, window=None, allow_dirty=False):
 
525
    def __init__(self, path, patch, window=None):
426
526
        self.path = path
427
527
        self.patch = patch
428
 
        self.allow_dirty = allow_dirty
429
528
        if window is None:
430
529
            window = DiffWindow(operations=self._provide_operations())
431
530
            self.initialize_window(window)
437
536
 
438
537
    def get_diff_sections(self):
439
538
        yield "Complete Diff", None, ''.join(self.patch)
440
 
        # allow_dirty was added to parse_patches in bzrlib 2.2b1
441
 
        if 'allow_dirty' in inspect.getargspec(parse_patches).args:
442
 
            patches = parse_patches(self.patch, allow_dirty=self.allow_dirty)
443
 
        else:
444
 
            patches = parse_patches(self.patch)
445
 
        for patch in patches:
 
539
        for patch in parse_patches(self.patch):
446
540
            oldname = patch.oldname.split('\t')[0]
447
541
            newname = patch.newname.split('\t')[0]
448
542
            yield oldname, newname, str(patch)
469
563
class MergeDirectiveController(DiffController):
470
564
 
471
565
    def __init__(self, path, directive, window=None):
472
 
        super(MergeDirectiveController, self).__init__(
473
 
            path, directive.patch.splitlines(True), window)
 
566
        DiffController.__init__(self, path, directive.patch.splitlines(True),
 
567
                                window)
474
568
        self.directive = directive
475
569
        self.merge_target = None
476
570
 
487
581
        tree.lock_write()
488
582
        try:
489
583
            try:
490
 
                if tree.has_changes():
491
 
                    raise errors.UncommittedChanges(tree)
492
 
                merger, verified = _mod_merge.Merger.from_mergeable(
493
 
                    tree, self.directive, pb=None)
 
584
                merger, verified = _mod_merge.Merger.from_mergeable(tree,
 
585
                    self.directive, progress.DummyProgress())
 
586
                merger.check_basis(True)
494
587
                merger.merge_type = _mod_merge.Merge3Merger
495
588
                conflict_count = merger.do_merge()
496
589
                merger.set_pending()