/b-gtk/fix-viz

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

  • Committer: John Arbash Meinel
  • Date: 2007-10-01 17:41:53 UTC
  • mto: (322.1.1 trunk) (330.3.3 trunk)
  • mto: This revision was merged to the branch mainline in revision 368.
  • Revision ID: john@arbash-meinel.com-20071001174153-6xoqsds4hnv291l3
Adding some prototypes of how the commit should look

Show diffs side-by-side

added added

removed removed

Lines of Context:
diff.py
30
30
except ImportError:
31
31
    have_gconf = False
32
32
 
33
 
from bzrlib import (
34
 
    merge as _mod_merge,
35
 
    osutils,
36
 
    progress,
37
 
    urlutils,
38
 
    workingtree,
39
 
)
40
 
from bzrlib.diff import show_diff_trees, internal_diff
 
33
import bzrlib
 
34
 
 
35
from bzrlib.diff import show_diff_trees
41
36
from bzrlib.errors import NoSuchFile
42
 
from bzrlib.patches import parse_patches
43
37
from bzrlib.trace import warning
44
 
from bzrlib.plugins.gtk import _i18n
45
 
from bzrlib.plugins.gtk.window import Window
46
 
from dialog import error_dialog, info_dialog, warning_dialog
47
 
 
48
 
 
49
 
class SelectCancelled(Exception):
50
 
 
51
 
    pass
52
 
 
53
 
 
54
 
class DiffFileView(gtk.ScrolledWindow):
55
 
    """Window for displaying diffs from a diff file"""
 
38
 
 
39
 
 
40
class DiffDisplay(gtk.ScrolledWindow):
 
41
    """This is the soft and chewy filling for a DiffWindow."""
56
42
 
57
43
    def __init__(self):
58
44
        gtk.ScrolledWindow.__init__(self)
 
45
 
59
46
        self.construct()
60
 
        self._diffs = {}
 
47
        self.rev_tree = None
 
48
        self.parent_tree = None
61
49
 
62
50
    def construct(self):
63
51
        self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
146
134
 
147
135
            lang.set_tag_style(tag_id, style)
148
136
 
149
 
    @classmethod
150
 
    def apply_colordiff_colors(klass, lang):
 
137
    @staticmethod
 
138
    def apply_colordiff_colors(lang):
