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