/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: 2012-07-09 15:23:26 UTC
  • mto: This revision was merged to the branch mainline in revision 794.
  • Revision ID: jelmer@samba.org-20120709152326-dzxb8zoz0btull7n
https://launchpad.net/bugs/714767
https://launchpad.net/bugs/949798
https://launchpad.net/bugs/998994
https://launchpad.net/bugs/342135
https://launchpad.net/bugs/342136
https://launchpad.net/bugs/394536
Remove bzr-notify.

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
19
13
import sys
20
 
from xml.etree.ElementTree import Element, SubElement, tostring
 
14
import inspect
21
15
 
 
16
from gi.repository import Gtk
 
17
from gi.repository import Pango
22
18
try:
23
 
    import gtksourceview2
 
19
    from gi.repository import GtkSource
24
20
    have_gtksourceview = True
25
21
except ImportError:
26
22
    have_gtksourceview = False
27
 
try:
28
 
    import gconf
29
 
    have_gconf = True
30
 
except ImportError:
31
 
    have_gconf = False
32
23
 
33
24
from bzrlib import (
 
25
    errors,
34
26
    merge as _mod_merge,
35
27
    osutils,
36
 
    progress,
37
28
    urlutils,
38
29
    workingtree,
39
 
)
40
 
from bzrlib.diff import show_diff_trees, internal_diff
41
 
from bzrlib.errors import NoSuchFile
 
30
    )
 
31
from bzrlib.diff import show_diff_trees
42
32
from bzrlib.patches import parse_patches
43
 
from bzrlib.trace import warning
44
 
from bzrlib.plugins.gtk import _i18n
 
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
39
from bzrlib.plugins.gtk.window import Window
46
 
from dialog import error_dialog, info_dialog, warning_dialog
47
40
 
48
41
 
49
42
def fallback_guess_language(slm, content_type):
59
52
    pass
60
53
 
61
54
 
62
 
class DiffFileView(gtk.ScrolledWindow):
 
55
class DiffFileView(Gtk.ScrolledWindow):
63
56
    """Window for displaying diffs from a diff file"""
64
57
 
 
58
    SHOW_WIDGETS = True
 
59
 
65
60
    def __init__(self):
66
 
        gtk.ScrolledWindow.__init__(self)
 
61
        super(DiffFileView, self).__init__()
67
62
        self.construct()
68
63
        self._diffs = {}
69
64
 
70
65
    def construct(self):
71
 
        self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
72
 
        self.set_shadow_type(gtk.SHADOW_IN)
 
66
        self.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
 
67
        self.set_shadow_type(Gtk.ShadowType.IN)
73
68
 
74
69
        if have_gtksourceview:
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)
 
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)
84
74
            self.buffer.set_highlight_syntax(True)
85
 
 
86
 
            self.sourceview = gtksourceview2.View(self.buffer)
 
75
            self.sourceview = GtkSource.View(buffer=self.buffer)
87
76
        else:
88
 
            self.buffer = gtk.TextBuffer()
89
 
            self.sourceview = gtk.TextView(self.buffer)
 
77
            self.buffer = Gtk.TextBuffer()
 
78
            self.sourceview = Gtk.TextView(self.buffer)
90
79
 
91
80
        self.sourceview.set_editable(False)
92
 
        self.sourceview.modify_font(pango.FontDescription("Monospace"))
 
81
        self.sourceview.override_font(Pango.FontDescription("Monospace"))
93
82
        self.add(self.sourceview)
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
 
83
        if self.SHOW_WIDGETS:
 
84
            self.sourceview.show()
201
85
 
202
86
    def set_trees(self, rev_tree, parent_tree):
203
87
        self.rev_tree = rev_tree
208
92
#        self.parent_tree.lock_read()
209
93
#        self.rev_tree.lock_read()
210
94
#        try:
211
 
#            self.delta = iter_changes_to_status(self.parent_tree, self.rev_tree)
 
95
#            self.delta = iter_changes_to_status(
 
96
#               self.parent_tree, self.rev_tree)
212
97
#            self.path_to_status = {}
213
98
#            self.path_to_diff = {}
214
99
#            source_inv = self.parent_tree.inventory
215
100
#            target_inv = self.rev_tree.inventory
216
101
#            for (file_id, real_path, change_type, display_path) in self.delta:
217
 
#                self.path_to_status[real_path] = u'=== %s %s' % (change_type, display_path)
 
102
#                self.path_to_status[real_path] = u'=== %s %s' % (
 
