/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: Vincent Ladeuil
  • Date: 2008-06-10 15:25:47 UTC
  • mto: This revision was merged to the branch mainline in revision 504.
  • Revision ID: v.ladeuil+lp@free.fr-20080610152547-dwmil1p8pd0mfpnl
Fix third failing test (thanks to jam).

* tests/test_commit.py:
(TestPendingRevisions.test_pending_revisions_multi_merge): Fix
provided by jam: bzr we now filter the pending merges so that only
the 'heads()' are included. We just ensure that the pending merges
contain the unique tips for the ancestries.

Show diffs side-by-side

added added

removed removed

Lines of Context:
diff.py
 
1
# -*- coding: UTF-8 -*-
1
2
"""Difference window.
2
3
 
3
4
This module contains the code to manage the diff window which shows
4
5
the changes made between two revisions on a branch.
5
6
"""
6
7
 
7
 
__copyright__ = "Copyright 2005 Canonical Ltd."
 
8
__copyright__ = "Copyright © 2005 Canonical Ltd."
8
9
__author__    = "Scott James Remnant <scott@ubuntu.com>"
9
10
 
10
11
 
17
18
import os
18
19
import re
19
20
import sys
20
 
try:
21
 
    from xml.etree.ElementTree import Element, SubElement, tostring
22
 
except ImportError:
23
 
    from elementtree.ElementTree import Element, SubElement, tostring
24
21
 
25
22
try:
26
 
    import gtksourceview2
 
23
    import gtksourceview
27
24
    have_gtksourceview = True
28
25
except ImportError:
29
26
    have_gtksourceview = False
34
31
    have_gconf = False
35
32
 
36
33
from bzrlib import (
37
 
    errors,
38
34
    merge as _mod_merge,
39
35
    osutils,
 
36
    progress,
40
37
    urlutils,
41
38
    workingtree,
42
39
)
43
40
from bzrlib.diff import show_diff_trees, internal_diff
 
41
from bzrlib.errors import NoSuchFile
44
42
from bzrlib.patches import parse_patches
45
43
from bzrlib.trace import warning
46
44
from bzrlib.plugins.gtk import _i18n
48
46
from dialog import error_dialog, info_dialog, warning_dialog
49
47
 
50
48
 
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
49
class SelectCancelled(Exception):
60
50
 
61
51
    pass
74
64
        self.set_shadow_type(gtk.SHADOW_IN)
75
65
 
76
66
        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")
 
67
            self.buffer = gtksourceview.SourceBuffer()
 
68
            slm = gtksourceview.SourceLanguagesManager()
 
69
            gsl = slm.get_language_from_mime_type("text/x-patch")
82
70
            if have_gconf:
83
 
                self.apply_gedit_colors(self.buffer)
84
 
            self.apply_colordiff_colors(self.buffer)
 
71
                self.apply_gedit_colors(gsl)
 
72
            self.apply_colordiff_colors(gsl)
85
73
            self.buffer.set_language(gsl)
86
 
            self.buffer.set_highlight_syntax(True)
 
74
            self.buffer.set_highlight(True)
87
75
 
88
 
            self.sourceview = gtksourceview2.View(self.buffer)
 
76
            sourceview = gtksourceview.SourceView(self.buffer)
89
77
        else:
90
78
            self.buffer = gtk.TextBuffer()
91
 
            self.sourceview = gtk.TextView(self.buffer)
 
79
            sourceview = gtk.TextView(self.buffer)
92
80
 
93
 
        self.sourceview.set_editable(False)
94
 
        self.sourceview.modify_font(pango.FontDescription("Monospace"))
95
 
        self.add(self.sourceview)
96
 
        self.sourceview.show()
 
81
        sourceview.set_editable(False)
 
82
        sourceview.modify_font(pango.FontDescription("Monospace"))
 
83
        self.add(sourceview)
 
84
        sourceview.show()
97
85
 
98
86
    @staticmethod
99
 
    def apply_gedit_colors(buf):
100
 
        """Set style to that specified in gedit configuration.
 
87
    def apply_gedit_colors(lang):
 
88
        """Set style for lang to that specified in gedit configuration.
101
89
 
102
90
        This method needs the gconf module.
103
91
 
104
 
        :param buf: a gtksourceview2.Buffer object.
 
92
        :param lang: a gtksourceview.SourceLanguage object.
105
93
        """
106
 
        GEDIT_SCHEME_PATH = '/apps/gedit-2/preferences/editor/colors/scheme'
 
94
        GEDIT_SYNTAX_PATH = '/apps/gedit-2/preferences/syntax_highlighting'
 
95
        GEDIT_LANG_PATH = GEDIT_SYNTAX_PATH + '/' + lang.get_id()
107
96
 
108
97
        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)
 
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)
114
148
 
115
149
    @classmethod
116
 
    def apply_colordiff_colors(klass, buf):
 
150
    def apply_colordiff_colors(klass, lang):
117
151
        """Set style colors for lang using the colordiff configuration file.
118
152
 
119
153
        Both ~/.colordiffrc and ~/.colordiffrc.bzr-gtk are read.
120
154
 
121
 
        :param buf: a "Diff" gtksourceview2.Buffer object.
 
