/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: Martin Pool
  • Date: 2010-05-27 03:07:30 UTC
  • mfrom: (688.1.5 201956-help)
  • Revision ID: mbp@canonical.com-20100527030730-os0opv1xroetccm9
https://launchpad.net/bugs/201965
Make find/goto more discoverable

Show diffs side-by-side

added added

removed removed

Lines of Context:
diff.py
1
 
#!/usr/bin/python
2
 
# -*- coding: UTF-8 -*-
3
1
"""Difference window.
4
2
 
5
3
This module contains the code to manage the diff window which shows
6
4
the changes made between two revisions on a branch.
7
5
"""
8
6
 
9
 
__copyright__ = "Copyright © 2005 Canonical Ltd."
 
7
__copyright__ = "Copyright 2005 Canonical Ltd."
10
8
__author__    = "Scott James Remnant <scott@ubuntu.com>"
11
9
 
12
10
 
13
11
from cStringIO import StringIO
14
12
 
 
13
import pygtk
 
14
pygtk.require("2.0")
15
15
import gtk
16
16
import pango
 
17
import os
 
18
import re
 
19
import sys
 
20
try:
 
21
    from xml.etree.ElementTree import Element, SubElement, tostring
 
22
except ImportError:
 
23
    from elementtree.ElementTree import Element, SubElement, tostring
17
24
 
18
25
try:
19
 
    import gtksourceview
 
26
    import gtksourceview2
20
27
    have_gtksourceview = True
21
28
except ImportError:
22
29
    have_gtksourceview = False
23
 
 
24
 
from bzrlib.delta import compare_trees
25
 
from bzrlib.diff import show_diff_trees
26
 
 
27
 
 
28
 
class DiffWindow(gtk.Window):
29
 
    """Diff window.
30
 
 
31
 
    This object represents and manages a single window containing the
32
 
    differences between two revisions on a branch.
33
 
    """
34
 
 
35
 
    def __init__(self, app=None):
36
 
        gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
37
 
        self.set_border_width(0)
38
 
        self.set_title("bzrk diff")
39
 
 
40
 
        self.app = app
41
 
 
42
 
        # Use two thirds of the screen by default
43
 
        screen = self.get_screen()
44
 
        monitor = screen.get_monitor_geometry(0)
45
 
        width = int(monitor.width * 0.66)
46
 
        height = int(monitor.height * 0.66)
47
 
        self.set_default_size(width, height)
48
 
 
 
30
try:
 
31
    import gconf
 
32
    have_gconf = True
 
33
except ImportError:
 
34
    have_gconf = False
 
35
 
 
36
from bzrlib import (
 
37
    errors,
 
38
    merge as _mod_merge,
 
39
    osutils,
 
40
    urlutils,
 
41
    workingtree,
 
42
)
 
43
from bzrlib.diff import show_diff_trees, internal_diff
 
44
from bzrlib.patches import parse_patches
 
45
from bzrlib.trace import warning
 
46
from bzrlib.plugins.gtk import _i18n
 
47
from bzrlib.plugins.gtk.window import Window
 
48
from dialog import error_dialog, info_dialog, warning_dialog
 
49
 
 
50
 
 
51
def fallback_guess_language(slm, content_type):
 
52
    for lang_id in slm.get_language_ids():
 
53
        lang = slm.get_language(lang_id)
 
54
        if "text/x-patch" in lang.get_mime_types():
 
55
            return lang
 
56
    return None
 
57
 
 
58
 
 
59
class SelectCancelled(Exception):
 
60
 
 
61
    pass
 
62
 
 
63
 
 
64
class DiffFileView(gtk.ScrolledWindow):
 
65
    """Window for displaying diffs from a diff file"""
 
66
 
 
67
    def __init__(self):
 
68
        gtk.ScrolledWindow.__init__(self)
49
69
        self.construct()
 
70
        self._diffs = {}
50
71
 
51
72
    def construct(self):
52
 
        """Construct the window contents."""
53
 
        hbox = gtk.HBox(spacing=6)
54
 
        hbox.set_border_width(12)
55
 
        self.add(hbox)
56
 
        hbox.show()
57
 
 
 
73
        self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
 
74
        self.set_shadow_type(gtk.SHADOW_IN)
 
75
 
 
76
        if have_gtksourceview:
 
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)
 
86
            self.buffer.set_highlight_syntax(True)
 
