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 272.1.4
- compare with another revision
- download diff
- download tarball
- view history from revision 272.1.4
- Committer: Mateusz Korniak
- Date: 2007-09-02 15:42:18 UTC
- mto: This revision was merged to the branch mainline in revision 274.
- Revision ID: matkor@laptop-hp-20070902154218-nba0woaqjsn20f9n
Ignoring eric3 project files.
- files added:
- olive.glade
- files removed:
- 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
from xml.etree.ElementTree import Element, SubElement, tostring
21
21
22
22
try:
23
import gtksourceview2
23
import gtksourceview
24
24
have_gtksourceview = True
25
25
except ImportError:
26
26
have_gtksourceview = False
30
30
except ImportError:
31
31
have_gconf = False
32
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
33
import bzrlib
34
35
from bzrlib.diff import show_diff_trees
41
36
from bzrlib.errors import NoSuchFile
42
from bzrlib.patches import parse_patches
43
37
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"""
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
"""
56
46
57
47
def __init__(self):
58
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
59
59
self.construct()
60
self._diffs = {}
61
60
62
61
def construct(self):
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 = gtksourceview2.Buffer()
68
slm = gtksourceview2.LanguageManager()
69
gsl = slm.guess_language(content_type="text/x-patch")
70
if have_gconf:
71
self.apply_gedit_colors(self.buffer)
72
self.apply_colordiff_colors(self.buffer)
73
self.buffer.set_language(gsl)
74
self.buffer.set_highlight_syntax(True)
75
76
self.sourceview = gtksourceview2.View(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(buf):
88
"""Set style to that specified in gedit configuration.
89
90
This method needs the gconf module.
91
92
:param buf: a gtksourceview2.Buffer object.
93
"""
94
GEDIT_SCHEME_PATH = '/apps/gedit-2/preferences/editor/colors/scheme'
95
96
client = gconf.client_get_default()
97
style_scheme_name = client.get_string(GEDIT_SCHEME_PATH)
98
style_scheme = gtksourceview2.StyleSchemeManager().get_scheme(style_scheme_name)
99
100
buf.set_style_scheme(style_scheme)
101
102
@classmethod
103
def apply_colordiff_colors(klass, buf):
104
"""Set style colors for lang using the colordiff configuration file.
105
106
Both ~/.colordiffrc and ~/.colordiffrc.bzr-gtk are read.
107
108
:param buf: a "Diff" gtksourceview2.Buffer object.
109
"""
110
scheme_manager = gtksourceview2.StyleSchemeManager()
111
style_scheme = scheme_manager.get_scheme('colordiff')
112
113
# if style scheme not found, we'll generate it from colordiffrc
114
# TODO: reload if colordiffrc has changed.
115
if style_scheme is None:
116
colors = {}
117
118
for f in ('~/.colordiffrc', '~/.colordiffrc.bzr-gtk'):
119
f = os.path.expanduser(f)
120
if os.path.exists(f):
121
try:
122
f = file(f)
123
except IOError, e:
124
warning('could not open file %s: %s' % (f, str(e)))
125
else:
126
colors.update(klass.parse_colordiffrc(f))
127
f.close()
128
129
if not colors:
130
# ~/.colordiffrc does not exist
131
return
132
133
mapping = {
134
# map GtkSourceView2 scheme styles to colordiff names
135
# since GSV is richer, accept new names for extra bits,
136
# defaulting to old names if they're not present
137
'diff:added-line': ['newtext'],
138
'diff:removed-line': ['oldtext'],
139
'diff:location': ['location', 'diffstuff'],
140
'diff:file': ['file', 'diffstuff'],
141
'diff:special-case': ['specialcase', 'diffstuff'],
142
}
143
144
converted_colors = {}
145
for name, values in mapping.items():
146
color = None
147
for value in values:
148
color = colors.get(value, None)
149
if color is not None:
150
break
151
if color is None:
152
continue
153
converted_colors[name] = color
154
155
# some xml magic to produce needed style scheme description
156
e_style_scheme = Element('style-scheme')
157
e_style_scheme.set('id', 'colordiff')
158
e_style_scheme.set('_name', 'ColorDiff')
159
e_style_scheme.set('version', '1.0')
160
for name, color in converted_colors.items():
161
style = SubElement(e_style_scheme, 'style')
162
style.set('name', name)
163
style.set('foreground', '#%s' % color)
164
165
scheme_xml = tostring(e_style_scheme, 'UTF-8')
166
if not os.path.exists(os.path.expanduser('~/.local/share/gtksourceview-2.0/styles')):
167
os.makedirs(os.path.expanduser('~/.local/share/gtksourceview-2.0/styles'))
168
file(os.path.expanduser('~/.local/share/gtksourceview-2.0/styles/colordiff.xml'), 'w').write(scheme_xml)
169
170
scheme_manager.force_rescan()
171
style_scheme = scheme_manager.get_scheme('colordiff')
172
173
buf.set_style_scheme(style_scheme)
174
175
@staticmethod
176
def parse_colordiffrc(fileobj):
177
"""Parse fileobj as a colordiff configuration file.
178
179
:return: A dict with the key -> value pairs.
180
"""
181
colors = {}
182
for line in fileobj:
183
if re.match(r'^\s*#', line):
184
continue
185
if '=' not in line:
186
continue
187
key, val = line.split('=', 1)
188
colors[key.strip()] = val.strip()
189
return colors
190
191
def set_trees(self, rev_tree, parent_tree):
192
self.rev_tree = rev_tree
193
self.parent_tree = parent_tree
194
# self._build_delta()
195
196
# def _build_delta(self):
197
# self.parent_tree.lock_read()
198
# self.rev_tree.lock_read()
199
# try:
200
# self.delta = iter_changes_to_status(self.parent_tree, self.rev_tree)
201
# self.path_to_status = {}
202
# self.path_to_diff = {}
203
# source_inv = self.parent_tree.inventory
204
# target_inv = self.rev_tree.inventory
205
# for (file_id, real_path, change_type, display_path) in self.delta:
206
# self.path_to_status[real_path] = u'=== %s %s' % (change_type, display_path)
207
# if change_type in ('modified', 'renamed and modified'):
208
# source_ie = source_inv[file_id]
209
# target_ie = target_inv[file_id]
210
# sio = StringIO()
211
# source_ie.diff(internal_diff, *old path, *old_tree,
212
# *new_path, target_ie, self.rev_tree,
213
# sio)
214
# self.path_to_diff[real_path] =
215
#
216
# finally:
217
# self.rev_tree.unlock()
218
# self.parent_tree.unlock()
219
220
def show_diff(self, specific_files):
221
sections = []
222
if specific_files is None:
223
self.buffer.set_text(self._diffs[None])
224
else:
225
for specific_file in specific_files:
226
sections.append(self._diffs[specific_file])
227
self.buffer.set_text(''.join(sections))
228
229
230
class DiffView(DiffFileView):
231
"""This is the soft and chewy filling for a DiffWindow."""
232
233
def __init__(self):
234
DiffFileView.__init__(self)
235
self.rev_tree = None
236
self.parent_tree = None
237
238
def show_diff(self, specific_files):
239
"""Show the diff for the specified files"""
240
s = StringIO()
241
show_diff_trees(self.parent_tree, self.rev_tree, s, specific_files,
242
old_label='', new_label='',
243
# path_encoding=sys.getdefaultencoding()
244
# The default is utf-8, but we interpret the file
245
# contents as getdefaultencoding(), so we should
246
# probably try to make the paths in the same encoding.
247
)
248
# str.decode(encoding, 'replace') doesn't do anything. Because if a
249
# character is not valid in 'encoding' there is nothing to replace, the
250
# 'replace' is for 'str.encode()'
251
try:
252
decoded = s.getvalue().decode(sys.getdefaultencoding())
253
except UnicodeDecodeError:
254
try:
255
decoded = s.getvalue().decode('UTF-8')
256
except UnicodeDecodeError:
257
decoded = s.getvalue().decode('iso-8859-1')
258
# This always works, because every byte has a valid
259
# mapping from iso-8859-1 to Unicode
260
# TextBuffer must contain pure UTF-8 data
261
self.buffer.set_text(decoded.encode('UTF-8'))
262
263
264
class DiffWidget(gtk.HPaned):
265
"""Diff widget
266
267
"""
268
def __init__(self):
269
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()
270
69
271
70
# The file hierarchy: a scrollable treeview
272
71
scrollwin = gtk.ScrolledWindow()
273
72
scrollwin.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
274
73
scrollwin.set_shadow_type(gtk.SHADOW_IN)
275
self.pack1(scrollwin)
74
pane.pack1(scrollwin)
276
75
scrollwin.show()
277
76
278
77
self.model = gtk.TreeStore(str, str)
279
78
self.treeview = gtk.TreeView(self.model)
280
79
self.treeview.set_headers_visible(False)
290
89
column.add_attribute(cell, "text", 0)
291
90
self.treeview.append_column(column)
292
91
293
def set_diff_text(self, lines):
294
"""Set the current diff from a list of lines
295
296
:param lines: The diff to show, in unified diff format
297
"""
298
92
# The diffs of the selected file: a scrollable source or
299
93
# text view
300
301
def set_diff_text_sections(self, sections):
302
if getattr(self, 'diff_view', None) is None:
303
self.diff_view = DiffFileView()
304
self.pack2(self.diff_view)
305
self.diff_view.show()
306
for oldname, newname, patch in sections:
307
self.diff_view._diffs[newname] = str(patch)
308
if newname is None:
309
newname = ''
310
self.model.append(None, [oldname, newname])
311
self.diff_view.show_diff(None)
312
313
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):
314
121
"""Set the differences showed by this window.
315
122
316
123
Compares the two trees and populates the window with the
317
124
differences.
318
125
"""
319
if getattr(self, 'diff_view', None) is None:
320
self.diff_view = DiffView()
321
self.pack2(self.diff_view)
322
self.diff_view.show()
323
self.diff_view.set_trees(rev_tree, parent_tree)
324
126
self.rev_tree = rev_tree
325
127
self.parent_tree = parent_tree
326
128
351
153
self.model.append(titer, [ path, path ])
352
154
353
155
self.treeview.expand_all()
354
self.diff_view.show_diff(None)
156
self.set_title(description + " - bzrk diff")
355
157
356
158
def set_file(self, file_path):
357
"""Select the current file to display"""
358
159
tv_path = None
359
160
for data in self.model:
360
161
for child in data.iterchildren():
373
174
if specific_files == [ None ]:
374
175
return
375
176
elif specific_files == [ "" ]:
376
specific_files = None
377
378
self.diff_view.show_diff(specific_files)
379
380
def _on_wraplines_toggled(self, widget=None, wrap=False):
381
"""Callback for when the wrap lines checkbutton is toggled"""
382
if wrap or widget.get_active():
383
self.diff_view.sourceview.set_wrap_mode(gtk.WRAP_WORD)
384
else:
385
self.diff_view.sourceview.set_wrap_mode(gtk.WRAP_NONE)
386
387
class DiffWindow(Window):
388
"""Diff window.
389
390
This object represents and manages a single window containing the
391
differences between two revisions on a branch.
392
"""
393
394
def __init__(self, parent=None, operations=None):
395
Window.__init__(self, parent)
396
self.set_border_width(0)
397
self.set_title("bzrk diff")
398
399
# Use two thirds of the screen by default
400
screen = self.get_screen()
401
monitor = screen.get_monitor_geometry(0)
402
width = int(monitor.width * 0.66)
403
height = int(monitor.height * 0.66)
404
self.set_default_size(width, height)
405
self.construct(operations)
406
407
def construct(self, operations):
408
"""Construct the window contents."""
409
self.vbox = gtk.VBox()
410
self.add(self.vbox)
411
self.vbox.show()
412
self.diff = DiffWidget()
413
self.vbox.pack_end(self.diff, True, True, 0)
414
self.diff.show_all()
415
# Build after DiffWidget to connect signals
416
menubar = self._get_menu_bar()
417
self.vbox.pack_start(menubar, False, False, 0)
418
hbox = self._get_button_bar(operations)
419
if hbox is not None:
420
self.vbox.pack_start(hbox, False, True, 0)
421
422
423
def _get_menu_bar(self):
424
menubar = gtk.MenuBar()
425
# View menu
426
mb_view = gtk.MenuItem(_i18n("_View"))
427
mb_view_menu = gtk.Menu()
428
mb_view_wrapsource = gtk.CheckMenuItem(_i18n("Wrap _Long Lines"))
429
mb_view_wrapsource.connect('activate', self.diff._on_wraplines_toggled)
430
mb_view_wrapsource.show()
431
mb_view_menu.append(mb_view_wrapsource)
432
mb_view.show()
433
mb_view.set_submenu(mb_view_menu)
434
mb_view.show()
435
menubar.append(mb_view)
436
menubar.show()
437
return menubar
438
439
def _get_button_bar(self, operations):
440
"""Return a button bar to use.
441
442
:return: None, meaning that no button bar will be used.
443
"""
444
if operations is None:
445
return None
446
hbox = gtk.HButtonBox()
447
hbox.set_layout(gtk.BUTTONBOX_START)
448
for title, method in operations:
449
merge_button = gtk.Button(title)
450
merge_button.show()
451
merge_button.set_relief(gtk.RELIEF_NONE)
452
merge_button.connect("clicked", method)
453
hbox.pack_start(merge_button, expand=False, fill=True)
454
hbox.show()
455
return hbox
456
457
def _get_merge_target(self):
458
d = gtk.FileChooserDialog('Merge branch', self,
459
gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER,
460
buttons=(gtk.STOCK_OK, gtk.RESPONSE_OK,
461
gtk.STOCK_CANCEL,
462
gtk.RESPONSE_CANCEL,))
463
try:
464
result = d.run()
465
if result != gtk.RESPONSE_OK:
466
raise SelectCancelled()
467
return d.get_current_folder_uri()
468
finally:
469
d.destroy()
470
471
def _merge_successful(self):
472
# No conflicts found.
473
info_dialog(_i18n('Merge successful'),
474
_i18n('All changes applied successfully.'))
475
476
def _conflicts(self):
477
warning_dialog(_i18n('Conflicts encountered'),
478
_i18n('Please resolve the conflicts manually'
479
' before committing.'))
480
481
def _handle_error(self, e):
482
error_dialog('Error', str(e))
483
484
def _get_save_path(self, basename):
485
d = gtk.FileChooserDialog('Save As', self,
486
gtk.FILE_CHOOSER_ACTION_SAVE,
487
buttons=(gtk.STOCK_OK, gtk.RESPONSE_OK,
488
gtk.STOCK_CANCEL,
489
gtk.RESPONSE_CANCEL,))
490
d.set_current_name(basename)
491
try:
492
result = d.run()
493
if result != gtk.RESPONSE_OK:
494
raise SelectCancelled()
495
return urlutils.local_path_from_url(d.get_uri())
496
finally:
497
d.destroy()
498
499
def set_diff(self, description, rev_tree, parent_tree):
500
"""Set the differences showed by this window.
501
502
Compares the two trees and populates the window with the
503
differences.
504
"""
505
self.diff.set_diff(rev_tree, parent_tree)
506
self.set_title(description + " - bzrk diff")
507
508
def set_file(self, file_path):
509
self.diff.set_file(file_path)
510
511
512
class DiffController(object):
513
514
def __init__(self, path, patch, window=None):
515
self.path = path
516
self.patch = patch
517
if window is None:
518
window = DiffWindow(operations=self._provide_operations())
519
self.initialize_window(window)
520
self.window = window
521
522
def initialize_window(self, window):
523
window.diff.set_diff_text_sections(self.get_diff_sections())
524
window.set_title(self.path + " - diff")
525
526
def get_diff_sections(self):
527
yield "Complete Diff", None, ''.join(self.patch)
528
for patch in parse_patches(self.patch):
529
oldname = patch.oldname.split('\t')[0]
530
newname = patch.newname.split('\t')[0]
531
yield oldname, newname, str(patch)
532
533
def perform_save(self, window):
534
try:
535
save_path = self.window._get_save_path(osutils.basename(self.path))
536
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
537
269
return
538
source = open(self.path, 'rb')
539
try:
540
target = open(save_path, 'wb')
541
try:
542
osutils.pumpfile(source, target)
543
finally:
544
target.close()
545
finally:
546
source.close()
547
548
def _provide_operations(self):
549
return [('Save', self.perform_save)]
550
551
552
class MergeDirectiveController(DiffController):
553
554
def __init__(self, path, directive, window=None):
555
DiffController.__init__(self, path, directive.patch.splitlines(True),
556
window)
557
self.directive = directive
558
self.merge_target = None
559
560
def _provide_operations(self):
561
return [('Merge', self.perform_merge), ('Save', self.perform_save)]
562
563
def perform_merge(self, window):
564
if self.merge_target is None:
565
try:
566
self.merge_target = self.window._get_merge_target()
567
except SelectCancelled:
568
return
569
tree = workingtree.WorkingTree.open(self.merge_target)
570
tree.lock_write()
571
try:
572
try:
573
merger, verified = _mod_merge.Merger.from_mergeable(tree,
574
self.directive, progress.DummyProgress())
575
merger.check_basis(True)
576
merger.merge_type = _mod_merge.Merge3Merger
577
conflict_count = merger.do_merge()
578
merger.set_pending()
579
if conflict_count == 0:
580
self.window._merge_successful()
581
else:
582
self.window._conflicts()
583
# There are conflicts to be resolved.
584
self.window.destroy()
585
except Exception, e:
586
self.window._handle_error(e)
587
finally:
588
tree.unlock()
589
590
591
def iter_changes_to_status(source, target):
592
"""Determine the differences between trees.
593
594
This is a wrapper around iter_changes which just yields more
595
understandable results.
596
597
:param source: The source tree (basis tree)
598
:param target: The target tree
599
:return: A list of (file_id, real_path, change_type, display_path)
600
"""
601
added = 'added'
602
removed = 'removed'
603
renamed = 'renamed'
604
renamed_and_modified = 'renamed and modified'
605
modified = 'modified'
606
kind_changed = 'kind changed'
607
missing = 'missing'
608
609
# TODO: Handle metadata changes
610
611
status = []
612
target.lock_read()
613
try:
614
source.lock_read()
615
try:
616
for (file_id, paths, changed_content, versioned, parent_ids, names,
617
kinds, executables) in target.iter_changes(source):
618
619
# Skip the root entry if it isn't very interesting
620
if parent_ids == (None, None):
621
continue
622
623
change_type = None
624
if kinds[0] is None:
625
source_marker = ''
626
else:
627
source_marker = osutils.kind_marker(kinds[0])
628
629
if kinds[1] is None:
630
if kinds[0] is None:
631
# We assume bzr will flag only files in that case,
632
# there may be a bzr bug there as only files seems to
633
# not receive any kind.
634
marker = osutils.kind_marker('file')
635
else:
636
marker = osutils.kind_marker(kinds[0])
637
else:
638
marker = osutils.kind_marker(kinds[1])
639
640
real_path = paths[1]
641
if real_path is None:
642
real_path = paths[0]
643
assert real_path is not None
644
645
present_source = versioned[0] and kinds[0] is not None
646
present_target = versioned[1] and kinds[1] is not None
647
648
if kinds[0] is None and kinds[1] is None:
649
change_type = missing
650
display_path = real_path + marker
651
elif present_source != present_target:
652
if present_target:
653
change_type = added
654
else:
655
assert present_source
656
change_type = removed
657
display_path = real_path + marker
658
elif names[0] != names[1] or parent_ids[0] != parent_ids[1]:
659
# Renamed
660
if changed_content or executables[0] != executables[1]:
661
# and modified
662
change_type = renamed_and_modified
663
else:
664
change_type = renamed
665
display_path = (paths[0] + source_marker
666
+ ' => ' + paths[1] + marker)
667
elif kinds[0] != kinds[1]:
668
change_type = kind_changed
669
display_path = (paths[0] + source_marker
670
+ ' => ' + paths[1] + marker)
671
elif changed_content or executables[0] != executables[1]:
672
change_type = modified
673
display_path = real_path + marker
674
else:
675
assert False, "How did we get here?"
676
677
status.append((file_id, real_path, change_type, display_path))
678
finally:
679
source.unlock()
680
finally:
681
target.unlock()
682
683
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