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 263.2.1
- compare with another revision
- download diff
- download tarball
- view history from revision 263.2.1
- Committer: matkor
- Date: 2007-08-23 10:17:40 UTC
- mto: This revision was merged to the branch mainline in revision 265.
- Revision ID: matkor@laptop-hp-20070823101740-s17kf9qa383wiuje
Code for "branch update" menuitem and toolbox. Typo fix
- files added:
- olive.glade
- files removed:
- branchbox.py
- branchview
- preferences
- files renamed:
- icons/bzr-icon-64.png => bzr-icon-64.png
- revisionview.py => logview.py
- preferences/__init__.py => preferences.py
- branchview/linegraph.py => viz/graph.py
- branchview/graphcell.py => viz/graphcell.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
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
33
30
except ImportError:
34
31
have_gconf = False
35
32
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
33
import bzrlib
34
35
from bzrlib.diff import show_diff_trees
36
from bzrlib.errors import NoSuchFile
45
37
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"""
38
39
40
class DiffWindow(gtk.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
"""
66
46
67
47
def __init__(self):
68
gtk.ScrolledWindow.__init__(self)
48
gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
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
69
59
self.construct()
70
self._diffs = {}
71
60
72
61
def construct(self):
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__()
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()
283
69
284
70
# The file hierarchy: a scrollable treeview
285
71
scrollwin = gtk.ScrolledWindow()
286
72
scrollwin.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
287
73
scrollwin.set_shadow_type(gtk.SHADOW_IN)
288
self.pack1(scrollwin)
74
pane.pack1(scrollwin)
289
75
scrollwin.show()
290
76
291
77
self.model = gtk.TreeStore(str, str)
292
78
self.treeview = gtk.TreeView(self.model)
293
79
self.treeview.set_headers_visible(False)
303
89
column.add_attribute(cell, "text", 0)
304
90
self.treeview.append_column(column)
305
91
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
92
# The diffs of the selected file: a scrollable source or
312
93
# 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):
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):
327
121
"""Set the differences showed by this window.
328
122
329
123
Compares the two trees and populates the window with the
330
124
differences.
331
125
"""
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
126
self.rev_tree = rev_tree
338
127
self.parent_tree = parent_tree
339
128
364
153
self.model.append(titer, [ path, path ])
365
154
366
155
self.treeview.expand_all()
367
self.diff_view.show_diff(None)
156
self.set_title(description + " - bzrk diff")
368
157
369
158
def set_file(self, file_path):
370
"""Select the current file to display"""
371
159
tv_path = None
372
160
for data in self.model:
373
161
for child in data.iterchildren():
375
163
tv_path = child.path
376
164
break
377
165
if tv_path is None:
378
raise errors.NoSuchFile(file_path)
166
raise NoSuchFile(file_path)
379
167
self.treeview.set_cursor(tv_path)
380
168
self.treeview.scroll_to_cell(tv_path)
381
169
386
174
if specific_files == [ None ]:
387
175
return
388
176
elif specific_files == [ "" ]:
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:
177
specific_files = []
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
550
269
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
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