87
 
 
88
            self.sourceview = gtksourceview2.View(self.buffer)
 
89
        else:
 
90
            self.buffer = gtk.TextBuffer()
 
91
            self.sourceview = gtk.TextView(self.buffer)
 
92
 
 
93
        self.sourceview.set_editable(False)
 
94
        self.sourceview.modify_font(pango.FontDescription("Monospace"))
 
95
        self.add(self.sourceview)
 
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
 
203
 
 
204
    def set_trees(self, rev_tree, parent_tree):
 
205
        self.rev_tree = rev_tree
 
206
        self.parent_tree = parent_tree
 
207
#        self._build_delta()
 
208
 
 
209
#    def _build_delta(self):
 
210
#        self.parent_tree.lock_read()
 
211
#        self.rev_tree.lock_read()
 
212
#        try:
 
213
#            self.delta = iter_changes_to_status(self.parent_tree, self.rev_tree)
 
214
#            self.path_to_status = {}
 
215
#            self.path_to_diff = {}
 
216
#            source_inv = self.parent_tree.inventory
 
217
#            target_inv = self.rev_tree.inventory
 
218
#            for (file_id, real_path, change_type, display_path) in self.delta:
 
219
#                self.path_to_status[real_path] = u'=== %s %s' % (change_type, display_path)
 
220
#                if change_type in ('modified', 'renamed and modified'):
 
221
#                    source_ie = source_inv[file_id]
 
222
#                    target_ie = target_inv[file_id]
 
223
#                    sio = StringIO()
 
224
#                    source_ie.diff(internal_diff, *old path, *old_tree,
 
225
#                                   *new_path, target_ie, self.rev_tree,
 
226
#                                   sio)
 
227
#                    self.path_to_diff[real_path] = 
 
228
#
 
229
#        finally:
 
230
#            self.rev_tree.unlock()
 
231
#            self.parent_tree.unlock()
 
232
 
 
233
    def show_diff(self, specific_files):
 
234
        sections = []
 
235
        if specific_files is None:
 
236
            self.buffer.set_text(self._diffs[None])
 
237
        else:
 
238
            for specific_file in specific_files:
 
239
                sections.append(self._diffs[specific_file])
 
240
            self.buffer.set_text(''.join(sections))
 
241
 
 
242
 
 
243
class DiffView(DiffFileView):
 
244
    """This is the soft and chewy filling for a DiffWindow."""
 
245
 
 
246
    def __init__(self):
 
247
        DiffFileView.__init__(self)
 
248
        self.rev_tree = None
 
249
        self.parent_tree = None
 
250
 
 
251
    def show_diff(self, specific_files):
 
252
        """Show the diff for the specified files"""
 
253
        s = StringIO()
 
254
        show_diff_trees(self.parent_tree, self.rev_tree, s, specific_files,
 
255
                        old_label='', new_label='',
 
256
                        # path_encoding=sys.getdefaultencoding()
 
257
                        # The default is utf-8, but we interpret the file
 
258
                        # contents as getdefaultencoding(), so we should
 
259
                        # probably try to make the paths in the same encoding.
 
260
                        )
 
261
        # str.decode(encoding, 'replace') doesn't do anything. Because if a
 
262
        # character is not valid in 'encoding' there is nothing to replace, the
 
263
        # 'replace' is for 'str.encode()'
 
264
        try:
 
265
            decoded = s.getvalue().decode(sys.getdefaultencoding())
 
266
        except UnicodeDecodeError:
 
267
            try:
 
268
                decoded = s.getvalue().decode('UTF-8')
 
269
            except UnicodeDecodeError:
 
270
                decoded = s.getvalue().decode('iso-8859-1')
 
271
                # This always works, because every byte has a valid
 
272
                # mapping from iso-8859-1 to Unicode
 
273
        # TextBuffer must contain pure UTF-8 data
 
274
        self.buffer.set_text(decoded.encode('UTF-8'))
 
275
 
 
276
 
 
277
class DiffWidget(gtk.HPaned):
 
278
    """Diff widget
 
279
 
 
280
    """
 
281
    def __init__(self):
 
282
        super(DiffWidget, self).__init__()
 
283
 
 
284
        # The file hierarchy: a scrollable treeview
58
285
        scrollwin = gtk.ScrolledWindow()
59
286
        scrollwin.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