151
139
        """Set style colors for lang using the colordiff configuration file.
152
140
 
153
141
        Both ~/.colordiffrc and ~/.colordiffrc.bzr-gtk are read.
164
152
                except IOError, e:
165
153
                    warning('could not open file %s: %s' % (f, str(e)))
166
154
                else:
167
 
                    colors.update(klass.parse_colordiffrc(f))
 
155
                    colors.update(DiffDisplay.parse_colordiffrc(f))
168
156
                    f.close()
169
157
 
170
158
        if not colors:
222
210
    def set_trees(self, rev_tree, parent_tree):
223
211
        self.rev_tree = rev_tree
224
212
        self.parent_tree = parent_tree
225
 
#        self._build_delta()
226
 
 
227
 
#    def _build_delta(self):
228
 
#        self.parent_tree.lock_read()
229
 
#        self.rev_tree.lock_read()
230
 
#        try:
231
 
#            self.delta = iter_changes_to_status(self.parent_tree, self.rev_tree)
232
 
#            self.path_to_status = {}
233
 
#            self.path_to_diff = {}
234
 
#            source_inv = self.parent_tree.inventory
235
 
#            target_inv = self.rev_tree.inventory
236
 
#            for (file_id, real_path, change_type, display_path) in self.delta:
237
 
#                self.path_to_status[real_path] = u'=== %s %s' % (change_type, display_path)
238
 
#                if change_type in ('modified', 'renamed and modified'):
239
 
#                    source_ie = source_inv[file_id]
240
 
#                    target_ie = target_inv[file_id]
241
 
#                    sio = StringIO()
242
 
#                    source_ie.diff(internal_diff, *old path, *old_tree,
243
 
#                                   *new_path, target_ie, self.rev_tree,
244
 
#                                   sio)
245
 
#                    self.path_to_diff[real_path] = 
246
 
#
247
 
#        finally:
248
 
#            self.rev_tree.unlock()
249
 
#            self.parent_tree.unlock()
250
 
 
251
 
    def show_diff(self, specific_files):
252
 
        sections = []
253
 
        if specific_files is None:
254
 
            self.buffer.set_text(self._diffs[None])
255
 
        else:
256
 
            for specific_file in specific_files:
257
 
                sections.append(self._diffs[specific_file])
258
 
            self.buffer.set_text(''.join(sections))
259
 
 
260
 
 
261
 
class DiffView(DiffFileView):
262
 
    """This is the soft and chewy filling for a DiffWindow."""
263
 
 
264
 
    def __init__(self):
265
 
        DiffFileView.__init__(self)
266
 
        self.rev_tree = None
267
 
        self.parent_tree = None
268
 
 
269
 
    def show_diff(self, specific_files):
270
 
        """Show the diff for the specified files"""
 
213
 
 
214
    def show_diff(self, specific_files):
271
215
        s = StringIO()
272
 
        show_diff_trees(self.parent_tree, self.rev_tree, s, specific_files,
273
 
                        old_label='', new_label='',
274
 
                        # path_encoding=sys.getdefaultencoding()
275
 
                        # The default is utf-8, but we interpret the file
276
 
                        # contents as getdefaultencoding(), so we should
277
 
                        # probably try to make the paths in the same encoding.
278
 
                        )
279
 
        # str.decode(encoding, 'replace') doesn't do anything. Because if a
280
 
        # character is not valid in 'encoding' there is nothing to replace, the
281
 
        # 'replace' is for 'str.encode()'
282
 
        try:
283
 
            decoded = s.getvalue().decode(sys.getdefaultencoding())
284
 
        except UnicodeDecodeError:
285
 
            try:
286
 
                decoded = s.getvalue().decode('UTF-8')
287
 
            except UnicodeDecodeError:
288
 
                decoded = s.getvalue().decode('iso-8859-1')
289
 
                # This always works, because every byte has a valid
290
 
                # mapping from iso-8859-1 to Unicode
291
 
        # TextBuffer must contain pure UTF-8 data
292
 
        self.buffer.set_text(decoded.encode('UTF-8'))
293
 
 
294
 
 
295
 
class DiffWidget(gtk.HPaned):
296
 
    """Diff widget
297
 
 
 
216
        show_diff_trees(self.parent_tree, self.rev_tree, s, specific_files)
 
217
        self.buffer.set_text(s.getvalue().decode(sys.getdefaultencoding(), 'replace'))
 
218
 
 
219
 
 
220
class DiffWindow(gtk.Window):
 
221
    """Diff window.
 
222
 
 
223
    This object represents and manages a single window containing the
 
224
    differences between two revisions on a branch.
298
225
    """
 
226
 
299
227
    def __init__(self):
300
 
        super(DiffWidget, self).__init__()
 
228
        gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
 
229
        self.set_border_width(0)
 
230
        self.set_title("bzrk diff")
 
231
 
 
232
        # Use two thirds of the screen by default
 
233
        screen = self.get_screen()
 
234
        monitor = screen.get_monitor_geometry(0)
 
235
        width = int(monitor.width * 0.66)
 
236
        height = int(monitor.height * 0.66)
 
237
        self.set_default_size(width, height)
 
238
 
 
239
        self.construct()
 
240
 
 
241
    def construct(self):
 
242
        """Construct the window contents."""
 
243
        # The   window  consists  of   a  pane   containing:  the
 
244
        # hierarchical list  of files on  the left, and  the diff
 
245
        # for the currently selected file on the right.
 
246
        pane = gtk.HPaned()
 
247
        self.add(pane)
 
248
        pane.show()
301
249
 
302
250
        # The file hierarchy: a scrollable treeview
303
251
        scrollwin = gtk.ScrolledWindow()
304
252
        scrollwin.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
305
253
        scrollwin.set_shadow_type(gtk.SHADOW_IN)
306
 
        self.pack1(scrollwin)
 
254
        pane.pack1(scrollwin)
307
255
        scrollwin.show()
308
256
 
309
257
        self.model = gtk.TreeStore(str, str)
321
269
        column.add_attribute(cell, "text", 0)
322
270
        self.treeview.append_column(column)
323
271
 
324
 
    def set_diff_text(self, lines):
