/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: Jasper Groenewegen
  • Date: 2008-07-27 12:01:40 UTC
  • mfrom: (576.3.2 improve-merge)
  • mto: This revision was merged to the branch mainline in revision 579.
  • Revision ID: colbrac@xs4all.nl-20080727120140-1agdlzkc9fumjk5f
Merge merge dialog improvements

Show diffs side-by-side

added added

removed removed

Lines of Context:
diff.py
1
 
#!/usr/bin/python
2
1
# -*- coding: UTF-8 -*-
3
2
"""Difference window.
4
3
 
12
11
 
13
12
from cStringIO import StringIO
14
13
 
 
14
import pygtk
 
15
pygtk.require("2.0")
15
16
import gtk
16
17
import pango
 
18
import os
 
19
import re
17
20
import sys
18
21
 
19
22
try:
21
24
    have_gtksourceview = True
22
25
except ImportError:
23
26
    have_gtksourceview = False
24
 
 
25
 
import bzrlib
26
 
 
27
 
from bzrlib.diff import show_diff_trees
 
27
try:
 
28
    import gconf
 
29
    have_gconf = True
 
30
except ImportError:
 
31
    have_gconf = False
 
32
 
 
33
from bzrlib import (
 
34
    merge as _mod_merge,
 
35
    osutils,
 
36
    progress,
 
37
    urlutils,
 
38
    workingtree,
 
39
)
 
40
from bzrlib.diff import show_diff_trees, internal_diff
28
41
from bzrlib.errors import NoSuchFile
29
 
 
30
 
 
31
 
class DiffWindow(gtk.Window):
32
 
    """Diff window.
33
 
 
34
 
    This object represents and manages a single window containing the
35
 
    differences between two revisions on a branch.
36
 
    """
 
42
from bzrlib.patches import parse_patches
 
43
from bzrlib.trace import warning
 
44
from bzrlib.plugins.gtk import _i18n
 
45
from bzrlib.plugins.gtk.window import Window
 
46
from dialog import error_dialog, info_dialog, warning_dialog
 
47
 
 
48
 
 
49
class SelectCancelled(Exception):
 
50
 
 
51
    pass
 
52
 
 
53
 
 
54
class DiffFileView(gtk.ScrolledWindow):
 
55
    """Window for displaying diffs from a diff file"""
37
56
 
38
57
    def __init__(self):
39
 
        gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
40
 
        self.set_border_width(0)
41
 
        self.set_title("bzrk diff")
42
 
 
43
 
        # Use two thirds of the screen by default
44
 
        screen = self.get_screen()
45
 
        monitor = screen.get_monitor_geometry(0)
46
 
        width = int(monitor.width * 0.66)
47
 
        height = int(monitor.height * 0.66)
48
 
        self.set_default_size(width, height)
49
 
 
 
58
        gtk.ScrolledWindow.__init__(self)
50
59
        self.construct()
 
60
        self._diffs = {}
51
61
 
52
62
    def construct(self):
53
 
        """Construct the window contents."""
54
 
        # The   window  consists  of   a  pane   containing:  the
55
 
        # hierarchical list  of files on  the left, and  the diff
56
 
        # for the currently selected file on the right.
57
 
        pane = gtk.HPaned()
58
 
        self.add(pane)
59
 
        pane.show()
 
63
        self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
 
64
        self.set_shadow_type(gtk.SHADOW_IN)
 
65
 
 
66
        if have_gtksourceview:
 
67
            self.buffer = gtksourceview.SourceBuffer()
 
68
            slm = gtksourceview.SourceLanguagesManager()
 
69
            gsl = slm.get_language_from_mime_type("text/x-patch")
 
70
            if have_gconf:
 
71
                self.apply_gedit_colors(gsl)
 
72
            self.apply_colordiff_colors(gsl)
 
73
            self.buffer.set_language(gsl)
 
74
            self.buffer.set_highlight(True)
 
75
 
 
76
            self.sourceview = gtksourceview.SourceView(self.buffer)
 
77
        else:
 
78
            self.buffer = gtk.TextBuffer()
 
79
            self.sourceview = gtk.TextView(self.buffer)
 
80
 
 
81
        self.sourceview.set_editable(False)
 
82
        self.sourceview.modify_font(pango.FontDescription("Monospace"))
 
83
        self.add(self.sourceview)
 
84
        self.sourceview.show()
 
85
 
 
86
    @staticmethod
 
87
    def apply_gedit_colors(lang):
 
88
        """Set style for lang to that specified in gedit configuration.
 