60
287
        scrollwin.set_shadow_type(gtk.SHADOW_IN)
61
 
        hbox.pack_start(scrollwin, expand=False, fill=True)
 
288
        self.pack1(scrollwin)
62
289
        scrollwin.show()
63
 
 
 
290
        
64
291
        self.model = gtk.TreeStore(str, str)
65
292
        self.treeview = gtk.TreeView(self.model)
66
293
        self.treeview.set_headers_visible(False)
76
303
        column.add_attribute(cell, "text", 0)
77
304
        self.treeview.append_column(column)
78
305
 
79
 
 
80
 
        scrollwin = gtk.ScrolledWindow()
81
 
        scrollwin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
82
 
        scrollwin.set_shadow_type(gtk.SHADOW_IN)
83
 
        hbox.pack_start(scrollwin, expand=True, fill=True)
84
 
        scrollwin.show()
85
 
 
86
 
        if have_gtksourceview:
87
 
            self.buffer = gtksourceview.SourceBuffer()
88
 
            slm = gtksourceview.SourceLanguagesManager()
89
 
            gsl = slm.get_language_from_mime_type("text/x-patch")
90
 
            self.buffer.set_language(gsl)
91
 
            self.buffer.set_highlight(True)
92
 
 
93
 
            sourceview = gtksourceview.SourceView(self.buffer)
94
 
        else:
95
 
            self.buffer = gtk.TextBuffer()
96
 
            sourceview = gtk.TextView(self.buffer)
97
 
 
98
 
        sourceview.set_editable(False)
99
 
        sourceview.modify_font(pango.FontDescription("Monospace"))
100
 
        scrollwin.add(sourceview)
101
 
        sourceview.show()
102
 
 
103
 
    def set_diff(self, branch, revid, parentid):
 
306
    def set_diff_text(self, lines):
 
307
        """Set the current diff from a list of lines
 
308
 
 
309
        :param lines: The diff to show, in unified diff format
 
310
        """
 
311
        # The diffs of the  selected file: a scrollable source or
 
312
        # text view
 
313
 
 
314
    def set_diff_text_sections(self, sections):
 
315
        if getattr(self, 'diff_view', None) is None:
 
316
            self.diff_view = DiffFileView()
 
317
            self.pack2(self.diff_view)
 
318
        self.diff_view.show()
 
319
        for oldname, newname, patch in sections:
 
320
            self.diff_view._diffs[newname] = str(patch)
 
321
            if newname is None:
 
322
                newname = ''
 
323
            self.model.append(None, [oldname, newname])
 
324
        self.diff_view.show_diff(None)
 
325
 
 
326
    def set_diff(self, rev_tree, parent_tree):
104
327
        """Set the differences showed by this window.
105
328
 
106
329
        Compares the two trees and populates the window with the
107
330
        differences.
108
331
        """
109
 
        self.rev_tree = branch.repository.revision_tree(revid)
110
 
        self.parent_tree = branch.repository.revision_tree(parentid)
 
332
        if getattr(self, 'diff_view', None) is None:
 
333
            self.diff_view = DiffView()
 
334
            self.pack2(self.diff_view)
 
335
        self.diff_view.show()
 
336
        self.diff_view.set_trees(rev_tree, parent_tree)
 
337
        self.rev_tree = rev_tree
 
338
        self.parent_tree = parent_tree
111
339
 
112
340
        self.model.clear()
113
 
        delta = compare_trees(self.parent_tree, self.rev_tree)
 
341
        delta = self.rev_tree.changes_from(self.parent_tree)
114
342
 
115
343
        self.model.append(None, [ "Complete Diff", "" ])
116
344
 
128
356
            titer = self.model.append(None, [ "Renamed", None ])
129
357
            for oldpath, newpath, id, kind, text_modified, meta_modified \
130
358
                    in delta.renamed:
131
 
                self.model.append(titer, [ oldpath, oldpath ])
 
359
                self.model.append(titer, [ oldpath, newpath ])
132
360
 
133
361
        if len(delta.modified):
134
362
            titer = self.model.append(None, [ "Modified", None ])
136
364
                self.model.append(titer, [ path, path ])
137
365
 
138
366
        self.treeview.expand_all()
139
 
        self.set_title(revid + " - " + branch.nick + " - bzrk diff")
 
367
        self.diff_view.show_diff(None)
 
