/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: Mark Lee
  • Date: 2009-07-10 20:07:43 UTC
  • mto: This revision was merged to the branch mainline in revision 661.
  • Revision ID: bzr@lazymalevolence.com-20090710200743-2s9x0xa8jgs9wf8s
Remove credits.pickle (generated file).

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