89
 
 
90
        This method needs the gconf module.
 
91
 
 
92
        :param lang: a gtksourceview.SourceLanguage object.
 
93
        """
 
94
        GEDIT_SYNTAX_PATH = '/apps/gedit-2/preferences/syntax_highlighting'
 
95
        GEDIT_LANG_PATH = GEDIT_SYNTAX_PATH + '/' + lang.get_id()
 
96
 
 
97
        client = gconf.client_get_default()
 
98
        client.add_dir(GEDIT_LANG_PATH, gconf.CLIENT_PRELOAD_NONE)
 
99
 
 
100
        for tag in lang.get_tags():
 
101
            tag_id = tag.get_id()
 
102
            gconf_key = GEDIT_LANG_PATH + '/' + tag_id
 
103
            style_string = client.get_string(gconf_key)
 
104
 
 
105
            if style_string is None:
 
106
                continue
 
107
 
 
108
            # function to get a bool from a string that's either '0' or '1'
 
109
            string_bool = lambda x: bool(int(x))
 
110
 
 
111
            # style_string is a string like "2/#FFCCAA/#000000/0/1/0/0"
 
112
            # values are: mask, fg, bg, italic, bold, underline, strike
 
113
            # this packs them into (str_value, attr_name, conv_func) tuples
 
114
            items = zip(style_string.split('/'), ['mask', 'foreground',
 
115
                'background', 'italic', 'bold', 'underline', 'strikethrough' ],
 
116
                [ int, gtk.gdk.color_parse, gtk.gdk.color_parse, string_bool,
 
117
                    string_bool, string_bool, string_bool ]
 
118
            )
 
119
 
 
120
            style = gtksourceview.SourceTagStyle()
 
121
 
 
122
            # XXX The mask attribute controls whether the present values of
 
123
            # foreground and background color should in fact be used. Ideally
 
124
            # (and that's what gedit does), one could set all three attributes,
 
125
            # and let the TagStyle object figure out which colors to use.
 
126
            # However, in the GtkSourceview python bindings, the mask attribute
 
127
            # is read-only, and it's derived instead from the colors being
 
128
            # set or not. This means that we have to sometimes refrain from
 
129
            # setting fg or bg colors, depending on the value of the mask.
 
130
            # This code could go away if mask were writable.
 
131
            mask = int(items[0][0])
 
132
            if not (mask & 1): # GTK_SOURCE_TAG_STYLE_USE_BACKGROUND
 
133
                items[2:3] = []
 
134
            if not (mask & 2): # GTK_SOURCE_TAG_STYLE_USE_FOREGROUND
 
135
                items[1:2] = []
 
136
            items[0:1] = [] # skip the mask unconditionally
 
137
 
 
138
            for value, attr, func in items:
 
139
                try:
 
140
                    value = func(value)
 
141
                except ValueError:
 
142
                    warning('gconf key %s contains an invalid value: %s'
 
143
                            % gconf_key, value)
 
144
                else:
 
145
                    setattr(style, attr, value)
 
146
 
 
147
            lang.set_tag_style(tag_id, style)
 
148
 
 
149
    @classmethod
 
150
    def apply_colordiff_colors(klass, lang):
 
151
        """Set style colors for lang using the colordiff configuration file.
 
152
 
 
153
        Both ~/.colordiffrc and ~/.colordiffrc.bzr-gtk are read.
 
154
 
 
155
        :param lang: a "Diff" gtksourceview.SourceLanguage object.
 
