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