368
 
 
369
    def set_file(self, file_path):
 
370
        """Select the current file to display"""
 
371
        tv_path = None
 
372
        for data in self.model:
 
373
            for child in data.iterchildren():
 
374
                if child[0] == file_path or child[1] == file_path:
 
375
                    tv_path = child.path
 
376
                    break
 
377
        if tv_path is None:
 
378
            raise errors.NoSuchFile(file_path)
 
379
        self.treeview.set_cursor(tv_path)
 
380
        self.treeview.scroll_to_cell(tv_path)
140
381
 
141
382
    def _treeview_cursor_cb(self, *args):
142
383
        """Callback for when the treeview cursor changes."""
145
386
        if specific_files == [ None ]:
146
387
            return
147
388
        elif specific_files == [ "" ]:
148
 
            specific_files = []
149
 
 
150
 
        s = StringIO()
151
 
        show_diff_trees(self.parent_tree, self.rev_tree, s, specific_files)
152
 
        self.buffer.set_text(s.getvalue())
 
389
            specific_files = None
 
390
        
 
391
        self.diff_view.show_diff(specific_files)
 
392
    
 
393
    def _on_wraplines_toggled(self, widget=None, wrap=False):
 
394
        """Callback for when the wrap lines checkbutton is toggled"""
 
395
        if wrap or widget.get_active():
 
396
            self.diff_view.sourceview.set_wrap_mode(gtk.WRAP_WORD)
 
397
        else:
 
398
            self.diff_view.sourceview.set_wrap_mode(gtk.WRAP_NONE)
 
399
 
 
400
class DiffWindow(Window):
 
401
    """Diff window.
 
402
 
 
403
    This object represents and manages a single window containing the
 
404
    differences between two revisions on a branch.
 
405
    """
 
406
 
 
407
    def __init__(self, parent=None, operations=None):
 
408
        Window.__init__(self, parent)
 
409
        self.set_border_width(0)
 
410
        self.set_title("bzrk diff")
 
411
 
 
412
        # Use two thirds of the screen by default
 
413
        screen = self.get_screen()
 
414
        monitor = screen.get_monitor_geometry(0)
 
415
        width = int(monitor.width * 0.66)
 
416
        height = int(monitor.height * 0.66)
 
417
        self.set_default_size(width, height)
 
418
        self.construct(operations)
 
419
 
 
420
    def construct(self, operations):
 
421
        """Construct the window contents."""
 
422
        self.vbox = gtk.VBox()
 
423
        self.add(self.vbox)
 
424
        self.vbox.show()
 
425
        self.diff = DiffWidget()
 
426
        self.vbox.pack_end(self.diff, True, True, 0)
 
427
        self.diff.show_all()
 
428
        # Build after DiffWidget to connect signals
 
429
        menubar = self._get_menu_bar()
 
430
        self.vbox.pack_start(menubar, False, False, 0)
 
431
        hbox = self._get_button_bar(operations)
 
432
        if hbox is not None:
 
433
            self.vbox.pack_start(hbox, False, True, 0)
 
434
        
 
435
    
 
436
    def _get_menu_bar(self):
 
437
        menubar = gtk.MenuBar()
 
438
        # View menu
 
439
        mb_view = gtk.MenuItem(_i18n("_View"))
 
440
        mb_view_menu = gtk.Menu()
 
441
        mb_view_wrapsource = gtk.CheckMenuItem(_i18n("Wrap _Long Lines"))
 
442
        mb_view_wrapsource.connect('activate', self.diff._on_wraplines_toggled)
 
443
        mb_view_wrapsource.show()
 
444
        mb_view_menu.append(mb_view_wrapsource)
 
445
        mb_view.show()
 
446
        mb_view.set_submenu(mb_view_menu)
 
447
        mb_view.show()
 
448
        menubar.append(mb_view)
 
449
        menubar.show()
 
450
        return menubar
 
451
    
 
452
    def _get_button_bar(self, operations):
 
453
        """Return a button bar to use.
 
454
 
 
455
        :return: None, meaning that no button bar will be used.
 
456
        """
 
457
        if operations is None:
 
458
            return None
 
459
        hbox = gtk.HButtonBox()
 
460
        hbox.set_layout(gtk.BUTTONBOX_START)
 
461
        for title, method in operations:
 
462
            merge_button = gtk.Button(title)
 
463
            merge_button.show()
 