156
        """
 
157
        colors = {}
 
158
 
 
159
        for f in ('~/.colordiffrc', '~/.colordiffrc.bzr-gtk'):
 
160
            f = os.path.expanduser(f)
 
161
            if os.path.exists(f):
 
162
                try:
 
163
                    f = file(f)
 
164
                except IOError, e:
 
165
                    warning('could not open file %s: %s' % (f, str(e)))
 
166
                else:
 
167
                    colors.update(klass.parse_colordiffrc(f))
 
168
                    f.close()
 
169
 
 
170
        if not colors:
 
171
            # ~/.colordiffrc does not exist
 
172
            return
 
173
 
 
174
        mapping = {
 
175
                # map GtkSourceView tags to colordiff names
 
176
                # since GSV is richer, accept new names for extra bits,
 
177
                # defaulting to old names if they're not present
 
178
                'Added@32@line': ['newtext'],
 
179
                'Removed@32@line': ['oldtext'],
 
180
                'Location': ['location', 'diffstuff'],
 
181
                'Diff@32@file': ['file', 'diffstuff'],
 
182
                'Special@32@case': ['specialcase', 'diffstuff'],
 
183
        }
 
184
 
 
185
        for tag in lang.get_tags():
 
186
            tag_id = tag.get_id()
 
187
            keys = mapping.get(tag_id, [])
 
188
            color = None
 
189
 
 
190
            for key in keys:
 
191
                color = colors.get(key, None)
 
192
                if color is not None:
 
193
                    break
 
194
 
 
195
            if color is None:
 
196
                continue
 
197
 
 
198
            style = gtksourceview.SourceTagStyle()
 
199
            try:
 
200
                style.foreground = gtk.gdk.color_parse(color)
 
201
            except ValueError:
 
202
                warning('not a valid color: %s' % color)
 
203
            else:
 
204
                lang.set_tag_style(tag_id, style)
 
205
 
 
206
    @staticmethod
 
207
    def parse_colordiffrc(fileobj):
 
208
        """Parse fileobj as a colordiff configuration file.
 
209
 
 
210
        :return: A dict with the key -> value pairs.
 
211
        """
 
212
        colors = {}
 
213
        for line in fileobj:
 
214
            if re.match(r'^\s*#', line):
 
215
                continue
 
216
            if '=' not in line:
 
217
                continue
 
218
            key, val = line.split('=', 1)
 
219
            colors[key.strip()] = val.strip()
 
220
        return colors
 
221
 
 
222
    def set_trees(self, rev_tree, parent_tree):
 
223
        self.rev_tree = rev_tree
 
224
        self.parent_tree = parent_tree
 
225
#        self._build_delta()
 
226
 
 
227
#    def _build_delta(self):
 
228
#        self.parent_tree.lock_read()
 
229
#        self.rev_tree.lock_read()
 
230
#        try:
 
231
#            self.delta = iter_changes_to_status(self.parent_tree, self.rev_tree)
 
232
#            self.path_to_status = {}
 
233
#            self.path_to_diff = {}
 
234
#            source_inv = self.parent_tree.inventory
 
235
#            target_inv = self.rev_tree.inventory
 
236
#            for (file_id, real_path, change_type, display_path) in self.delta:
 
237
#                self.path_to_status[real_path] = u'=== %s %s' % (change_type, display_path)
 
238
#                if change_type in ('modified', 'renamed and modified'):
 
239
#                    source_ie = source_inv[file_id]
 
240
#                    target_ie = target_inv[file_id]
 
241
#                    sio = StringIO()
 
242
#                    source_ie.diff(internal_diff, *old path, *old_tree,
 
243
#                                   *new_path, target_ie, self.rev_tree,
 
244
#                                   sio)
 
245
#                    self.path_to_diff[real_path] = 
 
246
#
 
247
#        finally:
 
248
#            self.rev_tree.unlock()
 
249
#            self.parent_tree.unlock()
 
250
 
 
251
    def show_diff(self, specific_files):
 
252
        sections = []
 
253
        if specific_files is None:
 
254
            self.buffer.set_text(self._diffs[None])
 
255
        else:
 
256
            for specific_file in specific_files:
 
257
                sections.append(self._diffs[specific_file])
 
258
            self.buffer.set_text(''.join(sections))
 
259
 
 
260
 
 
261
class DiffView(DiffFileView):
 
262
    """This is the soft and chewy filling for a DiffWindow."""
 
263
 
 
264
    def __init__(self):
 
265
        DiffFileView.__init__(self)
 
266
        self.rev_tree = None
 
267
        self.parent_tree = None
 
268
 
 
269
    def show_diff(self, specific_files):
 
270
        """Show the diff for the specified files"""
 
271
        s = StringIO()
 
272
        show_diff_trees(self.parent_tree, self.rev_tree, s, specific_files,
 
273
                        old_label='', new_label='',
 
274
                        # path_encoding=sys.getdefaultencoding()
 
275
                        # The default is utf-8, but we interpret the file
 
276
                        # contents as getdefaultencoding(), so we should
 
277
                        # probably try to make the paths in the same encoding.
 
278
                        )
 
279
        # str.decode(encoding, 'replace') doesn't do anything. Because if a
 
280
        # character is not valid in 'encoding' there is nothing to replace, the
 
281
        # 'replace' is for 'str.encode()'
 
282
        try:
 
283
            decoded = s.getvalue().decode(sys.getdefaultencoding())
 
284
        except UnicodeDecodeError:
 
285
            try:
 
286
                decoded = s.getvalue().decode('UTF-8')
 
287
            except UnicodeDecodeError:
 
288
                decoded = s.getvalue().decode('iso-8859-1')
 
289
                # This always works, because every byte has a valid
 
290
                # mapping from iso-8859-1 to Unicode
 
291
        # TextBuffer must contain pure UTF-8 data
 
292
        self.buffer.set_text(decoded.encode('UTF-8'))
 
293
 
 
294
 
 
295
class DiffWidget(gtk.HPaned):
 
296
    """Diff widget
 
