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 423.2.1
- compare with another revision
- download diff
- download tarball
- view history from revision 423.2.1
- Committer: Daniel Schierbeck
- Date: 2008-01-13 14:12:49 UTC
- mto: (423.1.2 trunk)
- mto: This revision was merged to the branch mainline in revision 429.
- Revision ID: daniel.schierbeck@gmail.com-20080113141249-gd0i2lknr3yik55r
Moved branch view to its own package.
- files added:
- olive.glade
- files removed:
- bzr-gtk.applications
- preferences
- files renamed:
- icons/bzr-icon-64.png => bzr-icon-64.png
- preferences/__init__.py => preferences.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
)
33
from bzrlib import osutils
40
34
from bzrlib.diff import show_diff_trees, internal_diff
41
35
from bzrlib.errors import NoSuchFile
42
from bzrlib.patches import parse_patches
43
36
from bzrlib.trace import warning
44
from bzrlib.plugins.gtk import _i18n
45
37
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 DiffView(gtk.ScrolledWindow):
41
"""This is the soft and chewy filling for a DiffWindow."""
56
42
57
43
def __init__(self):
58
44
gtk.ScrolledWindow.__init__(self)
45
59
46
self.construct()
60
self._diffs = {}
47
self.rev_tree = None
48
self.parent_tree = None
61
49
62
50
def construct(self):
63
51
self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
64
52
self.set_shadow_type(gtk.SHADOW_IN)
65
53
66
54
if have_gtksourceview:
67
self.buffer = gtksourceview2.Buffer()
68
slm = gtksourceview2.LanguageManager()
69
gsl = slm.guess_language(content_type="text/x-patch")
55
self.buffer = gtksourceview.SourceBuffer()
56
slm = gtksourceview.SourceLanguagesManager()
57
gsl = slm.get_language_from_mime_type("text/x-patch")
70
58
if have_gconf:
71
self.apply_gedit_colors(self.buffer)
72
self.apply_colordiff_colors(self.buffer)
59
self.apply_gedit_colors(gsl)
60
self.apply_colordiff_colors(gsl)
73
61
self.buffer.set_language(gsl)
74
self.buffer.set_highlight_syntax(True)
62
self.buffer.set_highlight(True)
75
63
76
self.sourceview = gtksourceview2.View(self.buffer)
64
sourceview = gtksourceview.SourceView(self.buffer)
77
65
else:
78
66
self.buffer = gtk.TextBuffer()
79
self.sourceview = gtk.TextView(self.buffer)
67
sourceview = gtk.TextView(self.buffer)
80
68
81
self.sourceview.set_editable(False)
82
self.sourceview.modify_font(pango.FontDescription("Monospace"))
83
self.add(self.sourceview)
84
self.sourceview.show()
69
sourceview.set_editable(False)
70
sourceview.modify_font(pango.FontDescription("Monospace"))
71
self.add(sourceview)
72
sourceview.show()
85
73
86
74
@staticmethod
87
def apply_gedit_colors(buf):
88
"""Set style to that specified in gedit configuration.
75
def apply_gedit_colors(lang):
76
"""Set style for lang to that specified in gedit configuration.
89
77
90
78
This method needs the gconf module.
91
79
92
:param buf: a gtksourceview2.Buffer object.
80
:param lang: a gtksourceview.SourceLanguage object.
93
81
"""
94
GEDIT_SCHEME_PATH = '/apps/gedit-2/preferences/editor/colors/scheme'
82
GEDIT_SYNTAX_PATH = '/apps/gedit-2/preferences/syntax_highlighting'
83
GEDIT_LANG_PATH = GEDIT_SYNTAX_PATH + '/' + lang.get_id()
95
84
96
85
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):
86
client.add_dir(GEDIT_LANG_PATH, gconf.CLIENT_PRELOAD_NONE)
87
88
for tag in lang.get_tags():
89
tag_id = tag.get_id()
90
gconf_key = GEDIT_LANG_PATH + '/' + tag_id
91
style_string = client.get_string(gconf_key)
92
93
if style_string is None:
94
continue
95
96
# function to get a bool from a string that's either '0' or '1'
97
string_bool = lambda x: bool(int(x))
98
99
# style_string is a string like "2/#FFCCAA/#000000/0/1/0/0"
100
# values are: mask, fg, bg, italic, bold, underline, strike
101
# this packs them into (str_value, attr_name, conv_func) tuples
102
items = zip(style_string.split('/'), ['mask', 'foreground',
103
'background', 'italic', 'bold', 'underline', 'strikethrough' ],
104
[ int, gtk.gdk.color_parse, gtk.gdk.color_parse, string_bool,
105
string_bool, string_bool, string_bool ]
106
)
107
108
style = gtksourceview.SourceTagStyle()
109
110
# XXX The mask attribute controls whether the present values of
111
# foreground and background color should in fact be used. Ideally
112
# (and that's what gedit does), one could set all three attributes,
113
# and let the TagStyle object figure out which colors to use.
114
# However, in the GtkSourceview python bindings, the mask attribute
115
# is read-only, and it's derived instead from the colors being
116
# set or not. This means that we have to sometimes refrain from
117
# setting fg or bg colors, depending on the value of the mask.
118
# This code could go away if mask were writable.
119
mask = int(items[0][0])
120
if not (mask & 1): # GTK_SOURCE_TAG_STYLE_USE_BACKGROUND
121
items[2:3] = []
122
if not (mask & 2): # GTK_SOURCE_TAG_STYLE_USE_FOREGROUND
123
items[1:2] = []
124
items[0:1] = [] # skip the mask unconditionally
125
126
for value, attr, func in items:
127
try:
128
value = func(value)
129
except ValueError:
130
warning('gconf key %s contains an invalid value: %s'
131
% gconf_key, value)
132
else:
133
setattr(style, attr, value)
134
135
lang.set_tag_style(tag_id, style)
136
137
@staticmethod
138
def apply_colordiff_colors(lang):
104
139
"""Set style colors for lang using the colordiff configuration file.
105
140
106
141
Both ~/.colordiffrc and ~/.colordiffrc.bzr-gtk are read.
107
142
108
:param buf: a "Diff" gtksourceview2.Buffer object.
143
:param lang: a "Diff" gtksourceview.SourceLanguage object.
109
144
"""
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
145
colors = {}
146
147
for f in ('~/.colordiffrc', '~/.colordiffrc.bzr-gtk'):
148
f = os.path.expanduser(f)
149
if os.path.exists(f):
150
try:
151
f = file(f)
152
except IOError, e:
153
warning('could not open file %s: %s' % (f, str(e)))
154
else:
155
colors.update(DiffView.parse_colordiffrc(f))
156
f.close()
157
158
if not colors:
159
# ~/.colordiffrc does not exist
160
return
161
162
mapping = {
163
# map GtkSourceView tags to colordiff names
135
164
# since GSV is richer, accept new names for extra bits,
136
165
# 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)
166
'Added@32@line': ['newtext'],
167
'Removed@32@line': ['oldtext'],
168
'Location': ['location', 'diffstuff'],
169
'Diff@32@file': ['file', 'diffstuff'],
170
'Special@32@case': ['specialcase', 'diffstuff'],
171
}
172
173
for tag in lang.get_tags():
174
tag_id = tag.get_id()
175
keys = mapping.get(tag_id, [])
176
color = None
177
178
for key in keys:
179
color = colors.get(key, None)
180
if color is not None:
181
break
182
183
if color is None:
184
continue
185
186
style = gtksourceview.SourceTagStyle()
187
try:
188
style.foreground = gtk.gdk.color_parse(color)
189
except ValueError:
190
warning('not a valid color: %s' % color)
191
else:
192
lang.set_tag_style(tag_id, style)
174
193
175
194
@staticmethod
176
195
def parse_colordiffrc(fileobj):
197
216
# self.parent_tree.lock_read()
198
217
# self.rev_tree.lock_read()
199
218
# try:
200
# self.delta = iter_changes_to_status(self.parent_tree, self.rev_tree)
219
# self.delta = _iter_changes_to_status(self.parent_tree, self.rev_tree)
201
220
# self.path_to_status = {}
202
221
# self.path_to_diff = {}
203
222
# source_inv = self.parent_tree.inventory
218
237
# self.parent_tree.unlock()
219
238
220
239
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
240
s = StringIO()
241
241
show_diff_trees(self.parent_tree, self.rev_tree, s, specific_files,
242
242
old_label='', new_label='',
261
261
self.buffer.set_text(decoded.encode('UTF-8'))
262
262
263
263
264
class DiffWidget(gtk.HPaned):
265
"""Diff widget
264
class DiffWindow(Window):
265
"""Diff window.
266
266
267
This object represents and manages a single window containing the
268
differences between two revisions on a branch.
267
269
"""
268
def __init__(self):
269
super(DiffWidget, self).__init__()
270
271
def __init__(self, parent=None):
272
Window.__init__(self, parent)
273
self.set_border_width(0)
274
self.set_title("bzrk diff")
275
276
# Use two thirds of the screen by default
277
screen = self.get_screen()
278
monitor = screen.get_monitor_geometry(0)
279
width = int(monitor.width * 0.66)
280
height = int(monitor.height * 0.66)
281
self.set_default_size(width, height)
282
283
self.construct()
284
285
def construct(self):
286
"""Construct the window contents."""
287
# The window consists of a pane containing: the
288
# hierarchical list of files on the left, and the diff
289
# for the currently selected file on the right.
290
pane = gtk.HPaned()
291
self.add(pane)
292
pane.show()
270
293
271
294
# The file hierarchy: a scrollable treeview
272
295
scrollwin = gtk.ScrolledWindow()
273
296
scrollwin.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
274
297
scrollwin.set_shadow_type(gtk.SHADOW_IN)
275
self.pack1(scrollwin)
298
pane.pack1(scrollwin)
276
299
scrollwin.show()
277
300
278
301
self.model = gtk.TreeStore(str, str)
279
302
self.treeview = gtk.TreeView(self.model)
280
303
self.treeview.set_headers_visible(False)
290
313
column.add_attribute(cell, "text", 0)
291
314
self.treeview.append_column(column)
292
315
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
316
# The diffs of the selected file: a scrollable source or
299
317
# 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)
318
self.diff_view = DiffView()
319
pane.pack2(self.diff_view)
305
320
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
321
313
def set_diff(self, rev_tree, parent_tree):
322
def set_diff(self, description, rev_tree, parent_tree):
314
323
"""Set the differences showed by this window.
315
324
316
325
Compares the two trees and populates the window with the
317
326
differences.
318
327
"""
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
328
self.diff_view.set_trees(rev_tree, parent_tree)
324
329
self.rev_tree = rev_tree
325
330
self.parent_tree = parent_tree
351
356
self.model.append(titer, [ path, path ])
352
357
353
358
self.treeview.expand_all()
354
self.diff_view.show_diff(None)
359
self.set_title(description + " - bzrk diff")
355
360
356
361
def set_file(self, file_path):
357
"""Select the current file to display"""
358
362
tv_path = None
359
363
for data in self.model:
360
364
for child in data.iterchildren():
374
378
return
375
379
elif specific_files == [ "" ]:
376
380
specific_files = None
377
381
378
382
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:
537
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):
383
384
385
def _iter_changes_to_status(source, target):
592
386
"""Determine the differences between trees.
593
387
594
This is a wrapper around iter_changes which just yields more
388
This is a wrapper around _iter_changes which just yields more
595
389
understandable results.
596
390
597
391
:param source: The source tree (basis tree)
604
398
renamed_and_modified = 'renamed and modified'
605
399
modified = 'modified'
606
400
kind_changed = 'kind changed'
607
missing = 'missing'
608
401
609
402
# TODO: Handle metadata changes
610
403
614
407
source.lock_read()
615
408
try:
616
409
for (file_id, paths, changed_content, versioned, parent_ids, names,
617
kinds, executables) in target.iter_changes(source):
410
kinds, executables) in target._iter_changes(source):
618
411
619
412
# Skip the root entry if it isn't very interesting
620
413
if parent_ids == (None, None):
625
418
source_marker = ''
626
419
else:
627
420
source_marker = osutils.kind_marker(kinds[0])
628
629
421
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])
422
assert kinds[0] is not None
423
marker = osutils.kind_marker(kinds[0])
637
424
else:
638
425
marker = osutils.kind_marker(kinds[1])
639
426
641
428
if real_path is None:
642
429
real_path = paths[0]
643
430
assert real_path is not None
431
display_path = real_path + marker
644
432
645
433
present_source = versioned[0] and kinds[0] is not None
646
434
present_target = versioned[1] and kinds[1] is not None
647
435
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:
436
if present_source != present_target:
652
437
if present_target:
653
438
change_type = added
654
439
else:
655
440
assert present_source
656
441
change_type = removed
657
display_path = real_path + marker
658
442
elif names[0] != names[1] or parent_ids[0] != parent_ids[1]:
659
443
# Renamed
660
444
if changed_content or executables[0] != executables[1]:
668
452
change_type = kind_changed
669
453
display_path = (paths[0] + source_marker
670
454
+ ' => ' + paths[1] + marker)
671
elif changed_content or executables[0] != executables[1]:
455
elif changed_content is True or executables[0] != executables[1]:
672
456
change_type = modified
673
display_path = real_path + marker
674
457
else:
675
458
assert False, "How did we get here?"
676
459
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0