464
            merge_button.set_relief(gtk.RELIEF_NONE)
 
465
            merge_button.connect("clicked", method)
 
466
            hbox.pack_start(merge_button, expand=False, fill=True)
 
467
        hbox.show()
 
468
        return hbox
 
469
 
 
470
    def _get_merge_target(self):
 
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,))
 
476
        try:
 
477
            result = d.run()
 
478
            if result != gtk.RESPONSE_OK:
 
479
                raise SelectCancelled()
 
480
            return d.get_current_folder_uri()
 
481
        finally:
 
482
            d.destroy()
 
483
 
 
484
    def _merge_successful(self):
 
485
        # No conflicts found.
 
486
        info_dialog(_i18n('Merge successful'),
 
487
                    _i18n('All changes applied successfully.'))
 
488
 
 
489
    def _conflicts(self):
 
490
        warning_dialog(_i18n('Conflicts encountered'),
 
491
                       _i18n('Please resolve the conflicts manually'
 
492
                             ' before committing.'))
 
493
 
 
494
    def _handle_error(self, e):
 
495
        error_dialog('Error', str(e))
 
496
 
 
497
    def _get_save_path(self, basename):
 
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,))
 
503
        d.set_current_name(basename)
 
504
        try:
 
505
            result = d.run()
 
506
            if result != gtk.RESPONSE_OK:
 
507
                raise SelectCancelled()
 
508
            return urlutils.local_path_from_url(d.get_uri())
 
509
        finally:
 
510
            d.destroy()
 
511
 
 
512
    def set_diff(self, description, rev_tree, parent_tree):
 
513
        """Set the differences showed by this window.
 
514
 
 
515
        Compares the two trees and populates the window with the
 
516
        differences.
 
517
        """
 
518
        self.diff.set_diff(rev_tree, parent_tree)
 
519
        self.set_title(description + " - bzrk diff")
 
520
 
 
521
    def set_file(self, file_path):
 
522
        self.diff.set_file(file_path)
 
523
 
 
524
 
 
525
class DiffController(object):
 
526
 
 
527
    def __init__(self, path, patch, window=None):
 
528
        self.path = path
 
529
        self.patch = patch
 
530
        if window is None:
 
531
            window = DiffWindow(operations=self._provide_operations())
 
532
            self.initialize_window(window)
 
533
        self.window = window
 
534
 
 
535
    def initialize_window(self, window):
 
536
        window.diff.set_diff_text_sections(self.get_diff_sections())
 
537
        window.set_title(self.path + " - diff")
 
538
 
 
539
    def get_diff_sections(self):
 
540
        yield "Complete Diff", None, ''.join(self.patch)
 
541
        for patch in parse_patches(self.patch):
 
542
            oldname = patch.oldname.split('\t')[0]
 
543
            newname = patch.newname.split('\t')[0]
 
544
            yield oldname, newname, str(patch)
 
545
 
 
546
    def perform_save(self, window):
 
547
        try:
 
548
            save_path = self.window._get_save_path(osutils.basename(self.path))
 
549
        except SelectCancelled:
 
550
            return
 
551
        source = open(self.path, 'rb')
 
552
        try:
 
553
            target = open(save_path, 'wb')
 
554
            try:
 
555
                osutils.pumpfile(source, target)
 
556
            finally:
 
557
                target.close()
 
558
        finally:
 
559
            source.close()
 
560
 
 
561
    def _provide_operations(self):
 
562
        return [('Save', self.perform_save)]
 
563
 
 
564
 
 
565
class MergeDirectiveController(DiffController):
 
566
 
 
567
    def __init__(self, path, directive, window=None):
 
568
        DiffController.__init__(self, path, directive.patch.splitlines(True),
 
569
                                window)
 
570
        self.directive = directive
 
571
        self.merge_target = None
 
572
 
 
573
    def _provide_operations(self):
 
574
        return [('Merge', self.perform_merge), ('Save', self.perform_save)]
 
575
 
 
576
    def perform_merge(self, window):
 
577
        if self.merge_target is None:
 
578
            try:
 
579
                self.merge_target = self.window._get_merge_target()
 
580
            except SelectCancelled:
 
581
                return
 
582
        tree = workingtree.WorkingTree.open(self.merge_target)
 
583
        tree.lock_write()
 
584
        try:
 
585
            try:
 
586
                if tree.has_changes():
 