297
 
 
298
    """
 
299
    def __init__(self):
 
300
        super(DiffWidget, self).__init__()
60
301
 
61
302
        # The file hierarchy: a scrollable treeview
62
303
        scrollwin = gtk.ScrolledWindow()
63
304
        scrollwin.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
64
305
        scrollwin.set_shadow_type(gtk.SHADOW_IN)
65
 
        pane.pack1(scrollwin)
 
306
        self.pack1(scrollwin)
66
307
        scrollwin.show()
67
 
 
 
308
        
68
309
        self.model = gtk.TreeStore(str, str)
69
310
        self.treeview = gtk.TreeView(self.model)
70
311
        self.treeview.set_headers_visible(False)
80
321
        column.add_attribute(cell, "text", 0)
81
322
        self.treeview.append_column(column)
82
323
 
 
324
    def set_diff_text(self, lines):
 
325
        """Set the current diff from a list of lines
 
326
 
 
327
        :param lines: The diff to show, in unified diff format
 
328
        """
83
329
        # The diffs of the  selected file: a scrollable source or
84
330
        # text view
85
 
        scrollwin = gtk.ScrolledWindow()
86
 
        scrollwin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
87
 
        scrollwin.set_shadow_type(gtk.SHADOW_IN)
88
 
        pane.pack2(scrollwin)
89
 
        scrollwin.show()
90
 
 
91
 
        if have_gtksourceview:
92
 
            self.buffer = gtksourceview.SourceBuffer()
93
 
            slm = gtksourceview.SourceLanguagesManager()
94
 
            gsl = slm.get_language_from_mime_type("text/x-patch")
95
 
            self.buffer.set_language(gsl)
96
 
            self.buffer.set_highlight(True)
97
 
 
98
 
            sourceview = gtksourceview.SourceView(self.buffer)
99
 
        else:
100
 
            self.buffer = gtk.TextBuffer()
101
 
            sourceview = gtk.TextView(self.buffer)
102
 
 
103
 
        sourceview.set_editable(False)
104
 
        sourceview.modify_font(pango.FontDescription("Monospace"))
105
 
        scrollwin.add(sourceview)
106
 
        sourceview.show()
107
 
 
108
 
    def set_diff(self, description, rev_tree, parent_tree):
 
331
 
 
332
    def set_diff_text_sections(self, sections):
 
333
        if getattr(self, 'diff_view', None) is None:
 
334
            self.diff_view = DiffFileView()
 
335
            self.pack2(self.diff_view)
 
336
        self.diff_view.show()
 
337
        for oldname, newname, patch in sections:
 
338
            self.diff_view._diffs[newname] = str(patch)
 
339
            if newname is None:
 
340
                newname = ''
 
341
            self.model.append(None, [oldname, newname])
 
342
        self.diff_view.show_diff(None)
 
343
 
 
344
    def set_diff(self, rev_tree, parent_tree):
109
345
        """Set the differences showed by this window.
110
346
 
111
347
        Compares the two trees and populates the window with the
112
348
        differences.