325
 
        """Set the current diff from a list of lines
326
 
 
327
 
        :param lines: The diff to show, in unified diff format
328
 
        """
329
272
        # The diffs of the  selected file: a scrollable source or
330
273
        # text view
331
 
 
332
 
    def set_diff_text_sections(self, sections):
333
 
        self.diff_view = DiffFileView()
334
 
        self.diff_view.show()
335
 
        self.pack2(self.diff_view)
336
 
        for oldname, newname, patch in sections:
337
 
            self.diff_view._diffs[newname] = str(patch)
338
 
            if newname is None:
339
 
                newname = ''
340
 
            self.model.append(None, [oldname, newname])
341
 
        self.diff_view.show_diff(None)
342
 
 
343
 
    def set_diff(self, rev_tree, parent_tree):
 
274
        self.diff_win = DiffDisplay()
 
275
        pane.pack2(self.diff_win)
 
276
        self.diff_win.show()
 
277
 
 
278
    def set_diff(self, description, rev_tree, parent_tree):
344
279
        """Set the differences showed by this window.
345
280
 
346
281
        Compares the two trees and populates the window with the
347
282
        differences.
348
283
        """
349
 
        self.diff_view = DiffView()
350
 
        self.pack2(self.diff_view)
351
 
        self.diff_view.show()
352
 
        self.diff_view.set_trees(rev_tree, parent_tree)
 
284
        self.diff_win.set_trees(rev_tree, parent_tree)
353
285
        self.rev_tree = rev_tree
354
286
        self.parent_tree = parent_tree
355
287
 
380
312
                self.model.append(titer, [ path, path ])
381
313
 
382
314
        self.treeview.expand_all()
 
315
        self.set_title(description + " - bzrk diff")
383
316
 
384
317
    def set_file(self, file_path):
385
 
        """Select the current file to display"""
386
318
        tv_path = None
387
319
        for data in self.model:
388
320
            for child in data.iterchildren():
403
335
        elif specific_files == [ "" ]:
404
336
            specific_files = None
405
337
 
406
 
        self.diff_view.show_diff(specific_files)
407
 
 
408
 
 
409
 
class DiffWindow(Window):
410
 
    """Diff window.
411
 
 
412
 
    This object represents and manages a single window containing the
413
 
    differences between two revisions on a branch.
414
 
    """
415
 
 
416
 
    def __init__(self, parent=None, operations=None):
417
 
        Window.__init__(self, parent)
418
 
        self.set_border_width(0)
419
 
        self.set_title("bzrk diff")
420
 
 
421
 
        # Use two thirds of the screen by default
422
 
        screen = self.get_screen()
423
 
        monitor = screen.get_monitor_geometry(0)
424
 
        width = int(monitor.width * 0.66)
425
 
        height = int(monitor.height * 0.66)
426
 
        self.set_default_size(width, height)
427
 
        self.construct(operations)
428
 
 
429
 
    def construct(self, operations):
430
 
        """Construct the window contents."""
431
 
        self.vbox = gtk.VBox()
432
 
        self.add(self.vbox)
433
 
        self.vbox.show()
434
 
        hbox = self._get_button_bar(operations)
435
 
        if hbox is not None:
436
 
            self.vbox.pack_start(hbox, expand=False, fill=True)
437
 
        self.diff = DiffWidget()
438
 
        self.vbox.add(self.diff)
439
 
        self.diff.show_all()
440
 
 
441
 
    def _get_button_bar(self, operations):
442
 
        """Return a button bar to use.
443
 
 
444
 
        :return: None, meaning that no button bar will be used.
445
 
        """
446
 
        if operations is None:
447
 
            return None
448
 
        hbox = gtk.HButtonBox()
449
 
        hbox.set_layout(gtk.BUTTONBOX_START)
450
 
        for title, method in operations:
451
 
            merge_button = gtk.Button(title)
452
 
            merge_button.show()
453
 
            merge_button.set_relief(gtk.RELIEF_NONE)
454
 
            merge_button.connect("clicked", method)
455
 
            hbox.pack_start(merge_button, expand=False, fill=True)
456
 
        hbox.show()
457
 
        return hbox
458
 
 
459
 
    def _get_merge_target(self):
