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