103
#                    change_type, display_path)
218
104
#                if change_type in ('modified', 'renamed and modified'):
219
105
#                    source_ie = source_inv[file_id]
220
106
#                    target_ie = target_inv[file_id]
222
108
#                    source_ie.diff(internal_diff, *old path, *old_tree,
223
109
#                                   *new_path, target_ie, self.rev_tree,
224
110
#                                   sio)
225
 
#                    self.path_to_diff[real_path] = 
 
111
#                    self.path_to_diff[real_path] =
226
112
#
227
113
#        finally:
228
114
#            self.rev_tree.unlock()
242
128
    """This is the soft and chewy filling for a DiffWindow."""
243
129
 
244
130
    def __init__(self):
245
 
        DiffFileView.__init__(self)
 
131
        super(DiffView, self).__init__()
246
132
        self.rev_tree = None
247
133
        self.parent_tree = None
248
134
 
272
158
        self.buffer.set_text(decoded.encode('UTF-8'))
273
159
 
274
160
 
275
 
class DiffWidget(gtk.HPaned):
 
161
class DiffWidget(Gtk.HPaned):
276
162
    """Diff widget
277
163
 
278
164
    """
 
165
 
 
166
    SHOW_WIDGETS = True
 
167
 
279
168
    def __init__(self):
280
169
        super(DiffWidget, self).__init__()
281
170
 
282
171
        # The file hierarchy: a scrollable treeview
283
 
        scrollwin = gtk.ScrolledWindow()
284
 
        scrollwin.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
285
 
        scrollwin.set_shadow_type(gtk.SHADOW_IN)
 
172
        scrollwin = Gtk.ScrolledWindow()
 
173
        scrollwin.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
 
174
        scrollwin.set_shadow_type(Gtk.ShadowType.IN)
286
175
        self.pack1(scrollwin)
287
 
        scrollwin.show()
288
 
        
289
 
        self.model = gtk.TreeStore(str, str)
290
 
        self.treeview = gtk.TreeView(self.model)
 
176
        if self.SHOW_WIDGETS:
 
177
            scrollwin.show()
 
178
 
 
179
        self.model = Gtk.TreeStore(str, str)
 
180
        self.treeview = Gtk.TreeView(model=self.model)
291
181
        self.treeview.set_headers_visible(False)
292
182
        self.treeview.set_search_column(1)
293
183
        self.treeview.connect("cursor-changed", self._treeview_cursor_cb)
294
184
        scrollwin.add(self.treeview)
295
 
        self.treeview.show()
 
185
        if self.SHOW_WIDGETS:
 
186
            self.treeview.show()
296
187
 
297
 
        cell = gtk.CellRendererText()
 
188
        cell = Gtk.CellRendererText()
298
189
        cell.set_property("width-chars", 20)
299
 
        column = gtk.TreeViewColumn()
300
 
        column.pack_start(cell, expand=True)
 
190
        column = Gtk.TreeViewColumn()
 
191
        column.pack_start(cell, True)
301
192
        column.add_attribute(cell, "text", 0)
302
193
        self.treeview.append_column(column)
303
194
 
313
204
        if getattr(self, 'diff_view', None) is None:
314
205
            self.diff_view = DiffFileView()
315
206
            self.pack2(self.diff_view)
316
 
        self.diff_view.show()
 
207
        if self.SHOW_WIDGETS:
 
208
            self.diff_view.show()
317
209
        for oldname, newname, patch in sections:
318
210
            self.diff_view._diffs[newname] = str(patch)
319
211
            if newname is None:
330
222
        if getattr(self, 'diff_view', None) is None:
331
223
            self.diff_view = DiffView()
332
224
            self.pack2(self.diff_view)
333
 
        self.diff_view.show()
 
225
        if self.SHOW_WIDGETS:
 
226
            self.diff_view.show()
334
227
        self.diff_view.set_trees(rev_tree, parent_tree)
335
228
        self.rev_tree = rev_tree
336
229
        self.parent_tree = parent_tree
338
231
        self.model.clear()
339
232
        delta = self.rev_tree.changes_from(self.parent_tree)
340
233
 
341
 
        self.model.append(None, [ "Complete Diff", "" ])
 
234
        self.model.append(None, ["Complete Diff", ""])
342
235
 
343
236
        if len(delta.added):
344
 
            titer = self.model.append(None, [ "Added", None ])
 
237
            titer = self.model.append(None, ["Added", None])
345
238
            for path, id, kind in delta.added:
346
 
                self.model.append(titer, [ path, path ])
 
239
                self.model.append(titer, [path, path])
347
240
 
348
241
        if len(delta.removed):
349
 
            titer = self.model.append(None, [ "Removed", None ])
 
