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 796
- compare with another revision
- download diff
- download tarball
- view history from revision 796
- Committer: Vincent Ladeuil
- Date: 2013-02-27 08:05:54 UTC
- mfrom: (795.1.1 1132719-dont-expand-commit-message)
- Revision ID: v.ladeuil+lp@free.fr-20130227080554-scbbwlampq9n74r0
Commit messages never contain config options
- files added:
- avatarproviders.py
- branchview
- preferences
- files removed:
- bzr-notify.desktop
- olive
- files renamed:
- bazaar-properties.desktop => bazaar-properties.desktop.in
- viz/graphcell.py => branchview/graphcell.py
- viz/linegraph.py => branchview/linegraph.py
- viz/treemodel.py => branchview/treemodel.py
- viz/treeview.py => branchview/treeview.py
- bzr-icon-64.png => icons/bzr-icon-64.png
- preferences.py => preferences/__init__.py
- files modified:
- .bzrignore
added
removed
diff.py
1
# -*- coding: UTF-8 -*-
2
1
"""Difference window.
3
2
4
3
This module contains the code to manage the diff window which shows
5
4
the changes made between two revisions on a branch.
6
5
"""
7
6
8
__copyright__ = "Copyright © 2005 Canonical Ltd."
9
__author__ = "Scott James Remnant <scott@ubuntu.com>"
7
__copyright__ = "Copyright 2005 Canonical Ltd."
8
__author__ = "Scott James Remnant <scott@ubuntu.com>"
10
9
11
10
12
11
from cStringIO import StringIO
13
12
14
import pygtk
15
pygtk.require("2.0")
16
import gtk
17
import pango
18
import os
19
import re
20
13
import sys
14
import inspect
21
15
16
from gi.repository import Gtk
17
from gi.repository import Pango
22
18
try:
23
import gtksourceview
19
from gi.repository import GtkSource
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
23
33
from bzrlib import osutils
34
from bzrlib.diff import show_diff_trees, internal_diff
35
from bzrlib.errors import NoSuchFile
36
from bzrlib.trace import warning
24
from bzrlib import (
25
errors,
26
merge as _mod_merge,
27
osutils,
28
urlutils,
29
workingtree,
30
)
31
from bzrlib.diff import show_diff_trees
32
from bzrlib.patches import parse_patches
33
from bzrlib.plugins.gtk.dialog import (
34
error_dialog,
35
info_dialog,
36
warning_dialog,
37
)
38
from bzrlib.plugins.gtk.i18n import _i18n
37
39
from bzrlib.plugins.gtk.window import Window
38
40
39
41
40
class DiffView(gtk.ScrolledWindow):
41
"""This is the soft and chewy filling for a DiffWindow."""
42
def fallback_guess_language(slm, content_type):
43
for lang_id in slm.get_language_ids():
44
lang = slm.get_language(lang_id)
45
if "text/x-patch" in lang.get_mime_types():
46
return lang
47
return None
48
49
50
class SelectCancelled(Exception):
51
52
pass
53
54
55
class DiffFileView(Gtk.ScrolledWindow):
56
"""Window for displaying diffs from a diff file"""
57
58
SHOW_WIDGETS = True
42
59
43
60
def __init__(self):
44
gtk.ScrolledWindow.__init__(self)
45
61
super(DiffFileView, self).__init__()
46
62
self.construct()
47
self.rev_tree = None
48
self.parent_tree = None
63
self._diffs = {}
49
64
50
65
def construct(self):
51
self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
52
self.set_shadow_type(gtk.SHADOW_IN)
66
self.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
67
self.set_shadow_type(Gtk.ShadowType.IN)
53
68
54
69
if have_gtksourceview:
55
self.buffer = gtksourceview.SourceBuffer()
56
slm = gtksourceview.SourceLanguagesManager()
57
gsl = slm.get_language_from_mime_type("text/x-patch")
58
if have_gconf:
59
self.apply_gedit_colors(gsl)
60
self.apply_colordiff_colors(gsl)
61
self.buffer.set_language(gsl)
62
self.buffer.set_highlight(True)
63
64
sourceview = gtksourceview.SourceView(self.buffer)
70
self.buffer = GtkSource.Buffer()
71
lang_manager = GtkSource.LanguageManager.get_default()
72
language = lang_manager.guess_language(None, "text/x-patch")
73
self.buffer.set_language(language)
74
self.buffer.set_highlight_syntax(True)
75
self.sourceview = GtkSource.View(buffer=self.buffer)
65
76
else:
66
self.buffer = gtk.TextBuffer()
67
sourceview = gtk.TextView(self.buffer)
68
69
sourceview.set_editable(False)
70
sourceview.modify_font(pango.FontDescription("Monospace"))
71
self.add(sourceview)
72
sourceview.show()
73
74
@staticmethod
75
def apply_gedit_colors(lang):
76
"""Set style for lang to that specified in gedit configuration.
77
78
This method needs the gconf module.
79
80
:param lang: a gtksourceview.SourceLanguage object.
81
"""
82
GEDIT_SYNTAX_PATH = '/apps/gedit-2/preferences/syntax_highlighting'
83
GEDIT_LANG_PATH = GEDIT_SYNTAX_PATH + '/' + lang.get_id()
84
85
client = gconf.client_get_default()
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):
139
"""Set style colors for lang using the colordiff configuration file.
140
141
Both ~/.colordiffrc and ~/.colordiffrc.bzr-gtk are read.
142
143
:param lang: a "Diff" gtksourceview.SourceLanguage object.
144
"""
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
164
# since GSV is richer, accept new names for extra bits,
165
# defaulting to old names if they're not present
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)
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
77
self.buffer = Gtk.TextBuffer()
78
self.sourceview = Gtk.TextView(self.buffer)
79
80
self.sourceview.set_editable(False)
81
self.sourceview.override_font(Pango.FontDescription("Monospace"))
82
self.add(self.sourceview)
83
if self.SHOW_WIDGETS:
84
self.sourceview.show()
209
85
210
86
def set_trees(self, rev_tree, parent_tree):
211
87
self.rev_tree = rev_tree
216
92
# self.parent_tree.lock_read()
217
93
# self.rev_tree.lock_read()
218
94
# try:
219
# self.delta = _iter_changes_to_status(self.parent_tree, self.rev_tree)
95
# self.delta = iter_changes_to_status(
96
# self.parent_tree, self.rev_tree)
220
97
# self.path_to_status = {}
221
98
# self.path_to_diff = {}
222
99
# source_inv = self.parent_tree.inventory
223
100
# target_inv = self.rev_tree.inventory
224
101
# 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)
102
# self.path_to_status[real_path] = u'=== %s %s' % (
103
# change_type, display_path)
226
104
# if change_type in ('modified', 'renamed and modified'):
227
105
# source_ie = source_inv[file_id]
228
106
# target_ie = target_inv[file_id]
230
108
# source_ie.diff(internal_diff, *old path, *old_tree,
231
109
# *new_path, target_ie, self.rev_tree,
232
110
# sio)
233
# self.path_to_diff[real_path] =
111
# self.path_to_diff[real_path] =
234
112
#
235
113
# finally:
236
114
# self.rev_tree.unlock()
237
115
# self.parent_tree.unlock()
238
116
239
117
def show_diff(self, specific_files):
118
sections = []
119
if specific_files is None:
120
self.buffer.set_text(self._diffs[None])
121
else:
122
for specific_file in specific_files:
123
sections.append(self._diffs[specific_file])
124
self.buffer.set_text(''.join(sections))
125
126
127
class DiffView(DiffFileView):
128
"""This is the soft and chewy filling for a DiffWindow."""
129
130
def __init__(self):
131
super(DiffView, self).__init__()
132
self.rev_tree = None
133
self.parent_tree = None
134
135
def show_diff(self, specific_files):
136
"""Show the diff for the specified files"""
240
137
s = StringIO()
241
138
show_diff_trees(self.parent_tree, self.rev_tree, s, specific_files,
242
139
old_label='', new_label='',
261
158
self.buffer.set_text(decoded.encode('UTF-8'))
262
159
263
160
264
class DiffWindow(Window):
265
"""Diff window.
161
class DiffWidget(Gtk.HPaned):
162
"""Diff widget
266
163
267
This object represents and manages a single window containing the
268
differences between two revisions on a branch.
269
164
"""
270
165
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()
166
SHOW_WIDGETS = True
167
168
def __init__(self):
169
super(DiffWidget, self).__init__()
293
170
294
171
# The file hierarchy: a scrollable treeview
295
scrollwin = gtk.ScrolledWindow()
296
scrollwin.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
297
scrollwin.set_shadow_type(gtk.SHADOW_IN)
298
pane.pack1(scrollwin)
299
scrollwin.show()
172
scrollwin = Gtk.ScrolledWindow()
173
scrollwin.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
174
scrollwin.set_shadow_type(Gtk.ShadowType.IN)
175
self.pack1(scrollwin)
176
if self.SHOW_WIDGETS:
177
scrollwin.show()
300
178
301
self.model = gtk.TreeStore(str, str)
302
self.treeview = gtk.TreeView(self.model)
179
self.model = Gtk.TreeStore(str, str)
180
self.treeview = Gtk.TreeView(model=self.model)
303
181
self.treeview.set_headers_visible(False)
304
182
self.treeview.set_search_column(1)
305
183
self.treeview.connect("cursor-changed", self._treeview_cursor_cb)
306
184
scrollwin.add(self.treeview)
307
self.treeview.show()
185
if self.SHOW_WIDGETS:
186
self.treeview.show()
308
187
309
cell = gtk.CellRendererText()
188
cell = Gtk.CellRendererText()
310
189
cell.set_property("width-chars", 20)
311
column = gtk.TreeViewColumn()
312
column.pack_start(cell, expand=True)
190
column = Gtk.TreeViewColumn()
191
column.pack_start(cell, True)
313
192
column.add_attribute(cell, "text", 0)
314
193
self.treeview.append_column(column)
315
194
195
def set_diff_text(self, lines):
196
"""Set the current diff from a list of lines
197
198
:param lines: The diff to show, in unified diff format
199
"""
316
200
# The diffs of the selected file: a scrollable source or
317
201
# text view
318
self.diff_view = DiffView()
319
pane.pack2(self.diff_view)
320
self.diff_view.show()
321
322
def set_diff(self, description, rev_tree, parent_tree):
202
203
def set_diff_text_sections(self, sections):
204
if getattr(self, 'diff_view', None) is None:
205
self.diff_view = DiffFileView()
206
self.pack2(self.diff_view)
207
if self.SHOW_WIDGETS:
208
self.diff_view.show()
209
for oldname, newname, patch in sections:
210
self.diff_view._diffs[newname] = str(patch)
211
if newname is None:
212
newname = ''
213
self.model.append(None, [oldname, newname])
214
self.diff_view.show_diff(None)
215
216
def set_diff(self, rev_tree, parent_tree):
323
217
"""Set the differences showed by this window.
324
218
325
219
Compares the two trees and populates the window with the
326
220
differences.
327
221
"""
222
if getattr(self, 'diff_view', None) is None:
223
self.diff_view = DiffView()
224
self.pack2(self.diff_view)
225
if self.SHOW_WIDGETS:
226
self.diff_view.show()
328
227
self.diff_view.set_trees(rev_tree, parent_tree)
329
228
self.rev_tree = rev_tree
330
229
self.parent_tree = parent_tree
332
231
self.model.clear()
333
232
delta = self.rev_tree.changes_from(self.parent_tree)
334
233
335
self.model.append(None, [ "Complete Diff", "" ])
234
self.model.append(None, ["Complete Diff", ""])
336
235
337
236
if len(delta.added):
338
titer = self.model.append(None, [ "Added", None ])
237
titer = self.model.append(None, ["Added", None])
339
238
for path, id, kind in delta.added:
340
self.model.append(titer, [ path, path ])
239
self.model.append(titer, [path, path])
341
240
342
241
if len(delta.removed):
343
titer = self.model.append(None, [ "Removed", None ])
242
titer = self.model.append(None, ["Removed", None])
344
243
for path, id, kind in delta.removed:
345
self.model.append(titer, [ path, path ])
244
self.model.append(titer, [path, path])
346
245
347
246
if len(delta.renamed):
348
titer = self.model.append(None, [ "Renamed", None ])
247
titer = self.model.append(None, ["Renamed", None])
349
248
for oldpath, newpath, id, kind, text_modified, meta_modified \
350
249
in delta.renamed:
351
self.model.append(titer, [ oldpath, newpath ])
250
self.model.append(titer, [oldpath, newpath])
352
251
353
252
if len(delta.modified):
354
titer = self.model.append(None, [ "Modified", None ])
253
titer = self.model.append(None, ["Modified", None])
355
254
for path, id, kind, text_modified, meta_modified in delta.modified:
356
self.model.append(titer, [ path, path ])
255
self.model.append(titer, [path, path])
357
256
358
257
self.treeview.expand_all()
359
self.set_title(description + " - bzrk diff")
258
self.diff_view.show_diff(None)
360
259
361
260
def set_file(self, file_path):
261
"""Select the current file to display"""
362
262
tv_path = None
363
263
for data in self.model:
364
264
for child in data.iterchildren():
366
266
tv_path = child.path
367
267
break
368
268
if tv_path is None:
369
raise NoSuchFile(file_path)
370
self.treeview.set_cursor(tv_path)
269
raise errors.NoSuchFile(file_path)
270
self.treeview.set_cursor(tv_path, None, False)
371
271
self.treeview.scroll_to_cell(tv_path)
372
272
373
273
def _treeview_cursor_cb(self, *args):
374
274
"""Callback for when the treeview cursor changes."""
375
275
(path, col) = self.treeview.get_cursor()
376
specific_files = [ self.model[path][1] ]
377
if specific_files == [ None ]:
378
return
379
elif specific_files == [ "" ]:
276
if path is None:
277
return
278
specific_files = [self.model[path][1]]
279
if specific_files == [None]:
280
return
281
elif specific_files == [""]:
380
282
specific_files = None
381
283
382
284
self.diff_view.show_diff(specific_files)
383
285
384
385
def _iter_changes_to_status(source, target):
286
def _on_wraplines_toggled(self, widget=None, wrap=False):
287
"""Callback for when the wrap lines checkbutton is toggled"""
288
if wrap or widget.get_active():
289
self.diff_view.sourceview.set_wrap_mode(Gtk.WrapMode.WORD)
290
else:
291
self.diff_view.sourceview.set_wrap_mode(Gtk.WrapMode.NONE)
292
293
294
class DiffWindow(Window):
295
"""Diff window.
296
297
This object represents and manages a single window containing the
298
differences between two revisions on a branch.
299
"""
300
301
SHOW_WIDGETS = True
302
303
def __init__(self, parent=None, operations=None):
304
super(DiffWindow, self).__init__(parent=parent)
305
self.set_border_width(0)
306
self.set_title("bzr diff")
307
308
# Use two thirds of the screen by default
309
screen = self.get_screen()
310
monitor = screen.get_monitor_geometry(0)
311
width = int(monitor.width * 0.66)
312
height = int(monitor.height * 0.66)
313
self.set_default_size(width, height)
314
self.construct(operations)
315
316
def construct(self, operations):
317
"""Construct the window contents."""
318
self.vbox = Gtk.VBox()
319
self.add(self.vbox)
320
if self.SHOW_WIDGETS:
321
self.vbox.show()
322
self.diff = DiffWidget()
323
self.vbox.pack_end(self.diff, True, True, 0)
324
if self.SHOW_WIDGETS:
325
self.diff.show_all()
326
# Build after DiffWidget to connect signals
327
menubar = self._get_menu_bar()
328
self.vbox.pack_start(menubar, False, False, 0)
329
hbox = self._get_button_bar(operations)
330
if hbox is not None:
331
self.vbox.pack_start(hbox, False, True, 0)
332
333
def _get_menu_bar(self):
334
menubar = Gtk.MenuBar()
335
# View menu
336
mb_view = Gtk.MenuItem.new_with_mnemonic(_i18n("_View"))
337
mb_view_menu = Gtk.Menu()
338
mb_view_wrapsource = Gtk.CheckMenuItem.new_with_mnemonic(
339
_i18n("Wrap _Long Lines"))
340
mb_view_wrapsource.connect('activate', self.diff._on_wraplines_toggled)
341
mb_view_menu.append(mb_view_wrapsource)
342
mb_view.set_submenu(mb_view_menu)
343
menubar.append(mb_view)
344
if self.SHOW_WIDGETS:
345
menubar.show_all()
346
return menubar
347
348
def _get_button_bar(self, operations):
349
"""Return a button bar to use.
350
351
:return: None, meaning that no button bar will be used.
352
"""
353
if operations is None:
354
return None
355
hbox = Gtk.HButtonBox()
356
hbox.set_layout(Gtk.ButtonBoxStyle.START)
357
for title, method in operations:
358
merge_button = Gtk.Button(title)
359
if self.SHOW_WIDGETS:
360
merge_button.show()
361
merge_button.set_relief(Gtk.ReliefStyle.NONE)
362
merge_button.connect("clicked", method)
363
hbox.pack_start(merge_button, False, True, 0)
364
if self.SHOW_WIDGETS:
365
hbox.show()
366
return hbox
367
368
def _get_merge_target(self):
369
d = Gtk.FileChooserDialog('Merge branch', self,
370
Gtk.FileChooserAction.SELECT_FOLDER,
371
buttons=(Gtk.STOCK_OK, Gtk.ResponseType.OK,
372
Gtk.STOCK_CANCEL,
373
Gtk.ResponseType.CANCEL,))
374
try:
375
result = d.run()
376
if result != Gtk.ResponseType.OK:
377
raise SelectCancelled()
378
return d.get_current_folder_uri()
379
finally:
380
d.destroy()
381
382
def _merge_successful(self):
383
# No conflicts found.
384
info_dialog(_i18n('Merge successful'),
385
_i18n('All changes applied successfully.'))
386
387
def _conflicts(self):
388
warning_dialog(_i18n('Conflicts encountered'),
389
_i18n('Please resolve the conflicts manually'
390
' before committing.'))
391
392
def _handle_error(self, e):
393
error_dialog('Error', str(e))
394
395
def _get_save_path(self, basename):
396
d = Gtk.FileChooserDialog('Save As', self,
397
Gtk.FileChooserAction.SAVE,
398
buttons=(Gtk.STOCK_OK, Gtk.ResponseType.OK,
399
Gtk.STOCK_CANCEL,
400
Gtk.ResponseType.CANCEL,))
401
d.set_current_name(basename)
402
try:
403
result = d.run()
404
if result != Gtk.ResponseType.OK:
405
raise SelectCancelled()
406
return urlutils.local_path_from_url(d.get_uri())
407
finally:
408
d.destroy()
409
410
def set_diff(self, description, rev_tree, parent_tree):
411
"""Set the differences showed by this window.
412
413
Compares the two trees and populates the window with the
414
differences.
415
"""
416
self.diff.set_diff(rev_tree, parent_tree)
417
self.set_title(description + " - bzrk diff")
418
419
def set_file(self, file_path):
420
self.diff.set_file(file_path)
421
422
423
class DiffController(object):
424
425
def __init__(self, path, patch, window=None, allow_dirty=False):
426
self.path = path
427
self.patch = patch
428
self.allow_dirty = allow_dirty
429
if window is None:
430
window = DiffWindow(operations=self._provide_operations())
431
self.initialize_window(window)
432
self.window = window
433
434
def initialize_window(self, window):
435
window.diff.set_diff_text_sections(self.get_diff_sections())
436
window.set_title(self.path + " - diff")
437
438
def get_diff_sections(self):
439
yield "Complete Diff", None, ''.join(self.patch)
440
# allow_dirty was added to parse_patches in bzrlib 2.2b1
441
if 'allow_dirty' in inspect.getargspec(parse_patches).args:
442
patches = parse_patches(self.patch, allow_dirty=self.allow_dirty)
443
else:
444
patches = parse_patches(self.patch)
445
for patch in patches:
446
oldname = patch.oldname.split('\t')[0]
447
newname = patch.newname.split('\t')[0]
448
yield oldname, newname, str(patch)
449
450
def perform_save(self, window):
451
try:
452
save_path = self.window._get_save_path(osutils.basename(self.path))
453
except SelectCancelled:
454
return
455
source = open(self.path, 'rb')
456
try:
457
target = open(save_path, 'wb')
458
try:
459
osutils.pumpfile(source, target)
460
finally:
461
target.close()
462
finally:
463
source.close()
464
465
def _provide_operations(self):
466
return [('Save', self.perform_save)]
467
468
469
class MergeDirectiveController(DiffController):
470
471
def __init__(self, path, directive, window=None):
472
super(MergeDirectiveController, self).__init__(
473
path, directive.patch.splitlines(True), window)
474
self.directive = directive
475
self.merge_target = None
476
477
def _provide_operations(self):
478
return [('Merge', self.perform_merge), ('Save', self.perform_save)]
479
480
def perform_merge(self, window):
481
if self.merge_target is None:
482
try:
483
self.merge_target = self.window._get_merge_target()
484
except SelectCancelled:
485
return
486
tree = workingtree.WorkingTree.open(self.merge_target)
487
tree.lock_write()
488
try:
489
try:
490
if tree.has_changes():
491
raise errors.UncommittedChanges(tree)
492
merger, verified = _mod_merge.Merger.from_mergeable(
493
tree, self.directive, pb=None)
494
merger.merge_type = _mod_merge.Merge3Merger
495
conflict_count = merger.do_merge()
496
merger.set_pending()
497
if conflict_count == 0:
498
self.window._merge_successful()
499
else:
500
self.window._conflicts()
501
# There are conflicts to be resolved.
502
self.window.destroy()
503
except Exception, e:
504
self.window._handle_error(e)
505
finally:
506
tree.unlock()
507
508
509
def iter_changes_to_status(source, target):
386
510
"""Determine the differences between trees.
387
511
388
This is a wrapper around _iter_changes which just yields more
512
This is a wrapper around iter_changes which just yields more
389
513
understandable results.
390
514
391
515
:param source: The source tree (basis tree)
398
522
renamed_and_modified = 'renamed and modified'
399
523
modified = 'modified'
400
524
kind_changed = 'kind changed'
525
missing = 'missing'
401
526
402
527
# TODO: Handle metadata changes
403
528
407
532
source.lock_read()
408
533
try:
409
534
for (file_id, paths, changed_content, versioned, parent_ids, names,
410
kinds, executables) in target._iter_changes(source):
535
kinds, executables) in target.iter_changes(source):
411
536
412
537
# Skip the root entry if it isn't very interesting
413
538
if parent_ids == (None, None):
418
543
source_marker = ''
419
544
else:
420
545
source_marker = osutils.kind_marker(kinds[0])
546
421
547
if kinds[1] is None:
422
assert kinds[0] is not None
423
marker = osutils.kind_marker(kinds[0])
548
if kinds[0] is None:
549
# We assume bzr will flag only files in that case,
550
# there may be a bzr bug there as only files seems to
551
# not receive any kind.
552
marker = osutils.kind_marker('file')
553
else:
554
marker = osutils.kind_marker(kinds[0])
424
555
else:
425
556
marker = osutils.kind_marker(kinds[1])
426
557
428
559
if real_path is None:
429
560
real_path = paths[0]
430
561
assert real_path is not None
431
display_path = real_path + marker
432
562
433
563
present_source = versioned[0] and kinds[0] is not None
434
564
present_target = versioned[1] and kinds[1] is not None
435
565
436
if present_source != present_target:
566
if kinds[0] is None and kinds[1] is None:
567
change_type = missing
568
display_path = real_path + marker
569
elif present_source != present_target:
437
570
if present_target:
438
571
change_type = added
439
572
else:
440
573
assert present_source
441
574
change_type = removed
575
display_path = real_path + marker
442
576
elif names[0] != names[1] or parent_ids[0] != parent_ids[1]:
443
577
# Renamed
444
578
if changed_content or executables[0] != executables[1]:
452
586
change_type = kind_changed
453
587
display_path = (paths[0] + source_marker
454
588
+ ' => ' + paths[1] + marker)
455
elif changed_content is True or executables[0] != executables[1]:
589
elif changed_content or executables[0] != executables[1]:
456
590
change_type = modified
591
display_path = real_path + marker
457
592
else:
458
593
assert False, "How did we get here?"
459
594
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0