/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: Vincent Ladeuil
  • Date: 2008-06-10 15:25:47 UTC
  • mto: This revision was merged to the branch mainline in revision 504.
  • Revision ID: v.ladeuil+lp@free.fr-20080610152547-dwmil1p8pd0mfpnl
Fix third failing test (thanks to jam).

* tests/test_commit.py:
(TestPendingRevisions.test_pending_revisions_multi_merge): Fix
provided by jam: bzr we now filter the pending merges so that only
the 'heads()' are included. We just ensure that the pending merges
contain the unique tips for the ancestries.

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 osutils
 
33
from bzrlib import (
 
34
    merge as _mod_merge,
 
35
    osutils,
 
36
    progress,
 
37
    urlutils,
 
38
    workingtree,
 
39
)
34
40
from bzrlib.diff import show_diff_trees, internal_diff
35
41
from bzrlib.errors import NoSuchFile
 
42
from bzrlib.patches import parse_patches
36
43
from bzrlib.trace import warning
 
44
from bzrlib.plugins.gtk import _i18n
37
45
from bzrlib.plugins.gtk.window import Window
38
 
 
39
 
 
40
 
class DiffView(gtk.ScrolledWindow):
41
 
    """This is the soft and chewy filling for a DiffWindow."""
 
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"""
42
56
 
43
57
    def __init__(self):
44
58
        gtk.ScrolledWindow.__init__(self)
45
 
 
46
59
        self.construct()
47
 
        self.rev_tree = None
48
 
        self.parent_tree = None
 
60
        self._diffs = {}
49
61
 
50
62
    def construct(self):
51
63
        self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
134
146
 
135
147
            lang.set_tag_style(tag_id, style)
136
148
 
137
 
    @staticmethod
138
 
    def apply_colordiff_colors(lang):
 
149
    @classmethod
 
150
    def apply_colordiff_colors(klass, lang):
139
151
        """Set style colors for lang using the colordiff configuration file.
140
152
 
141
153
        Both ~/.colordiffrc and ~/.colordiffrc.bzr-gtk are read.
152
164
                except IOError, e:
153
165
                    warning('could not open file %s: %s' % (f, str(e)))
154
166
                else:
155
 
                    colors.update(DiffView.parse_colordiffrc(f))
 
167
                    colors.update(klass.parse_colordiffrc(f))
156
168
                    f.close()
157
169
 
158
170
        if not colors:
216
228
#        self.parent_tree.lock_read()
217
229
#        self.rev_tree.lock_read()
218
230
#        try:
219
 
#            self.delta = _iter_changes_to_status(self.parent_tree, self.rev_tree)
 
231
#            self.delta = iter_changes_to_status(self.parent_tree, self.rev_tree)
220
232
#            self.path_to_status = {}
221
233
#            self.path_to_diff = {}
222
234
#            source_inv = self.parent_tree.inventory
237
249
#            self.parent_tree.unlock()
238
250
 
239
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"""
240
271
        s = StringIO()
241
272
        show_diff_trees(self.parent_tree, self.rev_tree, s, specific_files,
242
273
                        old_label='', new_label='',
290
321
        column.add_attribute(cell, "text", 0)
291
322
        self.treeview.append_column(column)
292
323
 
 
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
        """
293
329
        # The diffs of the  selected file: a scrollable source or
294
330
        # 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):
 
344
        """Set the differences showed by this window.
 
345
 
 
346
        Compares the two trees and populates the window with the
 
347
        differences.
 
348
        """
295
349
        self.diff_view = DiffView()
296
350
        self.pack2(self.diff_view)
297
351
        self.diff_view.show()
298
 
 
299
 
    def set_diff(self, rev_tree, parent_tree):
300
 
        """Set the differences showed by this window.
301
 
 
302
 
        Compares the two trees and populates the window with the
303
 
        differences.
304
 
        """
305
352
        self.diff_view.set_trees(rev_tree, parent_tree)
306
353
        self.rev_tree = rev_tree
307
354
        self.parent_tree = parent_tree
335
382
        self.treeview.expand_all()
336
383
 
337
384
    def set_file(self, file_path):
 
385
        """Select the current file to display"""
338
386
        tv_path = None
339
387
        for data in self.model:
340
388
            for child in data.iterchildren():
365
413
    differences between two revisions on a branch.
366
414
    """
367
415
 
368
 
    def __init__(self, parent=None):
 
416
    def __init__(self, parent=None, operations=None):
369
417
        Window.__init__(self, parent)
370
418
        self.set_border_width(0)
371
419
        self.set_title("bzrk diff")
376
424
        width = int(monitor.width * 0.66)
377
425
        height = int(monitor.height * 0.66)
378
426
        self.set_default_size(width, height)
379
 
 
380
 
        self.construct()
381
 
 
382
 
    def construct(self):
 
427
        self.construct(operations)
 
428
 
 
429
    def construct(self, operations):
383
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)
384
437
        self.diff = DiffWidget()
385
 
        self.add(self.diff)
 
438
        self.vbox.add(self.diff)
386
439
        self.diff.show_all()
387
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
 
388
501
    def set_diff(self, description, rev_tree, parent_tree):
389
502
        """Set the differences showed by this window.
390
503
 
398
511
        self.diff.set_file(file_path)
399
512
 
400
513
 
401
 
def _iter_changes_to_status(source, target):
 
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):
402
594
    """Determine the differences between trees.
403
595
 
404
 
    This is a wrapper around _iter_changes which just yields more
 
596
    This is a wrapper around iter_changes which just yields more
405
597
    understandable results.
406
598
 
407
599
    :param source: The source tree (basis tree)
423
615
        source.lock_read()
424
616
        try:
425
617
            for (file_id, paths, changed_content, versioned, parent_ids, names,
426
 
                 kinds, executables) in target._iter_changes(source):
 
618
                 kinds, executables) in target.iter_changes(source):
427
619
 
428
620
                # Skip the root entry if it isn't very interesting
429
621
                if parent_ids == (None, None):