113
349
        """
 
350
        if getattr(self, 'diff_view', None) is None:
 
351
            self.diff_view = DiffView()
 
352
            self.pack2(self.diff_view)
 
353
        self.diff_view.show()
 
354
        self.diff_view.set_trees(rev_tree, parent_tree)
114
355
        self.rev_tree = rev_tree
115
356
        self.parent_tree = parent_tree
116
357
 
141
382
                self.model.append(titer, [ path, path ])
142
383
 
143
384
        self.treeview.expand_all()
144
 
        self.set_title(description + " - bzrk diff")
 
385
        self.diff_view.show_diff(None)
145
386
 
146
387
    def set_file(self, file_path):
 
388
        """Select the current file to display"""
147
389
        tv_path = None
148
390
        for data in self.model:
149
391
            for child in data.iterchildren():
162
404
        if specific_files == [ None ]:
163
405
            return
164
406
        elif specific_files == [ "" ]:
165
 
            specific_files = []
166
 
 
167
 
        s = StringIO()
168
 
        show_diff_trees(self.parent_tree, self.rev_tree, s, specific_files)
169
 
        self.buffer.set_text(s.getvalue().decode(sys.getdefaultencoding(), 'replace'))
 
407
            specific_files = None
 
408
        
 
409
        self.diff_view.show_diff(specific_files)
 
410
    
 
411
    def _on_wraplines_toggled(self, widget=None, wrap=False):
 
412
        """Callback for when the wrap lines checkbutton is toggled"""
 
413
        if wrap or widget.get_active():
 
414
            self.diff_view.sourceview.set_wrap_mode(gtk.WRAP_WORD)
 
415
        else:
 
416
            self.diff_view.sourceview.set_wrap_mode(gtk.WRAP_NONE)
 
417
 
 
418
class DiffWindow(Window):
 
419
    """Diff window.
 
420
 
 
421
    This object represents and manages a single window containing the
 
422
    differences between two revisions on a branch.
 
423
    """
 
424
 
 
425
    def __init__(self, parent=None, operations=None):
 
426
        Window.__init__(self, parent)
 
427
        self.set_border_width(0)
 
428
        self.set_title("bzrk diff")
 
429
 
 
430
        # Use two thirds of the screen by default
 
431
        screen = self.get_screen()
 
432
        monitor = screen.get_monitor_geometry(0)
 
433
        width = int(monitor.width * 0.66)
 
434
        height = int(monitor.height * 0.66)
 
435
        self.set_default_size(width, height)
 
436
        self.construct(operations)
 
437
 
 
438
    def construct(self, operations):
 
439
        """Construct the window contents."""
 
440
        self.vbox = gtk.VBox()
 
441
        self.add(self.vbox)
 
442
        self.vbox.show()
 
443
        self.diff = DiffWidget()
 
444
        self.vbox.pack_end(self.diff, True, True, 0)
 
445
        self.diff.show_all()
 
446
        # Build after DiffWidget to connect signals
 
447
        menubar = self._get_menu_bar()
 
448
        self.vbox.pack_start(menubar, False, False, 0)
 
449
        hbox = self._get_button_bar(operations)
 
450
        if hbox is not None:
 
451
            self.vbox.pack_start(hbox, False, True, 0)
 
452
        
 
453
    
 
454
    def _get_menu_bar(self):
 
455
        menubar = gtk.MenuBar()
 
456
        # View menu
 
457
        mb_view = gtk.MenuItem(_i18n("_View"))
 
458
        mb_view_menu = gtk.Menu()
 
459
        mb_view_wrapsource = gtk.CheckMenuItem(_i18n("Wrap _Long Lines"))
 
460
        mb_view_wrapsource.connect('activate', self.diff._on_wraplines_toggled)
 
461
        mb_view_wrapsource.show()
 
462
        mb_view_menu.append(mb_view_wrapsource)
 
463
        mb_view.show()
 
464
        mb_view.set_submenu(mb_view_menu)
 
465
        mb_view.show()
 
466
        menubar.append(mb_view)
 
467
        menubar.show()
 
468
        return menubar
 
469
    
 
470
    def _get_button_bar(self, operations):
 
471
        """Return a button bar to use.
 
472
 
 
473
        :return: None, meaning that no button bar will be used.
 
