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 viz/diffwin.py
- browse files at revision 48
- compare with another revision
- download diff
- download tarball
- view history from revision 48
- Committer: Jelmer Vernooij
- Date: 2006-05-19 16:37:13 UTC
- Revision ID: jelmer@samba.org-20060519163713-be77b31c72cbc7e8
Move visualisation code to a separate directory, preparing for bundling
the GTK+ plugins for bzr.
the GTK+ plugins for bzr.
- files added:
- .bzrignore
- files removed:
- .bzrignore
- annotate
- branchview
- icons
- olive
- po
- preferences
- tests
- files renamed:
- diff.py => viz/diffwin.py
- branchview/linegraph.py => viz/graph.py
- branchview/graphcell.py => viz/graphcell.py
- files modified:
- AUTHORS
added
removed
viz/diffwin.py
1
#!/usr/bin/python
1
2
# -*- coding: UTF-8 -*-
2
3
"""Difference window.
3
4
11
12
12
13
from cStringIO import StringIO
13
14
14
import pygtk
15
pygtk.require("2.0")
16
15
import gtk
17
16
import pango
18
import os
19
import re
20
import sys
21
17
22
18
try:
23
19
import gtksourceview
24
20
have_gtksourceview = True
25
21
except ImportError:
26
22
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)
23
24
from bzrlib.delta import compare_trees
25
from bzrlib.diff import show_diff_trees
26
27
28
class DiffWindow(gtk.Window):
29
"""Diff window.
30
31
This object represents and manages a single window containing the
32
differences between two revisions on a branch.
33
"""
34
35
def __init__(self, app=None):
36
gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
37
self.set_border_width(0)
38
self.set_title("bzrk diff")
39
40
self.app = app
41
42
# Use two thirds of the screen by default
43
screen = self.get_screen()
44
monitor = screen.get_monitor_geometry(0)
45
width = int(monitor.width * 0.66)
46
height = int(monitor.height * 0.66)
47
self.set_default_size(width, height)
48
59
49
self.construct()
60
self._diffs = {}
61
50
62
51
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
52
"""Construct the window contents."""
53
hbox = gtk.HBox(spacing=6)
54
hbox.set_border_width(12)
55
self.add(hbox)
56
hbox.show()
57
303
58
scrollwin = gtk.ScrolledWindow()
304
59
scrollwin.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
305
60
scrollwin.set_shadow_type(gtk.SHADOW_IN)
306
self.pack1(scrollwin)
61
hbox.pack_start(scrollwin, expand=False, fill=True)
307
62
scrollwin.show()
308
63
309
64
self.model = gtk.TreeStore(str, str)
310
65
self.treeview = gtk.TreeView(self.model)
311
66
self.treeview.set_headers_visible(False)
321
76
column.add_attribute(cell, "text", 0)
322
77
self.treeview.append_column(column)
323
78
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):
79
80
scrollwin = gtk.ScrolledWindow()
81
scrollwin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
82
scrollwin.set_shadow_type(gtk.SHADOW_IN)
83
hbox.pack_start(scrollwin, expand=True, fill=True)
84
scrollwin.show()
85
86
if have_gtksourceview:
87
self.buffer = gtksourceview.SourceBuffer()
88
slm = gtksourceview.SourceLanguagesManager()
89
gsl = slm.get_language_from_mime_type("text/x-patch")
90
self.buffer.set_language(gsl)
91
self.buffer.set_highlight(True)
92
93
sourceview = gtksourceview.SourceView(self.buffer)
94
else:
95
self.buffer = gtk.TextBuffer()
96
sourceview = gtk.TextView(self.buffer)
97
98
sourceview.set_editable(False)
99
sourceview.modify_font(pango.FontDescription("Monospace"))
100
scrollwin.add(sourceview)
101
sourceview.show()
102
103
def set_diff(self, branch, revid, parentid):
345
104
"""Set the differences showed by this window.
346
105
347
106
Compares the two trees and populates the window with the
348
107
differences.
349
108
"""
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
109
self.rev_tree = branch.repository.revision_tree(revid)
110
self.parent_tree = branch.repository.revision_tree(parentid)
357
111
358
112
self.model.clear()
359
delta = self.rev_tree.changes_from(self.parent_tree)
113
delta = compare_trees(self.parent_tree, self.rev_tree)
360
114
361
115
self.model.append(None, [ "Complete Diff", "" ])
362
116
374
128
titer = self.model.append(None, [ "Renamed", None ])
375
129
for oldpath, newpath, id, kind, text_modified, meta_modified \
376
130
in delta.renamed:
377
self.model.append(titer, [ oldpath, newpath ])
131
self.model.append(titer, [ oldpath, oldpath ])
378
132
379
133
if len(delta.modified):
380
134
titer = self.model.append(None, [ "Modified", None ])
382
136
self.model.append(titer, [ path, path ])
383
137
384
138
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)
139
self.set_title(revid + " - " + branch.nick + " - bzrk diff")
399
140
400
141
def _treeview_cursor_cb(self, *args):
401
142
"""Callback for when the treeview cursor changes."""
404
145
if specific_files == [ None ]:
405
146
return
406
147
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
148
specific_files = []
149
150
s = StringIO()
151
show_diff_trees(self.parent_tree, self.rev_tree, s, specific_files)
152
self.buffer.set_text(s.getvalue())
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0