242
            titer = self.model.append(None, ["Removed", None])
350
243
            for path, id, kind in delta.removed:
351
 
                self.model.append(titer, [ path, path ])
 
244
                self.model.append(titer, [path, path])
352
245
 
353
246
        if len(delta.renamed):
354
 
            titer = self.model.append(None, [ "Renamed", None ])
 
247
            titer = self.model.append(None, ["Renamed", None])
355
248
            for oldpath, newpath, id, kind, text_modified, meta_modified \
356
249
                    in delta.renamed:
357
 
                self.model.append(titer, [ oldpath, newpath ])
 
250
                self.model.append(titer, [oldpath, newpath])
358
251
 
359
252
        if len(delta.modified):
360
 
            titer = self.model.append(None, [ "Modified", None ])
 
253
            titer = self.model.append(None, ["Modified", None])
361
254
            for path, id, kind, text_modified, meta_modified in delta.modified:
362
 
                self.model.append(titer, [ path, path ])
 
255
                self.model.append(titer, [path, path])
363
256
 
364
257
        self.treeview.expand_all()
365
258
        self.diff_view.show_diff(None)
373
266
                    tv_path = child.path
374
267
                    break
375
268
        if tv_path is None:
376
 
            raise NoSuchFile(file_path)
377
 
        self.treeview.set_cursor(tv_path)
 
269
            raise errors.NoSuchFile(file_path)
 
270
        self.treeview.set_cursor(tv_path, None, False)
378
271
        self.treeview.scroll_to_cell(tv_path)
379
272
 
380
273
    def _treeview_cursor_cb(self, *args):
381
274
        """Callback for when the treeview cursor changes."""
382
275
        (path, col) = self.treeview.get_cursor()
383
 
        specific_files = [ self.model[path][1] ]
384
 
        if specific_files == [ None ]:
385
 
            return
386
 
        elif specific_files == [ "" ]:
 
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 == [""]:
387
282
            specific_files = None
388
 
        
 
283
 
389
284
        self.diff_view.show_diff(specific_files)
390
 
    
 
285
 
391
286
    def _on_wraplines_toggled(self, widget=None, wrap=False):
392
287
        """Callback for when the wrap lines checkbutton is toggled"""
393
288
        if wrap or widget.get_active():
394
 
            self.diff_view.sourceview.set_wrap_mode(gtk.WRAP_WORD)
 
289
            self.diff_view.sourceview.set_wrap_mode(Gtk.WrapMode.WORD)
395
290
        else:
396
 
            self.diff_view.sourceview.set_wrap_mode(gtk.WRAP_NONE)
 
291
            self.diff_view.sourceview.set_wrap_mode(Gtk.WrapMode.NONE)
 
292
 
397
293
 
398
294
class DiffWindow(Window):
399
295
    """Diff window.
402
298
    differences between two revisions on a branch.
403
299
    """
404
300
 
 
301
    SHOW_WIDGETS = True
 
302
 
405
303
    def __init__(self, parent=None, operations=None):
406
 
        Window.__init__(self, parent)
 
304
        super(DiffWindow, self).__init__(parent=parent)
407
305
        self.set_border_width(0)
408
 
        self.set_title("bzrk diff")
 
306
        self.set_title("bzr diff")
409
307
 
410
308
        # Use two thirds of the screen by default
411
309
        screen = self.get_screen()
417
315
 
418
316
    def construct(self, operations):
419
317
        """Construct the window contents."""
420
 
        self.vbox = gtk.VBox()
 
318
        self.vbox = Gtk.VBox()
421
319
        self.add(self.vbox)
422
 
        self.vbox.show()
 
320
        if self.SHOW_WIDGETS:
 
321
            self.vbox.show()
423
322
        self.diff = DiffWidget()
424
323
        self.vbox.pack_end(self.diff, True, True, 0)
425
 
        self.diff.show_all()
 
324
        if self.SHOW_WIDGETS:
 
325
            self.diff.show_all()
426
326
        # Build after DiffWidget to connect signals
427
327
        menubar = self._get_menu_bar()
428
328
        self.vbox.pack_start(menubar, False, False, 0)
429
329
        hbox = self._get_button_bar(operations)
430
330
        if hbox is not None:
431
331
            self.vbox.pack_start(hbox, False, True, 0)
432
 
        
433
 
    
 
332
 
434
333
    def _get_menu_bar(self):
435
 
        menubar = gtk.MenuBar()
 
334
        menubar = Gtk.MenuBar()
436
335
        # View menu
437
 
        mb_view = gtk.MenuItem(_i18n("_View"))