474
        """
 
475
        if operations is None:
 
476
            return None
 
477
        hbox = gtk.HButtonBox()
 
478
        hbox.set_layout(gtk.BUTTONBOX_START)
 
479
        for title, method in operations:
 
480
            merge_button = gtk.Button(title)
 
481
            merge_button.show()
 
482
            merge_button.set_relief(gtk.RELIEF_NONE)
 
483
            merge_button.connect("clicked", method)
 
484
            hbox.pack_start(merge_button, expand=False, fill=True)
 
485
        hbox.show()
 
486
        return hbox
 
487
 
 
488
    def _get_merge_target(self):
 
489
        d = gtk.FileChooserDialog('Merge branch', self,
 
490
                                  gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER,
 
491
                                  buttons=(gtk.STOCK_OK, gtk.RESPONSE_OK,
 
492
                                           gtk.STOCK_CANCEL,
 
493
                                           gtk.RESPONSE_CANCEL,))
 
494
        try:
 
495
            result = d.run()
 
496
            if result != gtk.RESPONSE_OK:
 
497
                raise SelectCancelled()
 
498
            return d.get_current_folder_uri()
 
499
        finally:
 
500
            d.destroy()
 
501
 
 
502
    def _merge_successful(self):
 
503
        # No conflicts found.
 
504
        info_dialog(_i18n('Merge successful'),
 
505
                    _i18n('All changes applied successfully.'))
 
506
 
 
507
    def _conflicts(self):
 
508
        warning_dialog(_i18n('Conflicts encountered'),
 
509
                       _i18n('Please resolve the conflicts manually'
 
510
                             ' before committing.'))
 
511
 
 
512
    def _handle_error(self, e):
 
513
        error_dialog('Error', str(e))
 
514
 
 
515
    def _get_save_path(self, basename):
 
516
        d = gtk.FileChooserDialog('Save As', self,
 
517
                                  gtk.FILE_CHOOSER_ACTION_SAVE,
 
518
                                  buttons=(gtk.STOCK_OK, gtk.RESPONSE_OK,
 
519
                                           gtk.STOCK_CANCEL,
 
520
                                           gtk.RESPONSE_CANCEL,))
 
521
        d.set_current_name(basename)
 
522
        try:
 
523
            result = d.run()
 
524
            if result != gtk.RESPONSE_OK:
 
525
                raise SelectCancelled()
 
526
            return urlutils.local_path_from_url(d.get_uri())
 
527
        finally:
 
528
            d.destroy()
 
529
 
 
530
    def set_diff(self, description, rev_tree, parent_tree):
 
531
        """Set the differences showed by this window.
 
532
 
 
533
        Compares the two trees and populates the window with the
 
534
        differences.
 
535
        """
 
536
        self.diff.set_diff(rev_tree, parent_tree)
 
537
        self.set_title(description + " - bzrk diff")
 
538
 
 
539
    def set_file(self, file_path):
 
540
        self.diff.set_file(file_path)
 
541
 
 
542
 
 
543
class DiffController(object):
 
544
 
 
545
    def __init__(self, path, patch, window=None):
 
546
        self.path = path
 
547
        self.patch = patch
 
548
        if window is None:
 
549
            window = DiffWindow(operations=self._provide_operations())
 
550
            self.initialize_window(window)
 
551
        self.window = window
 
552
 
 
553
    def initialize_window(self, window):
 
554
        window.diff.set_diff_text_sections(self.get_diff_sections())
 
555
        window.set_title(self.path + " - diff")
 
556
 
 
557
    def get_diff_sections(self):
 
558
        yield "Complete Diff", None, ''.join(self.patch)
 
559
        for patch in parse_patches(self.patch):
 
560
            oldname = patch.oldname.split('\t')[0]
 
561
            newname = patch.newname.split('\t')[0]
 
562
            yield oldname, newname, str(patch)
 
563
 
 
564
    def perform_save(self, window):
 
565
        try:
 
566
            save_path = self.window._get_save_path(osutils.basename(self.path))
 
567
        except SelectCancelled:
 
568
            return
 
569
        source = open(self.path, 'rb')
 
570
        try:
 
571
            target = open(save_path, 'wb')
 
572
            try:
 
573
                osutils.pumpfile(source, target)
 
574
            finally:
 
575
                target.close()
 
576
        finally:
 
577
            source.close()
 
578
 
 
579
    def _provide_operations(self):
 
580
        return [('Save', self.perform_save)]
 
581
 
 
582
 
 
583
class MergeDirectiveController(DiffController):
 
584
 
 
585
    def __init__(self, path, directive, window=None):
 
586
        DiffController.__init__(self, path, directive.patch.splitlines(True),
 
587
                                window)
 
588
        self.directive = directive
 
589
        self.merge_target = None
 
590
 
 
591
    def _provide_operations(self):
 
592
        return [('Merge', self.perform_merge), ('Save', self.perform_save)]
 
593
 
 
594
    def perform_merge(self, window):
 
595
        if self.merge_target is None:
 
596
            try:
 
597
                self.merge_target = self.window._get_merge_target()
 
598
            except SelectCancelled:
 
599
                return
 
600
        tree = workingtree.WorkingTree.open(self.merge_target)
 
601
        tree.lock_write()
 
602
        try:
 
603
            try:
 
604
                merger, verified = _mod_merge.Merger.from_mergeable(tree,
 
605
                    self.directive, progress.DummyProgress())
 
606
                merger.check_basis(True)
 
607
                merger.merge_type = _mod_merge.Merge3Merger
 
608
                conflict_count = merger.do_merge()
 
609
                merger.set_pending()
 
610
                if conflict_count == 0:
 
611
                    self.window._merge_successful()
 
612
                else:
 
613
                    self.window._conflicts()
 
614
                    # There are conflicts to be resolved.
 
615
                self.window.destroy()
 
616
            except Exception, e:
 
617
                self.window._handle_error(e)
 
618
        finally:
 
619
            tree.unlock()
 
620
 
 
621
 
 
622
def iter_changes_to_status(source, target):
 
623
    """Determine the differences between trees.
 