155
        :param lang: a "Diff" gtksourceview.SourceLanguage object.
122
156
        """
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
 
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
148
176
                # since GSV is richer, accept new names for extra bits,
149
177
                # 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)
 
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)
187
205
 
188
206
    @staticmethod
189
207
    def parse_colordiffrc(fileobj):
287
305
        scrollwin.set_shadow_type(gtk.SHADOW_IN)
288
306
        self.pack1(scrollwin)
289
307
        scrollwin.show()
290
 
        
 
308
 
291
309
        self.model = gtk.TreeStore(str, str)
292
310
        self.treeview = gtk.TreeView(self.model)
293
311
        self.treeview.set_headers_visible(False)
312
330
        # text view
313
331
 
314
332
    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)
 
333
        self.diff_view = DiffFileView()
318
334
        self.diff_view.show()
 
335
        self.pack2(self.diff_view)
319
336
        for oldname, newname, patch in sections:
320
337
            self.diff_view._diffs[newname] = str(patch)
321
338
            if newname is None:
329
346
        Compares the two trees and populates the window with the
330
347
        differences.
331
348
        """
332
 
        if getattr(self, 'diff_view', None) is None:
333
 
            self.diff_view = DiffView()
334
 
            self.pack2(self.diff_view)
 
349
        self.diff_view = DiffView()
 
350
        self.pack2(self.diff_view)
335
351
        self.diff_view.show()
336
352
        self.diff_view.set_trees(rev_tree, parent_tree)
337
353
        self.rev_tree = rev_tree
364
380
                self.model.append(titer, [ path, path ])
365
381
 
366
382
        self.treeview.expand_all()
367
 
        self.diff_view.show_diff(None)
368
383
 
369
384
    def set_file(self, file_path):
370
385
        """Select the current file to display"""
375
390
                    tv_path = child.path
376
391
                    break
377
392
        if tv_path is None:
378
 
            raise errors.NoSuchFile(file_path)
 
393
            raise NoSuchFile(file_path)
379
394
        self.treeview.set_cursor(tv_path)
380
395
        self.treeview.scroll_to_cell(tv_path)
381
396
 
387
402
            return
388
403
        elif specific_files == [ "" ]:
389
404
            specific_files = None
390
 
        
 
405
 
391
406
        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)
 
407
 
399
408
 
400
409
class DiffWindow(Window):
401
410
    """Diff window.
422
431
        self.vbox = gtk.VBox()
423
432
        self.add(self.vbox)
424
433
        self.vbox.show()
 
434
        hbox = self._get_button_bar(operations)
 
435
        if hbox is not None:
 
436
            self.vbox.pack_start(hbox, expand=False, fill=True)
425
437
        self.diff = DiffWidget()
426
 
        self.vbox.pack_end(self.diff, True, True, 0)
 
438
        self.vbox.add(self.diff)
427
439
        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
 
    
 
440
 
452
441
    def _get_button_bar(self, operations):
453
442
        """Return a button bar to use.
454
443
 
583
572
        tree.lock_write()
584
573
        try:
585
574
            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)
 
575
                merger, verified = _mod_merge.Merger.from_mergeable(tree,
 
576
                    self.directive, progress.DummyProgress())
 
577
                merger.check_basis(True)
590
578
                merger.merge_type = _mod_merge.Merge3Merger
591
579
                conflict_count = merger.do_merge()
592
580
                merger.set_pending()
618
606
    renamed_and_modified = 'renamed and modified'
619
607
    modified = 'modified'
620
608
    kind_changed = 'kind changed'
621
 
    missing = 'missing'
622
609
 
623
610
    # TODO: Handle metadata changes
624
611
 
639
626
                    source_marker = ''
640
627
                else:
641
628
                    source_marker = osutils.kind_marker(kinds[0])
642
 
 
643
629
                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])
 
630
                    assert kinds[0] is not None
 
631
                    marker = osutils.kind_marker(kinds[0])
651
632
                else:
652
633
                    marker = osutils.kind_marker(kinds[1])
653
634
 
655
636
                if real_path is None:
656
637
                    real_path = paths[0]
657
638
                assert real_path is not None
 
639
                display_path = real_path + marker
658
640
 
659
641
                present_source = versioned[0] and kinds[0] is not None
660
642
                present_target = versioned[1] and kinds[1] is not None
661
643
 
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:
 
644
                if present_source != present_target:
666
645
                    if present_target:
667
646
                        change_type = added
668
647
                    else:
669
648
                        assert present_source
670
649
                        change_type = removed
671
 
                    display_path = real_path + marker
672
650
                elif names[0] != names[1] or parent_ids[0] != parent_ids[1]:
673
651
                    # Renamed
674
652
                    if changed_content or executables[0] != executables[1]:
682
660
                    change_type = kind_changed
683
661
                    display_path = (paths[0] + source_marker
684
662
                                    + ' => ' + paths[1] + marker)
685
 
                elif changed_content or executables[0] != executables[1]:
 
663
                elif changed_content is True or executables[0] != executables[1]:
686
664
                    change_type = modified
687
 
                    display_path = real_path + marker
688
665
                else:
689
666
                    assert False, "How did we get here?"
690
667