587
                    raise errors.UncommittedChanges(tree)
 
588
                merger, verified = _mod_merge.Merger.from_mergeable(
 
589
                    tree, self.directive, pb=None)
 
590
                merger.merge_type = _mod_merge.Merge3Merger
 
591
                conflict_count = merger.do_merge()
 
592
                merger.set_pending()
 
593
                if conflict_count == 0:
 
594
                    self.window._merge_successful()
 
595
                else:
 
596
                    self.window._conflicts()
 
597
                    # There are conflicts to be resolved.
 
598
                self.window.destroy()
 
599
            except Exception, e:
 
600
                self.window._handle_error(e)
 
601
        finally:
 
602
            tree.unlock()
 
603
 
 
604
 
 
605
def iter_changes_to_status(source, target):
 
606
    """Determine the differences between trees.
 
607
 
 
608
    This is a wrapper around iter_changes which just yields more
 
609
    understandable results.
 
610
 
 
611
    :param source: The source tree (basis tree)
 
612
    :param target: The target tree
 
613
    :return: A list of (file_id, real_path, change_type, display_path)
 
614
    """
 
615
    added = 'added'
 
616
    removed = 'removed'
 
617
    renamed = 'renamed'
 
618
    renamed_and_modified = 'renamed and modified'
 
619
    modified = 'modified'
 
620
    kind_changed = 'kind changed'
 
621
    missing = 'missing'
 
622
 
 
623
    # TODO: Handle metadata changes
 
624
 
 
625
    status = []
 
626
    target.lock_read()
 
627
    try:
 
628
        source.lock_read()
 
629
        try:
 
630
            for (file_id, paths, changed_content, versioned, parent_ids, names,
 
631
                 kinds, executables) in target.iter_changes(source):
 
632
 
 
633
                # Skip the root entry if it isn't very interesting
 
634
                if parent_ids == (None, None):
 
635
                    continue
 
636
 
 
637
                change_type = None
 
638
                if kinds[0] is None:
 
639
                    source_marker = ''
 
640
                else:
 
641
                    source_marker = osutils.kind_marker(kinds[0])
 
642
 
 
643
                if kinds[1] is None:
 
644
                    if kinds[0] is None:
 
645
                        # We assume bzr will flag only files in that case,
 
646
                        # there may be a bzr bug there as only files seems to
 
647
                        # not receive any kind.
 
648
                        marker = osutils.kind_marker('file')
 
649
                    else:
 
650
                        marker = osutils.kind_marker(kinds[0])
 
651
                else:
 
652
                    marker = osutils.kind_marker(kinds[1])
 
653
 
 
654
                real_path = paths[1]
 
655
                if real_path is None:
 
656
                    real_path = paths[0]
 
657
                assert real_path is not None
 
658
 
 
659
                present_source = versioned[0] and kinds[0] is not None
 
660
                present_target = versioned[1] and kinds[1] is not None
 
661
 
 
662
                if kinds[0] is None and kinds[1] is None:
 
663
                    change_type = missing
 
664
                    display_path = real_path + marker
 
665
                elif present_source != present_target:
 
666
                    if present_target:
 
667
                        change_type = added
 
668
                    else:
 
669
                        assert present_source
 
670
                        change_type = removed
 
671
                    display_path = real_path + marker
 
672
                elif names[0] != names[1] or parent_ids[0] != parent_ids[1]:
 
673
                    # Renamed
 
674
                    if changed_content or executables[0] != executables[1]:
 
675
                        # and modified
 
676
                        change_type = renamed_and_modified
 
677
                    else:
 
678
                        change_type = renamed
 
679
                    display_path = (paths[0] + source_marker
 
680
                                    + ' => ' + paths[1] + marker)
 
681
                elif kinds[0] != kinds[1]:
 
682
                    change_type = kind_changed
 
683
                    display_path = (paths[0] + source_marker
 
684
                                    + ' => ' + paths[1] + marker)
 
685
                elif changed_content or executables[0] != executables[1]:
 
686
                    change_type = modified
 
687
                    display_path = real_path + marker
 
688
                else:
 
689
                    assert False, "How did we get here?"
 
690
 
 
691
                status.append((file_id, real_path, change_type, display_path))
 
692
        finally:
 
693
            source.unlock()
 
694
    finally:
 
695
        target.unlock()
 
696
 
 
697
    return status