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.1.21
- compare with another revision
- download diff
- download tarball
- view history from revision 423.1.21
- Committer: Szilveszter Farkas (Phanatic)
- Date: 2008-03-03 17:24:22 UTC
- mto: This revision was merged to the branch mainline in revision 435.
- Revision ID: szilveszter.farkas@gmail.com-20080303172422-y1u0gg7kyirrxuun
Installing an olive package is pretty useless. (Fixed: #136432)
- files added:
- bzr-notify.desktop
- olive
- files removed:
- avatarproviders.py
- preferences
- files renamed:
- bazaar-properties.desktop.in => bazaar-properties.desktop
- icons/bzr-icon-64.png => bzr-icon-64.png
- bzr-handle-patch => handle-patch
- 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
__author__ = "Scott James Remnant <scott@ubuntu.com>"
8
__copyright__ = "Copyright © 2005 Canonical Ltd."
9
__author__ = "Scott James Remnant <scott@ubuntu.com>"
9
10
10
11
11
12
from cStringIO import StringIO
12
13
14
import pygtk
15
pygtk.require("2.0")
16
import gtk
17
import pango
18
import os
19
import re
13
20
import sys
14
import inspect
15
21
16
from gi.repository import Gtk
17
from gi.repository import Pango
18
22
try:
19
from gi.repository import GtkSource
23
import gtksourceview
20
24
have_gtksourceview = True
21
25
except ImportError:
22
26
have_gtksourceview = False
27
try:
28
import gconf
29
have_gconf = True
30
except ImportError:
31
have_gconf = False
23
32
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
33
from bzrlib import merge as _mod_merge, osutils, progress, workingtree
34
from bzrlib.diff import show_diff_trees, internal_diff
35
from bzrlib.errors import NoSuchFile
32
36
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
from bzrlib.trace import warning
39
38
from bzrlib.plugins.gtk.window import Window
40
41
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
39
from dialog import error_dialog, info_dialog, warning_dialog
48
40
49
41
50
42
class SelectCancelled(Exception):
52
44
pass
53
45
54
46
55
class DiffFileView(Gtk.ScrolledWindow):
47
class DiffFileView(gtk.ScrolledWindow):
56
48
"""Window for displaying diffs from a diff file"""
57
49
58
SHOW_WIDGETS = True
59
60
50
def __init__(self):
61
super(DiffFileView, self).__init__()
51
gtk.ScrolledWindow.__init__(self)
62
52
self.construct()
63
53
self._diffs = {}
64
54
65
55
def construct(self):
66
self.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
67
self.set_shadow_type(Gtk.ShadowType.IN)
56
self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
57
self.set_shadow_type(gtk.SHADOW_IN)
68
58
69
59
if have_gtksourceview:
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)
60
self.buffer = gtksourceview.SourceBuffer()
61
slm = gtksourceview.SourceLanguagesManager()
62
gsl = slm.get_language_from_mime_type("text/x-patch")
63
if have_gconf:
64
self.apply_gedit_colors(gsl)
65
self.apply_colordiff_colors(gsl)
66
self.buffer.set_language(gsl)
67
self.buffer.set_highlight(True)
68
69
sourceview = gtksourceview.SourceView(self.buffer)
76
70
else:
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()
71
self.buffer = gtk.TextBuffer()
72
sourceview = gtk.TextView(self.buffer)
73
74
sourceview.set_editable(False)
75
sourceview.modify_font(pango.FontDescription("Monospace"))
76
self.add(sourceview)
77
sourceview.show()
78
79
@staticmethod
80
def apply_gedit_colors(lang):
81
"""Set style for lang to that specified in gedit configuration.
82
83
This method needs the gconf module.
84
85
:param lang: a gtksourceview.SourceLanguage object.
86
"""
87
GEDIT_SYNTAX_PATH = '/apps/gedit-2/preferences/syntax_highlighting'
88
GEDIT_LANG_PATH = GEDIT_SYNTAX_PATH + '/' + lang.get_id()
89
90
client = gconf.client_get_default()
91
client.add_dir(GEDIT_LANG_PATH, gconf.CLIENT_PRELOAD_NONE)
92
93
for tag in lang.get_tags():
94
tag_id = tag.get_id()
95
gconf_key = GEDIT_LANG_PATH + '/' + tag_id
96
style_string = client.get_string(gconf_key)
97
98
if style_string is None:
99
continue
100
101
# function to get a bool from a string that's either '0' or '1'
102
string_bool = lambda x: bool(int(x))
103
104
# style_string is a string like "2/#FFCCAA/#000000/0/1/0/0"
105
# values are: mask, fg, bg, italic, bold, underline, strike
106
# this packs them into (str_value, attr_name, conv_func) tuples
107
items = zip(style_string.split('/'), ['mask', 'foreground',
108
'background', 'italic', 'bold', 'underline', 'strikethrough' ],
109
[ int, gtk.gdk.color_parse, gtk.gdk.color_parse, string_bool,
110
string_bool, string_bool, string_bool ]
111
)
112
113
style = gtksourceview.SourceTagStyle()
114
115
# XXX The mask attribute controls whether the present values of
116
# foreground and background color should in fact be used. Ideally
117
# (and that's what gedit does), one could set all three attributes,
118
# and let the TagStyle object figure out which colors to use.
119
# However, in the GtkSourceview python bindings, the mask attribute
120
# is read-only, and it's derived instead from the colors being
121
# set or not. This means that we have to sometimes refrain from
122
# setting fg or bg colors, depending on the value of the mask.
123
# This code could go away if mask were writable.
124
mask = int(items[0][0])
125
if not (mask & 1): # GTK_SOURCE_TAG_STYLE_USE_BACKGROUND
126
items[2:3] = []
127
if not (mask & 2): # GTK_SOURCE_TAG_STYLE_USE_FOREGROUND
128
items[1:2] = []
129
items[0:1] = [] # skip the mask unconditionally
130
131
for value, attr, func in items:
132
try:
133
value = func(value)
134
except ValueError:
135
warning('gconf key %s contains an invalid value: %s'
136
% gconf_key, value)
137
else:
138
setattr(style, attr, value)
139
140
lang.set_tag_style(tag_id, style)
141
142
@classmethod
143
def apply_colordiff_colors(klass, lang):
144
"""Set style colors for lang using the colordiff configuration file.
145
146
Both ~/.colordiffrc and ~/.colordiffrc.bzr-gtk are read.
147
148
:param lang: a "Diff" gtksourceview.SourceLanguage object.
149
"""
150
colors = {}
151
152
for f in ('~/.colordiffrc', '~/.colordiffrc.bzr-gtk'):
153
f = os.path.expanduser(f)
154
if os.path.exists(f):
155
try:
156
f = file(f)
157
except IOError, e:
158
warning('could not open file %s: %s' % (f, str(e)))
159
else:
160
colors.update(klass.parse_colordiffrc(f))
161
f.close()
162
163
if not colors:
164
# ~/.colordiffrc does not exist
165
return
166
167
mapping = {
168
# map GtkSourceView tags to colordiff names
169
# since GSV is richer, accept new names for extra bits,
170
# defaulting to old names if they're not present
171
'Added@32@line': ['newtext'],
172
'Removed@32@line': ['oldtext'],
173
'Location': ['location', 'diffstuff'],
174
'Diff@32@file': ['file', 'diffstuff'],
175
'Special@32@case': ['specialcase', 'diffstuff'],
176
}
177
178
for tag in lang.get_tags():
179
tag_id = tag.get_id()
180
keys = mapping.get(tag_id, [])
181
color = None
182
183
for key in keys:
184
color = colors.get(key, None)
185
if color is not None:
186
break
187
188
if color is None:
189
continue
190
191
style = gtksourceview.SourceTagStyle()
192
try:
193
style.foreground = gtk.gdk.color_parse(color)
194
except ValueError:
195
warning('not a valid color: %s' % color)
196
else:
197
lang.set_tag_style(tag_id, style)
198
199
@staticmethod
200
def parse_colordiffrc(fileobj):
201
"""Parse fileobj as a colordiff configuration file.
202
203
:return: A dict with the key -> value pairs.
204
"""
205
colors = {}
206
for line in fileobj:
207
if re.match(r'^\s*#', line):
208
continue
209
if '=' not in line:
210
continue
211
key, val = line.split('=', 1)
212
colors[key.strip()] = val.strip()
213
return colors
85
214
86
215
def set_trees(self, rev_tree, parent_tree):
87
216
self.rev_tree = rev_tree
92
221
# self.parent_tree.lock_read()
93
222
# self.rev_tree.lock_read()
94
223
# try:
95
# self.delta = iter_changes_to_status(
96
# self.parent_tree, self.rev_tree)
224
# self.delta = _iter_changes_to_status(self.parent_tree, self.rev_tree)
97
225
# self.path_to_status = {}
98
226
# self.path_to_diff = {}
99
227
# source_inv = self.parent_tree.inventory
100
228
# target_inv = self.rev_tree.inventory
101
229
# for (file_id, real_path, change_type, display_path) in self.delta:
102
# self.path_to_status[real_path] = u'=== %s %s' % (
103
# change_type, display_path)
230
# self.path_to_status[real_path] = u'=== %s %s' % (change_type, display_path)
104
231
# if change_type in ('modified', 'renamed and modified'):
105
232
# source_ie = source_inv[file_id]
106
233
# target_ie = target_inv[file_id]
108
235
# source_ie.diff(internal_diff, *old path, *old_tree,
109
236
# *new_path, target_ie, self.rev_tree,
110
237
# sio)
111
# self.path_to_diff[real_path] =
238
# self.path_to_diff[real_path] =
112
239
#
113
240
# finally:
114
241
# self.rev_tree.unlock()
128
255
"""This is the soft and chewy filling for a DiffWindow."""
129
256
130
257
def __init__(self):
131
super(DiffView, self).__init__()
258
DiffFileView.__init__(self)
132
259
self.rev_tree = None
133
260
self.parent_tree = None
134
261
158
285
self.buffer.set_text(decoded.encode('UTF-8'))
159
286
160
287
161
class DiffWidget(Gtk.HPaned):
288
class DiffWidget(gtk.HPaned):
162
289
"""Diff widget
163
290
164
291
"""
165
166
SHOW_WIDGETS = True
167
168
292
def __init__(self):
169
293
super(DiffWidget, self).__init__()
170
294
171
295
# The file hierarchy: a scrollable treeview
172
scrollwin = Gtk.ScrolledWindow()
173
scrollwin.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
174
scrollwin.set_shadow_type(Gtk.ShadowType.IN)
296
scrollwin = gtk.ScrolledWindow()
297
scrollwin.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
298
scrollwin.set_shadow_type(gtk.SHADOW_IN)
175
299
self.pack1(scrollwin)
176
if self.SHOW_WIDGETS:
177
scrollwin.show()
300
scrollwin.show()
178
301
179
self.model = Gtk.TreeStore(str, str)
180
self.treeview = Gtk.TreeView(model=self.model)
302
self.model = gtk.TreeStore(str, str)
303
self.treeview = gtk.TreeView(self.model)
181
304
self.treeview.set_headers_visible(False)
182
305
self.treeview.set_search_column(1)
183
306
self.treeview.connect("cursor-changed", self._treeview_cursor_cb)
184
307
scrollwin.add(self.treeview)
185
if self.SHOW_WIDGETS:
186
self.treeview.show()
308
self.treeview.show()
187
309
188
cell = Gtk.CellRendererText()
310
cell = gtk.CellRendererText()
189
311
cell.set_property("width-chars", 20)
190
column = Gtk.TreeViewColumn()
191
column.pack_start(cell, True)
312
column = gtk.TreeViewColumn()
313
column.pack_start(cell, expand=True)
192
314
column.add_attribute(cell, "text", 0)
193
315
self.treeview.append_column(column)
194
316
199
321
"""
200
322
# The diffs of the selected file: a scrollable source or
201
323
# text view
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:
324
self.diff_view = DiffFileView()
325
self.diff_view.show()
326
self.pack2(self.diff_view)
327
self.model.append(None, [ "Complete Diff", "" ])
328
self.diff_view._diffs[None] = ''.join(lines)
329
for patch in parse_patches(lines):
330
oldname = patch.oldname.split('\t')[0]
331
newname = patch.newname.split('\t')[0]
332
self.model.append(None, [oldname, newname])
210
333
self.diff_view._diffs[newname] = str(patch)
211
if newname is None:
212
newname = ''
213
self.model.append(None, [oldname, newname])
214
334
self.diff_view.show_diff(None)
215
335
216
336
def set_diff(self, rev_tree, parent_tree):
219
339
Compares the two trees and populates the window with the
220
340
differences.
221
341
"""
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()
342
self.diff_view = DiffView()
343
self.pack2(self.diff_view)
344
self.diff_view.show()
227
345
self.diff_view.set_trees(rev_tree, parent_tree)
228
346
self.rev_tree = rev_tree
229
347
self.parent_tree = parent_tree
231
349
self.model.clear()
232
350
delta = self.rev_tree.changes_from(self.parent_tree)
233
351
234
self.model.append(None, ["Complete Diff", ""])
352
self.model.append(None, [ "Complete Diff", "" ])
235
353
236
354
if len(delta.added):
237
titer = self.model.append(None, ["Added", None])
355
titer = self.model.append(None, [ "Added", None ])
238
356
for path, id, kind in delta.added:
239
self.model.append(titer, [path, path])
357
self.model.append(titer, [ path, path ])
240
358
241
359
if len(delta.removed):
242
titer = self.model.append(None, ["Removed", None])
360
titer = self.model.append(None, [ "Removed", None ])
243
361
for path, id, kind in delta.removed:
244
self.model.append(titer, [path, path])
362
self.model.append(titer, [ path, path ])
245
363
246
364
if len(delta.renamed):
247
titer = self.model.append(None, ["Renamed", None])
365
titer = self.model.append(None, [ "Renamed", None ])
248
366
for oldpath, newpath, id, kind, text_modified, meta_modified \
249
367
in delta.renamed:
250
self.model.append(titer, [oldpath, newpath])
368
self.model.append(titer, [ oldpath, newpath ])
251
369
252
370
if len(delta.modified):
253
titer = self.model.append(None, ["Modified", None])
371
titer = self.model.append(None, [ "Modified", None ])
254
372
for path, id, kind, text_modified, meta_modified in delta.modified:
255
self.model.append(titer, [path, path])
373
self.model.append(titer, [ path, path ])
256
374
257
375
self.treeview.expand_all()
258
self.diff_view.show_diff(None)
259
376
260
377
def set_file(self, file_path):
261
378
"""Select the current file to display"""
266
383
tv_path = child.path
267
384
break
268
385
if tv_path is None:
269
raise errors.NoSuchFile(file_path)
270
self.treeview.set_cursor(tv_path, None, False)
386
raise NoSuchFile(file_path)
387
self.treeview.set_cursor(tv_path)
271
388
self.treeview.scroll_to_cell(tv_path)
272
389
273
390
def _treeview_cursor_cb(self, *args):
274
391
"""Callback for when the treeview cursor changes."""
275
392
(path, col) = self.treeview.get_cursor()
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 == [""]:
393
specific_files = [ self.model[path][1] ]
394
if specific_files == [ None ]:
395
return
396
elif specific_files == [ "" ]:
282
397
specific_files = None
283
398
284
399
self.diff_view.show_diff(specific_files)
285
400
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
401
294
402
class DiffWindow(Window):
295
403
"""Diff window.
298
406
differences between two revisions on a branch.
299
407
"""
300
408
301
SHOW_WIDGETS = True
302
303
def __init__(self, parent=None, operations=None):
304
super(DiffWindow, self).__init__(parent=parent)
409
def __init__(self, parent=None):
410
Window.__init__(self, parent)
305
411
self.set_border_width(0)
306
self.set_title("bzr diff")
412
self.set_title("bzrk diff")
307
413
308
414
# Use two thirds of the screen by default
309
415
screen = self.get_screen()
311
417
width = int(monitor.width * 0.66)
312
418
height = int(monitor.height * 0.66)
313
419
self.set_default_size(width, height)
314
self.construct(operations)
315
316
def construct(self, operations):
420
421
self.construct()
422
423
def construct(self):
317
424
"""Construct the window contents."""
318
self.vbox = Gtk.VBox()
425
self.vbox = gtk.VBox()
319
426
self.add(self.vbox)
320
if self.SHOW_WIDGETS:
321
self.vbox.show()
427
self.vbox.show()
428
hbox = self._get_button_bar()
429
if hbox is not None:
430
self.vbox.pack_start(hbox, expand=False, fill=True)
322
431
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):
432
self.vbox.add(self.diff)
433
self.diff.show_all()
434
435
def _get_button_bar(self):
349
436
"""Return a button bar to use.
350
437
351
438
:return: None, meaning that no button bar will be used.
352
439
"""
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()
440
return None
441
442
def set_diff_text(self, description, lines):
443
"""Set the diff from a text.
444
445
The diff must be in unified diff format, and will be parsed to
446
determine filenames.
447
"""
448
self.diff.set_diff_text(lines)
449
self.set_title(description + " - bzrk diff")
409
450
410
451
def set_diff(self, description, rev_tree, parent_tree):
411
452
"""Set the differences showed by this window.
420
461
self.diff.set_file(file_path)
421
462
422
463
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)
464
class MergeDirectiveWindow(DiffWindow):
465
466
def __init__(self, directive, parent=None):
467
DiffWindow.__init__(self, parent)
468
self._merge_target = None
474
469
self.directive = directive
475
self.merge_target = None
476
477
def _provide_operations(self):
478
return [('Merge', self.perform_merge), ('Save', self.perform_save)]
470
471
def _get_button_bar(self):
472
"""The button bar has only the Merge button"""
473
merge_button = gtk.Button('Merge')
474
merge_button.show()
475
merge_button.set_relief(gtk.RELIEF_NONE)
476
merge_button.connect("clicked", self.perform_merge)
477
478
hbox = gtk.HButtonBox()
479
hbox.set_layout(gtk.BUTTONBOX_START)
480
hbox.pack_start(merge_button, expand=False, fill=True)
481
hbox.show()
482
return hbox
479
483
480
484
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)
485
try:
486
tree = self._get_merge_target()
487
except SelectCancelled:
488
return
487
489
tree.lock_write()
488
490
try:
489
491
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)
492
merger, verified = _mod_merge.Merger.from_mergeable(tree,
493
self.directive, progress.DummyProgress())
494
merger.check_basis(True)
494
495
merger.merge_type = _mod_merge.Merge3Merger
495
496
conflict_count = merger.do_merge()
496
497
merger.set_pending()
497
498
if conflict_count == 0:
498
self.window._merge_successful()
499
# No conflicts found.
500
info_dialog(_('Merge successful'),
501
_('All changes applied successfully.'))
499
502
else:
500
self.window._conflicts()
501
503
# There are conflicts to be resolved.
502
self.window.destroy()
504
warning_dialog(_('Conflicts encountered'),
505
_('Please resolve the conflicts manually'
506
' before committing.'))
507
self.destroy()
503
508
except Exception, e:
504
self.window._handle_error(e)
509
error_dialog('Error', str(e))
505
510
finally:
506
511
tree.unlock()
507
512
508
509
def iter_changes_to_status(source, target):
513
def _get_merge_target(self):
514
if self._merge_target is not None:
515
return self._merge_target
516
d = gtk.FileChooserDialog('Merge branch', self,
517
gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER,
518
buttons=(gtk.STOCK_OK, gtk.RESPONSE_OK,
519
gtk.STOCK_CANCEL,
520
gtk.RESPONSE_CANCEL,))
521
try:
522
result = d.run()
523
if result != gtk.RESPONSE_OK:
524
raise SelectCancelled()
525
uri = d.get_current_folder_uri()
526
finally:
527
d.destroy()
528
return workingtree.WorkingTree.open(uri)
529
530
531
def _iter_changes_to_status(source, target):
510
532
"""Determine the differences between trees.
511
533
512
This is a wrapper around iter_changes which just yields more
534
This is a wrapper around _iter_changes which just yields more
513
535
understandable results.
514
536
515
537
:param source: The source tree (basis tree)
522
544
renamed_and_modified = 'renamed and modified'
523
545
modified = 'modified'
524
546
kind_changed = 'kind changed'
525
missing = 'missing'
526
547
527
548
# TODO: Handle metadata changes
528
549
532
553
source.lock_read()
533
554
try:
534
555
for (file_id, paths, changed_content, versioned, parent_ids, names,
535
kinds, executables) in target.iter_changes(source):
556
kinds, executables) in target._iter_changes(source):
536
557
537
558
# Skip the root entry if it isn't very interesting
538
559
if parent_ids == (None, None):
543
564
source_marker = ''
544
565
else:
545
566
source_marker = osutils.kind_marker(kinds[0])
546
547
567
if kinds[1] is None:
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])
568
assert kinds[0] is not None
569
marker = osutils.kind_marker(kinds[0])
555
570
else:
556
571
marker = osutils.kind_marker(kinds[1])
557
572
559
574
if real_path is None:
560
575
real_path = paths[0]
561
576
assert real_path is not None
577
display_path = real_path + marker
562
578
563
579
present_source = versioned[0] and kinds[0] is not None
564
580
present_target = versioned[1] and kinds[1] is not None
565
581
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:
582
if present_source != present_target:
570
583
if present_target:
571
584
change_type = added
572
585
else:
573
586
assert present_source
574
587
change_type = removed
575
display_path = real_path + marker
576
588
elif names[0] != names[1] or parent_ids[0] != parent_ids[1]:
577
589
# Renamed
578
590
if changed_content or executables[0] != executables[1]:
586
598
change_type = kind_changed
587
599
display_path = (paths[0] + source_marker
588
600
+ ' => ' + paths[1] + marker)
589
elif changed_content or executables[0] != executables[1]:
601
elif changed_content is True or executables[0] != executables[1]:
590
602
change_type = modified
591
display_path = real_path + marker
592
603
else:
593
604
assert False, "How did we get here?"
594
605
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0