438
 
        mb_view_menu = gtk.Menu()
439
 
        mb_view_wrapsource = gtk.CheckMenuItem(_i18n("Wrap _Long Lines"))
 
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"))
440
340
        mb_view_wrapsource.connect('activate', self.diff._on_wraplines_toggled)
441
 
        mb_view_wrapsource.show()
442
341
        mb_view_menu.append(mb_view_wrapsource)
443
 
        mb_view.show()
444
342
        mb_view.set_submenu(mb_view_menu)
445
 
        mb_view.show()
446
343
        menubar.append(mb_view)
447
 
        menubar.show()
 
344
        if self.SHOW_WIDGETS:
 
345
            menubar.show_all()
448
346
        return menubar
449
 
    
 
347
 
450
348
    def _get_button_bar(self, operations):
451
349
        """Return a button bar to use.
452
350
 
454
352
        """
455
353
        if operations is None:
456
354
            return None
457
 
        hbox = gtk.HButtonBox()
458
 
        hbox.set_layout(gtk.BUTTONBOX_START)
 
355
        hbox = Gtk.HButtonBox()
 
356
        hbox.set_layout(Gtk.ButtonBoxStyle.START)
459
357
        for title, method in operations:
460
 
            merge_button = gtk.Button(title)
461
 
            merge_button.show()
462
 
            merge_button.set_relief(gtk.RELIEF_NONE)
 
358
            merge_button = Gtk.Button(title)
 
359
            if self.SHOW_WIDGETS:
 
360
                merge_button.show()
 
361
            merge_button.set_relief(Gtk.ReliefStyle.NONE)
463
362
            merge_button.connect("clicked", method)
464
 
            hbox.pack_start(merge_button, expand=False, fill=True)
465
 
        hbox.show()
 
363
            hbox.pack_start(merge_button, False, True, 0)
 
364
        if self.SHOW_WIDGETS:
 
365
            hbox.show()
466
366
        return hbox
467
367
 
468
368
    def _get_merge_target(self):
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,))
 
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,))
474
374
        try:
475
375
            result = d.run()
476
 
            if result != gtk.RESPONSE_OK:
 
376
            if result != Gtk.ResponseType.OK:
477
377
                raise SelectCancelled()
478
378
            return d.get_current_folder_uri()
479
379
        finally:
493
393
        error_dialog('Error', str(e))
494
394
 
495
395
    def _get_save_path(self, basename):
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,))
 
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,))
501
401
        d.set_current_name(basename)
502
402
        try:
503
403
            result = d.run()
504
 
            if result != gtk.RESPONSE_OK:
 
404
            if result != Gtk.ResponseType.OK:
505
405
                raise SelectCancelled()
506
406
            return urlutils.local_path_from_url(d.get_uri())
507
407
        finally:
522
422
 
523
423
class DiffController(object):
524
424
 
525
 
    def __init__(self, path, patch, window=None):
 
425
    def __init__(self, path, patch, window=None, allow_dirty=False):
526
426
        self.path = path
527
427
        self.patch = patch
 
428
        self.allow_dirty = allow_dirty
528
429
        if window is None:
529
430
            window = DiffWindow(operations=self._provide_operations())
530
431
            self.initialize_window(window)
536
437
 
537
438
    def get_diff_sections(self):
538
439
        yield "Complete Diff", None, ''.join(self.patch)
539
 
        for patch in parse_patches(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:
540
446
            oldname = patch.oldname.split('\t')[0]
541
447
            newname = patch.newname.split('\t')[0]
542
448
            yield oldname, newname, str(patch)
563
469
class MergeDirectiveController(DiffController):
564
470
 
565
471
    def __init__(self, path, directive, window=None):
566
 
        DiffController.__init__(self, path, directive.patch.splitlines(True),
567
 
                                window)
 
472
        super(MergeDirectiveController, self).__init__(
 
473
            path, directive.patch.splitlines(True), window)
568
474
        self.directive = directive
569
475
        self.merge_target = None
570
476
 
581
487
        tree.lock_write()
582
488
        try:
583
489
            try:
584
 
                merger, verified = _mod_merge.Merger.from_mergeable(tree,
585
 
                    self.directive, progress.DummyProgress())
586
 
                merger.check_basis(True)
 
490
                if tree.has_changes():
 
491
                    raise errors.UncommittedChanges(tree)
 
492
                merger, verified = _mod_merge.Merger.from_mergeable(
 
493
                    tree, self.directive, pb=None)
587
494
                merger.merge_type = _mod_merge.Merge3Merger
588
495
                conflict_count = merger.do_merge()
589
496
                merger.set_pending()