/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: 2010-03-03 14:10:25 UTC
  • mto: This revision was merged to the branch mainline in revision 686.
  • Revision ID: jelmer@samba.org-20100303141025-rz53ongyh8miv3q5
https://launchpad.net/bugs/339284
Don't crash when there is already a lan-notify instance running.

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