/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
  • Author(s): Fabio Zanini
  • Date: 2011-04-04 17:52:28 UTC
  • Revision ID: jelmer@samba.org-20110404175228-wz8eczzurrowmxju
Fix import of open_display in bzr-handle-patch.

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