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