624
 
 
625
    This is a wrapper around iter_changes which just yields more
 
626
    understandable results.
 
627
 
 
628
    :param source: The source tree (basis tree)
 
629
    :param target: The target tree
 
630
    :return: A list of (file_id, real_path, change_type, display_path)
 
631
    """
 
632
    added = 'added'
 
633
    removed = 'removed'
 
634
    renamed = 'renamed'
 
635
    renamed_and_modified = 'renamed and modified'
 
636
    modified = 'modified'
 
637
    kind_changed = 'kind changed'
 
638
 
 
639
    # TODO: Handle metadata changes
 
640
 
 
641
    status = []
 
642
    target.lock_read()
 
643
    try:
 
644
        source.lock_read()
 
645
        try:
 
646
            for (file_id, paths, changed_content, versioned, parent_ids, names,
 
647
                 kinds, executables) in target.iter_changes(source):
 
648
 
 
649
                # Skip the root entry if it isn't very interesting
 
650
                if parent_ids == (None, None):
 
651
                    continue
 
652
 
 
653
                change_type = None
 
654
                if kinds[0] is None:
 
655
                    source_marker = ''
 
656
                else:
 
657
                    source_marker = osutils.kind_marker(kinds[0])
 
658
                if kinds[1] is None:
 
659
                    assert kinds[0] is not None
 
660
                    marker = osutils.kind_marker(kinds[0])
 
661
                else:
 
662
                    marker = osutils.kind_marker(kinds[1])
 
663
 
 
664
                real_path = paths[1]
 
665
                if real_path is None:
 
666
                    real_path = paths[0]
 
667
                assert real_path is not None
 
668
                display_path = real_path + marker
 
669
 
 
670
                present_source = versioned[0] and kinds[0] is not None
 
671
                present_target = versioned[1] and kinds[1] is not None
 
672
 
 
673
                if present_source != present_target:
 
674
                    if present_target:
 
675
                        change_type = added
 
676
                    else:
 
677
                        assert present_source
 
678
                        change_type = removed
 
679
                elif names[0] != names[1] or parent_ids[0] != parent_ids[1]:
 
680
                    # Renamed
 
681
                    if changed_content or executables[0] != executables[1]:
 
682
                        # and modified
 
683
                        change_type = renamed_and_modified
 
684
                    else:
 
685
                        change_type = renamed
 
686
                    display_path = (paths[0] + source_marker
 
687
                                    + ' => ' + paths[1] + marker)
 
688
                elif kinds[0] != kinds[1]:
 
689
                    change_type = kind_changed
 
690
                    display_path = (paths[0] + source_marker
 
691
                                    + ' => ' + paths[1] + marker)
 
692
                elif changed_content is True or executables[0] != executables[1]:
 
693
                    change_type = modified
 
694
                else:
 
695
                    assert False, "How did we get here?"
 
696
 
 
697
                status.append((file_id, real_path, change_type, display_path))
 
698
        finally:
 
699
            source.unlock()
 
700
    finally:
 
701
        target.unlock()
 
702
 
 
703
    return status