460
 
        d = gtk.FileChooserDialog('Merge branch', self,
461
 
                                  gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER,
462
 
                                  buttons=(gtk.STOCK_OK, gtk.RESPONSE_OK,
463
 
                                           gtk.STOCK_CANCEL,
464
 
                                           gtk.RESPONSE_CANCEL,))
465
 
        try:
466
 
            result = d.run()
467
 
            if result != gtk.RESPONSE_OK:
468
 
                raise SelectCancelled()
469
 
            return d.get_current_folder_uri()
470
 
        finally:
471
 
            d.destroy()
472
 
 
473
 
    def _merge_successful(self):
474
 
        # No conflicts found.
475
 
        info_dialog(_i18n('Merge successful'),
476
 
                    _i18n('All changes applied successfully.'))
477
 
 
478
 
    def _conflicts(self):
479
 
        warning_dialog(_i18n('Conflicts encountered'),
480
 
                       _i18n('Please resolve the conflicts manually'
481
 
                             ' before committing.'))
482
 
 
483
 
    def _handle_error(self, e):
484
 
        error_dialog('Error', str(e))
485
 
 
486
 
    def _get_save_path(self, basename):
487
 
        d = gtk.FileChooserDialog('Save As', self,
488
 
                                  gtk.FILE_CHOOSER_ACTION_SAVE,
489
 
                                  buttons=(gtk.STOCK_OK, gtk.RESPONSE_OK,
490
 
                                           gtk.STOCK_CANCEL,
491
 
                                           gtk.RESPONSE_CANCEL,))
492
 
        d.set_current_name(basename)
493
 
        try:
494
 
            result = d.run()
495
 
            if result != gtk.RESPONSE_OK:
496
 
                raise SelectCancelled()
497
 
            return urlutils.local_path_from_url(d.get_uri())
498
 
        finally:
499
 
            d.destroy()
500
 
 
501
 
    def set_diff(self, description, rev_tree, parent_tree):
502
 
        """Set the differences showed by this window.
503
 
 
504
 
        Compares the two trees and populates the window with the
505
 
        differences.
506
 
        """
507
 
        self.diff.set_diff(rev_tree, parent_tree)
508
 
        self.set_title(description + " - bzrk diff")
509
 
 
510
 
    def set_file(self, file_path):
511
 
        self.diff.set_file(file_path)
512
 
 
513
 
 
514
 
class DiffController(object):
515
 
 
516
 
    def __init__(self, path, patch, window=None):
517
 
        self.path = path
518
 
        self.patch = patch
519
 
        if window is None:
520
 
            window = DiffWindow(operations=self._provide_operations())
521
 
            self.initialize_window(window)
522
 
        self.window = window
523
 
 
524
 
    def initialize_window(self, window):
525
 
        window.diff.set_diff_text_sections(self.get_diff_sections())
526
 
        window.set_title(self.path + " - diff")
527
 
 
528
 
    def get_diff_sections(self):
529
 
        yield "Complete Diff", None, ''.join(self.patch)
530
 
        for patch in parse_patches(self.patch):
531
 
            oldname = patch.oldname.split('\t')[0]
532
 
            newname = patch.newname.split('\t')[0]
533
 
            yield oldname, newname, str(patch)
534
 
 
535
 
    def perform_save(self, window):
536
 
        try:
537
 
            save_path = self.window._get_save_path(osutils.basename(self.path))
538
 
        except SelectCancelled:
539
 
            return
540
 
        source = open(self.path, 'rb')
541
 
        try:
542
 
            target = open(save_path, 'wb')
543
 
            try:
544
 
                osutils.pumpfile(source, target)
545
 
            finally:
546
 
                target.close()
547
 
        finally:
548
 
            source.close()
549
 
 
550
 
    def _provide_operations(self):
551
 
        return [('Save', self.perform_save)]
552
 
 
553
 
 
554
 
class MergeDirectiveController(DiffController):
555
 
 
556
 
    def __init__(self, path, directive, window=None):
557
 
        DiffController.__init__(self, path, directive.patch.splitlines(True),
558
 
                                window)
559
 
        self.directive = directive
560
 
        self.merge_target = None
561
 
 
562
 
    def _provide_operations(self):
563
 
        return [('Merge', self.perform_merge), ('Save', self.perform_save)]
564
 
 
565
 
    def perform_merge(self, window):
566
 
        if self.merge_target is None:
567
 
            try:
568
 
                self.merge_target = self.window._get_merge_target()
569
 
            except SelectCancelled:
570
 
                return
571
 
        tree = workingtree.WorkingTree.open(self.merge_target)
572
 
        tree.lock_write()
573
 
        try:
574
 
            try:
575
 
                merger, verified = _mod_merge.Merger.from_mergeable(tree,
576
 
                    self.directive, progress.DummyProgress())
577
 
                merger.check_basis(True)
578
 
                merger.merge_type = _mod_merge.Merge3Merger
579
 
                conflict_count = merger.do_merge()
580
 
                merger.set_pending()
581
 
                if conflict_count == 0:
582
 
                    self.window._merge_successful()
583
 
                else:
584
 
                    self.window._conflicts()
585
 
                    # There are conflicts to be resolved.
586
 
                self.window.destroy()
587
 
            except Exception, e:
588
 
                self.window._handle_error(e)
589
 
        finally:
590
 
            tree.unlock()
591
 
 
592
 
 
593
 
def iter_changes_to_status(source, target):
594
 
    """Determine the differences between trees.
595
 
 
596
 
    This is a wrapper around iter_changes which just yields more
597
 
    understandable results.
598
 
 
599
 
    :param source: The source tree (basis tree)
600
 
    :param target: The target tree
601
 
    :return: A list of (file_id, real_path, change_type, display_path)
602
 
    """
603
 
    added = 'added'
604
 
    removed = 'removed'
605
 
    renamed = 'renamed'
606
 
    renamed_and_modified = 'renamed and modified'
607
 
    modified = 'modified'
608
 
    kind_changed = 'kind changed'
609
 
 
610
 
    # TODO: Handle metadata changes
611
 
 
612
 
    status = []
613
 
    target.lock_read()
614
 
    try:
615
 
        source.lock_read()
616
 
        try:
617
 
            for (file_id, paths, changed_content, versioned, parent_ids, names,
618
 
                 kinds, executables) in target.iter_changes(source):
619
 
 
620
 
                # Skip the root entry if it isn't very interesting
621
 
                if parent_ids == (None, None):
622
 
                    continue
623
 
 
624
 
                change_type = None
625
 
                if kinds[0] is None:
626
 
                    source_marker = ''
627
 
                else:
628
 
                    source_marker = osutils.kind_marker(kinds[0])
629
 
                if kinds[1] is None:
630
 
                    assert kinds[0] is not None
631
 
                    marker = osutils.kind_marker(kinds[0])
632
 
                else:
633
 
                    marker = osutils.kind_marker(kinds[1])
634
 
 
635
 
                real_path = paths[1]
636
 
                if real_path is None:
637
 
                    real_path = paths[0]
638
 
                assert real_path is not None
639
 
                display_path = real_path + marker
640
 
 
641
 
                present_source = versioned[0] and kinds[0] is not None
642
 
                present_target = versioned[1] and kinds[1] is not None
643
 
 
644
 
                if present_source != present_target:
645
 
                    if present_target:
646
 
                        change_type = added
647
 
                    else:
648
 
                        assert present_source
649
 
                        change_type = removed
650
 
                elif names[0] != names[1] or parent_ids[0] != parent_ids[1]:
651
 
                    # Renamed
652
 
                    if changed_content or executables[0] != executables[1]:
653
 
                        # and modified
654
 
                        change_type = renamed_and_modified
655
 
                    else:
656
 
                        change_type = renamed
657
 
                    display_path = (paths[0] + source_marker
658
 
                                    + ' => ' + paths[1] + marker)
659
 
                elif kinds[0] != kinds[1]:
660
 
                    change_type = kind_changed
661
 
                    display_path = (paths[0] + source_marker
662
 
                                    + ' => ' + paths[1] + marker)
663
 
                elif changed_content is True or executables[0] != executables[1]:
664
 
                    change_type = modified
665
 
                else:
666
 
                    assert False, "How did we get here?"
667
 
 
668
 
                status.append((file_id, real_path, change_type, display_path))
669
 
        finally:
670
 
            source.unlock()
671
 
    finally:
672
 
        target.unlock()
673
 
 
674
 
    return status
 
338
        self.diff_win.show_diff(specific_files)