/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 commit.py

  • Committer: Jelmer Vernooij
  • Date: 2011-11-02 11:11:06 UTC
  • mfrom: (734.1.55 gtk3)
  • Revision ID: jelmer@samba.org-20111102111106-7l0vso8eg24dpf87
Merge gtk3 support from Curtis.

Show diffs side-by-side

added added

removed removed

Lines of Context:
commit.py
16
16
 
17
17
import re
18
18
 
19
 
try:
20
 
    import pygtk
21
 
    pygtk.require("2.0")
22
 
except:
23
 
    pass
24
 
 
25
 
import gtk
26
 
import gobject
27
 
import pango
 
19
from gi.repository import Gdk
 
20
from gi.repository import Gtk
 
21
from gi.repository import GObject
 
22
from gi.repository import Pango
28
23
 
29
24
from bzrlib import (
30
25
    errors,
109
104
    return fixed_newline.decode('utf-8')
110
105
 
111
106
 
112
 
class CommitDialog(gtk.Dialog):
 
107
class CommitDialog(Gtk.Dialog):
113
108
    """Implementation of Commit."""
114
109
 
115
110
    def __init__(self, wt, selected=None, parent=None):
116
 
        gtk.Dialog.__init__(self, title="Commit to %s" % wt.basedir,
117
 
                            parent=parent, flags=0,)
 
111
        super(CommitDialog, self).__init__(
 
112
            title="Commit to %s" % wt.basedir, parent=parent, flags=0)
118
113
        self.connect('delete-event', self._on_delete_window)
119
114
        self._question_dialog = question_dialog
120
115
 
121
 
        self.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_NORMAL)
 
116
        self.set_type_hint(Gdk.WindowTypeHint.NORMAL)
122
117
 
123
118
        self._wt = wt
124
119
        # TODO: Do something with this value, it is used by Olive
127
122
        self._enable_per_file_commits = True
128
123
        self._commit_all_changes = True
129
124
        self.committed_revision_id = None # Nothing has been committed yet
130
 
        self._saved_commit_messages_manager = SavedCommitMessagesManager(self._wt, self._wt.branch)
 
125
        self._saved_commit_messages_manager = SavedCommitMessagesManager(
 
126
            self._wt, self._wt.branch)
131
127
 
132
128
        self.setup_params()
133
129
        self.construct()
232
228
        # This sets the cursor, which causes the expander to close, which
233
229
        # causes the _file_message_text_view to never get realized. So we have
234
230
        # to give it a little kick, or it warns when we try to grab the focus
235
 
        self._treeview_files.set_cursor(initial_cursor)
 
231
        self._treeview_files.set_cursor(initial_cursor, None, False)
236
232
 
237
233
        def _realize_file_message_tree_view(*args):
238
234
            self._file_message_text_view.realize()
286
282
        """Build up the dialog widgets."""
287
283
        # The primary pane which splits it into left and right (adjustable)
288
284
        # sections.
289
 
        self._hpane = gtk.HPaned()
 
285
        self._hpane = Gtk.HPaned()
290
286
 
291
287
        self._construct_left_pane()
292
288
        self._construct_right_pane()
293
289
        self._construct_action_pane()
294
290
 
295
 
        self.vbox.pack_start(self._hpane)
 
291
        self.get_content_area().pack_start(self._hpane, True, True, 0)
296
292
        self._hpane.show()
297
293
        self.set_focus(self._global_message_text_view)
298
294
 
317
313
        self._hpane.set_position(300)
318
314
 
319
315
    def _construct_accelerators(self):
320
 
        group = gtk.AccelGroup()
321
 
        group.connect_group(gtk.gdk.keyval_from_name('N'),
322
 
                            gtk.gdk.CONTROL_MASK, 0, self._on_accel_next)
 
316
        group = Gtk.AccelGroup()
 
317
        group.connect(Gdk.keyval_from_name('N'),
 
318
                      Gdk.ModifierType.CONTROL_MASK, 0, self._on_accel_next)
323
319
        self.add_accel_group(group)
324
320
 
325
321
        # ignore the escape key (avoid closing the window)
326
322
        self.connect_object('close', self.emit_stop_by_name, 'close')
327
323
 
328
324
    def _construct_left_pane(self):
329
 
        self._left_pane_box = gtk.VBox(homogeneous=False, spacing=5)
 
325
        self._left_pane_box = Gtk.VBox(homogeneous=False, spacing=5)
330
326
        self._construct_file_list()
331
327
        self._construct_pending_list()
332
328
 
333
 
        self._check_local = gtk.CheckButton(_i18n("_Only commit locally"),
 
329
        self._check_local = Gtk.CheckButton(_i18n("_Only commit locally"),
334
330
                                            use_underline=True)
335
 
        self._left_pane_box.pack_end(self._check_local, False, False)
 
331
        self._left_pane_box.pack_end(self._check_local, False, False, 0)
336
332
        self._check_local.set_active(False)
337
333
 
338
334
        self._hpane.pack1(self._left_pane_box, resize=False, shrink=False)
345
341
        # commit, and 1 for file commit, and it looked good. But I don't seem
346
342
        # to have a way to do that with the gtk boxes... :( (Which is extra
347
343
        # weird since wx uses gtk on Linux...)
348
 
        self._right_pane_table = gtk.Table(rows=10, columns=1, homogeneous=False)
 
344
        self._right_pane_table = Gtk.Table(rows=10, columns=1, homogeneous=False)
349
345
        self._right_pane_table.set_row_spacings(5)
350
346
        self._right_pane_table.set_col_spacings(5)
351
347
        self._right_pane_table_row = 0
357
353
        self._hpane.pack2(self._right_pane_table, resize=True, shrink=True)
358
354
 
359
355
    def _construct_action_pane(self):
360
 
        self._button_cancel = gtk.Button(stock=gtk.STOCK_CANCEL)
 
356
        self._button_cancel = Gtk.Button(stock=Gtk.STOCK_CANCEL)
361
357
        self._button_cancel.connect('clicked', self._on_cancel_clicked)
362
358
        self._button_cancel.show()
363
 
        self.action_area.pack_end(self._button_cancel)
364
 
        self._button_commit = gtk.Button(_i18n("Comm_it"), use_underline=True)
 
359
        self.get_action_area().pack_end(
 
360
            self._button_cancel, True, True, 0)
 
361
        self._button_commit = Gtk.Button(_i18n("Comm_it"), use_underline=True)
365
362
        self._button_commit.connect('clicked', self._on_commit_clicked)
366
 
        self._button_commit.set_flags(gtk.CAN_DEFAULT)
 
363
        self._button_commit.set_can_default(True)
367
364
        self._button_commit.show()
368
 
        self.action_area.pack_end(self._button_commit)
 
365
        self.get_action_area().pack_end(
 
366
            self._button_commit, True, True, 0)
369
367
        self._button_commit.grab_default()
370
368
 
371
369
    def _add_to_right_table(self, widget, weight, expanding=False):
377
375
        """
378
376
        end_row = self._right_pane_table_row + weight
379
377
        options = 0
380
 
        expand_opts = gtk.EXPAND | gtk.FILL | gtk.SHRINK
 
378
        expand_opts = Gtk.AttachOptions.EXPAND | Gtk.AttachOptions.FILL | Gtk.AttachOptions.SHRINK
381
379
        if expanding:
382
380
            options = expand_opts
383
381
        self._right_pane_table.attach(widget, 0, 1,
386
384
        self._right_pane_table_row = end_row
387
385
 
388
386
    def _construct_file_list(self):
389
 
        self._files_box = gtk.VBox(homogeneous=False, spacing=0)
390
 
        file_label = gtk.Label(_i18n('Files'))
 
387
        self._files_box = Gtk.VBox(homogeneous=False, spacing=0)
 
388
        file_label = Gtk.Label(label=_i18n('Files'))
391
389
        # file_label.show()
392
 
        self._files_box.pack_start(file_label, expand=False)
 
390
        self._files_box.pack_start(file_label, False, True, 0)
393
391
 
394
 
        self._commit_all_files_radio = gtk.RadioButton(
 
392
        self._commit_all_files_radio = Gtk.RadioButton.new_with_label(
395
393
            None, _i18n("Commit all changes"))
396
 
        self._files_box.pack_start(self._commit_all_files_radio, expand=False)
 
394
        self._files_box.pack_start(self._commit_all_files_radio, False, True, 0)
397
395
        self._commit_all_files_radio.show()
398
396
        self._commit_all_files_radio.connect('toggled',
399
397
            self._toggle_commit_selection)
400
 
        self._commit_selected_radio = gtk.RadioButton(
 
398
        self._commit_selected_radio = Gtk.RadioButton.new_with_label_from_widget(
401
399
            self._commit_all_files_radio, _i18n("Only commit selected changes"))
402
 
        self._files_box.pack_start(self._commit_selected_radio, expand=False)
 
400
        self._files_box.pack_start(self._commit_selected_radio, False, True, 0)
403
401
        self._commit_selected_radio.show()
404
402
        self._commit_selected_radio.connect('toggled',
405
403
            self._toggle_commit_selection)
408
406
            self._commit_all_files_radio.set_sensitive(False)
409
407
            self._commit_selected_radio.set_sensitive(False)
410
408
 
411
 
        scroller = gtk.ScrolledWindow()
412
 
        scroller.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
413
 
        self._treeview_files = gtk.TreeView()
 
409
        scroller = Gtk.ScrolledWindow()
 
410
        scroller.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
 
411
        self._treeview_files = Gtk.TreeView()
414
412
        self._treeview_files.show()
415
413
        scroller.add(self._treeview_files)
416
 
        scroller.set_shadow_type(gtk.SHADOW_IN)
 
414
        scroller.set_shadow_type(Gtk.ShadowType.IN)
417
415
        scroller.show()
418
 
        self._files_box.pack_start(scroller,
419
 
                                   expand=True, fill=True)
 
416
        self._files_box.pack_start(scroller, True, True, 0)
420
417
        self._files_box.show()
421
 
        self._left_pane_box.pack_start(self._files_box)
 
418
        self._left_pane_box.pack_start(self._files_box, True, True, 0)
422
419
 
423
420
        # Keep note that all strings stored in a ListStore must be UTF-8
424
421
        # strings. GTK does not support directly setting and restoring Unicode
425
422
        # objects.
426
 
        liststore = gtk.ListStore(
427
 
            gobject.TYPE_STRING,  # [0] file_id
428
 
            gobject.TYPE_STRING,  # [1] real path
429
 
            gobject.TYPE_BOOLEAN, # [2] checkbox
430
 
            gobject.TYPE_STRING,  # [3] display path
431
 
            gobject.TYPE_STRING,  # [4] changes type
432
 
            gobject.TYPE_STRING,  # [5] commit message
 
423
        liststore = Gtk.ListStore(
 
424
            GObject.TYPE_STRING,  # [0] file_id
 
425
            GObject.TYPE_STRING,  # [1] real path
 
426
            GObject.TYPE_BOOLEAN, # [2] checkbox
 
427
            GObject.TYPE_STRING,  # [3] display path
 
428
            GObject.TYPE_STRING,  # [4] changes type
 
429
            GObject.TYPE_STRING,  # [5] commit message
433
430
            )
434
431
        self._files_store = liststore
435
432
        self._treeview_files.set_model(liststore)
436
 
        crt = gtk.CellRendererToggle()
 
433
        crt = Gtk.CellRendererToggle()
437
434
        crt.set_property('activatable', not bool(self._pending))
438
435
        crt.connect("toggled", self._toggle_commit, self._files_store)
439
436
        if self._pending:
440
437
            name = _i18n('Commit*')
441
438
        else:
442
439
            name = _i18n('Commit')
443
 
        commit_col = gtk.TreeViewColumn(name, crt, active=2)
 
440
        commit_col = Gtk.TreeViewColumn(name, crt, active=2)
444
441
        commit_col.set_visible(False)
445
442
        self._treeview_files.append_column(commit_col)
446
 
        self._treeview_files.append_column(gtk.TreeViewColumn(_i18n('Path'),
447
 
                                           gtk.CellRendererText(), text=3))
448
 
        self._treeview_files.append_column(gtk.TreeViewColumn(_i18n('Type'),
449
 
                                           gtk.CellRendererText(), text=4))
 
443
        self._treeview_files.append_column(Gtk.TreeViewColumn(_i18n('Path'),
 
444
                                           Gtk.CellRendererText(), text=3))
 
445
        self._treeview_files.append_column(Gtk.TreeViewColumn(_i18n('Type'),
 
446
                                           Gtk.CellRendererText(), text=4))
450
447
        self._treeview_files.connect('cursor-changed',
451
448
                                     self._on_treeview_files_cursor_changed)
452
449
 
467
464
                checked_col.set_visible(False)
468
465
            else:
469
466
                checked_col.set_visible(True)
470
 
            renderer = checked_col.get_cell_renderers()[0]
 
467
            renderer = checked_col.get_cells()[0]
471
468
            renderer.set_property('activatable', not all_files)
472
469
 
473
470
    def _construct_pending_list(self):
474
471
        # Pending information defaults to hidden, we put it all in 1 box, so
475
472
        # that we can show/hide all of them at once
476
 
        self._pending_box = gtk.VBox()
 
473
        self._pending_box = Gtk.VBox()
477
474
        self._pending_box.hide()
478
475
 
479
 
        pending_message = gtk.Label()
 
476
        pending_message = Gtk.Label()
480
477
        pending_message.set_markup(
481
478
            _i18n('<i>* Cannot select specific files when merging</i>'))
482
 
        self._pending_box.pack_start(pending_message, expand=False, padding=5)
 
479
        self._pending_box.pack_start(pending_message, False, True, 5)
483
480
        pending_message.show()
484
481
 
485
 
        pending_label = gtk.Label(_i18n('Pending Revisions'))
486
 
        self._pending_box.pack_start(pending_label, expand=False, padding=0)
 
482
        pending_label = Gtk.Label(label=_i18n('Pending Revisions'))
 
483
        self._pending_box.pack_start(pending_label, False, True, 0)
487
484
        pending_label.show()
488
485
 
489
 
        scroller = gtk.ScrolledWindow()
490
 
        scroller.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
491
 
        self._treeview_pending = gtk.TreeView()
 
486
        scroller = Gtk.ScrolledWindow()
 
487
        scroller.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
 
488
        self._treeview_pending = Gtk.TreeView()
492
489
        scroller.add(self._treeview_pending)
493
 
        scroller.set_shadow_type(gtk.SHADOW_IN)
 
490
        scroller.set_shadow_type(Gtk.ShadowType.IN)
494
491
        scroller.show()
495
 
        self._pending_box.pack_start(scroller,
496
 
                                     expand=True, fill=True, padding=5)
 
492
        self._pending_box.pack_start(scroller, True, True, 5)
497
493
        self._treeview_pending.show()
498
 
        self._left_pane_box.pack_start(self._pending_box)
 
494
        self._left_pane_box.pack_start(self._pending_box, True, True, 0)
499
495
 
500
 
        liststore = gtk.ListStore(gobject.TYPE_STRING, # revision_id
501
 
                                  gobject.TYPE_STRING, # date
502
 
                                  gobject.TYPE_STRING, # committer
503
 
                                  gobject.TYPE_STRING, # summary
 
496
        liststore = Gtk.ListStore(GObject.TYPE_STRING, # revision_id
 
497
                                  GObject.TYPE_STRING, # date
 
498
                                  GObject.TYPE_STRING, # committer
 
499
                                  GObject.TYPE_STRING, # summary
504
500
                                 )
505
501
        self._pending_store = liststore
506
502
        self._treeview_pending.set_model(liststore)
507
 
        self._treeview_pending.append_column(gtk.TreeViewColumn(_i18n('Date'),
508
 
                                             gtk.CellRendererText(), text=1))
509
 
        self._treeview_pending.append_column(gtk.TreeViewColumn(_i18n('Committer'),
510
 
                                             gtk.CellRendererText(), text=2))
511
 
        self._treeview_pending.append_column(gtk.TreeViewColumn(_i18n('Summary'),
512
 
                                             gtk.CellRendererText(), text=3))
 
503
        self._treeview_pending.append_column(Gtk.TreeViewColumn(_i18n('Date'),
 
504
                                             Gtk.CellRendererText(), text=1))
 
505
        self._treeview_pending.append_column(Gtk.TreeViewColumn(_i18n('Committer'),
 
506
                                             Gtk.CellRendererText(), text=2))
 
507
        self._treeview_pending.append_column(Gtk.TreeViewColumn(_i18n('Summary'),
 
508
                                             Gtk.CellRendererText(), text=3))
513
509
 
514
510
    def _construct_diff_view(self):
515
511
        from bzrlib.plugins.gtk.diff import DiffView
518
514
        #       decide that we really don't ever want to display it, we should
519
515
        #       actually remove it, and other references to it, along with the
520
516
        #       tests that it is set properly.
521
 
        self._diff_label = gtk.Label(_i18n('Diff for whole tree'))
 
517
        self._diff_label = Gtk.Label(label=_i18n('Diff for whole tree'))
522
518
        self._diff_label.set_alignment(0, 0)
523
519
        self._right_pane_table.set_row_spacing(self._right_pane_table_row, 0)
524
520
        self._add_to_right_table(self._diff_label, 1, False)
529
525
        self._diff_view.show()
530
526
 
531
527
    def _construct_file_message(self):
532
 
        scroller = gtk.ScrolledWindow()
533
 
        scroller.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
 
528
        scroller = Gtk.ScrolledWindow()
 
529
        scroller.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
534
530
 
535
 
        self._file_message_text_view = gtk.TextView()
 
531
        self._file_message_text_view = Gtk.TextView()
536
532
        scroller.add(self._file_message_text_view)
537
 
        scroller.set_shadow_type(gtk.SHADOW_IN)
 
533
        scroller.set_shadow_type(Gtk.ShadowType.IN)
538
534
        scroller.show()
539
535
 
540
 
        self._file_message_text_view.modify_font(pango.FontDescription("Monospace"))
541
 
        self._file_message_text_view.set_wrap_mode(gtk.WRAP_WORD)
 
536
        self._file_message_text_view.modify_font(Pango.FontDescription("Monospace"))
 
537
        self._file_message_text_view.set_wrap_mode(Gtk.WrapMode.WORD)
542
538
        self._file_message_text_view.set_accepts_tab(False)
543
539
        self._file_message_text_view.show()
544
540
 
545
 
        self._file_message_expander = gtk.Expander(_i18n('File commit message'))
 
541
        self._file_message_expander = Gtk.Expander(
 
542
            label=_i18n('File commit message'))
546
543
        self._file_message_expander.set_expanded(True)
547
544
        self._file_message_expander.add(scroller)
548
545
        self._add_to_right_table(self._file_message_expander, 1, False)
549
546
        self._file_message_expander.show()
550
547
 
551
548
    def _construct_global_message(self):
552
 
        self._global_message_label = gtk.Label(_i18n('Global Commit Message'))
 
549
        self._global_message_label = Gtk.Label(label=_i18n('Global Commit Message'))
553
550
        self._global_message_label.set_markup(
554
551
            _i18n('<b>Global Commit Message</b>'))
555
552
        self._global_message_label.set_alignment(0, 0)
558
555
        # Can we remove the spacing between the label and the box?
559
556
        self._global_message_label.show()
560
557
 
561
 
        scroller = gtk.ScrolledWindow()
562
 
        scroller.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
 
558
        scroller = Gtk.ScrolledWindow()
 
559
        scroller.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
563
560
 
564
 
        self._global_message_text_view = gtk.TextView()
 
561
        self._global_message_text_view = Gtk.TextView()
565
562
        self._set_global_commit_message(self._saved_commit_messages_manager.get()[0])
566
 
        self._global_message_text_view.modify_font(pango.FontDescription("Monospace"))
 
563
        self._global_message_text_view.modify_font(Pango.FontDescription("Monospace"))
567
564
        scroller.add(self._global_message_text_view)
568
 
        scroller.set_shadow_type(gtk.SHADOW_IN)
 
565
        scroller.set_shadow_type(Gtk.ShadowType.IN)
569
566
        scroller.show()
570
567
        self._add_to_right_table(scroller, 2, True)
571
 
        self._file_message_text_view.set_wrap_mode(gtk.WRAP_WORD)
 
568
        self._file_message_text_view.set_wrap_mode(Gtk.WrapMode.WORD)
572
569
        self._file_message_text_view.set_accepts_tab(False)
573
570
        self._global_message_text_view.show()
574
571
 
599
596
            # We have either made it to the end of the list, or nothing was
600
597
            # selected. Either way, select All Files, and jump to the global
601
598
            # commit message.
602
 
            self._treeview_files.set_cursor((0,))
 
599
            self._treeview_files.set_cursor(
 
600
                Gtk.TreePath(path=0), None, False)
603
601
            self._global_message_text_view.grab_focus()
604
602
        else:
605
603
            # Set the cursor to this entry, and jump to the per-file commit
606
604
            # message
607
 
            self._treeview_files.set_cursor(model.get_path(next))
 
605
            self._treeview_files.set_cursor(model.get_path(next), None, False)
608
606
            self._file_message_text_view.grab_focus()
609
607
 
610
608
    def _save_current_file_message(self):
612
610
            return # Nothing to save
613
611
        text_buffer = self._file_message_text_view.get_buffer()
614
612
        cur_text = text_buffer.get_text(text_buffer.get_start_iter(),
615
 
                                        text_buffer.get_end_iter())
 
613
                                        text_buffer.get_end_iter(), True)
616
614
        last_selected = self._files_store.get_iter(self._last_selected_file)
617
615
        self._files_store.set_value(last_selected, 5, cur_text)
618
616
 
689
687
                _i18n('Commit cancelled'),
690
688
                _i18n('Do you want to save your commit messages ?'),
691
689
                parent=self)
692
 
            if response == gtk.RESPONSE_NO:
 
690
            if response == Gtk.ResponseType.NO:
693
691
                 # save nothing and destroy old comments if any
694
692
                mgr = SavedCommitMessagesManager()
695
693
        mgr.save(self._wt, self._wt.branch)
696
 
        self.response(gtk.RESPONSE_CANCEL) # close window
 
694
        self.response(Gtk.ResponseType.CANCEL) # close window
697
695
 
698
696
    @show_bzr_error
699
697
    def _on_commit_clicked(self, button):
708
706
                _i18n('Commit with an empty message?'),
709
707
                _i18n('You can describe your commit intent in the message.'),
710
708
                parent=self)
711
 
            if response == gtk.RESPONSE_NO:
 
709
            if response == Gtk.ResponseType.NO:
712
710
                # Kindly give focus to message area
713
711
                self._global_message_text_view.grab_focus()
714
712
                return
730
728
                _i18n("Unknown files exist in the working tree. Commit anyway?"),
731
729
                parent=self)
732
730
                # Doesn't set a parent for the dialog..
733
 
            if response == gtk.RESPONSE_NO:
 
731
            if response == Gtk.ResponseType.NO:
734
732
                return
735
733
            break
736
734
 
751
749
                _i18n('There are no changes in the working tree.'
752
750
                      ' Do you want to commit anyway?'),
753
751
                parent=self)
754
 
            if response == gtk.RESPONSE_YES:
 
752
            if response == Gtk.ResponseType.YES:
755
753
                rev_id = self._wt.commit(message,
756
754
                               allow_pointless=True,
757
755
                               strict=False,
761
759
        self.committed_revision_id = rev_id
762
760
        # destroy old comments if any
763
761
        SavedCommitMessagesManager().save(self._wt, self._wt.branch)
764
 
        self.response(gtk.RESPONSE_OK)
 
762
        self.response(Gtk.ResponseType.OK)
765
763
 
766
764
    def _get_global_commit_message(self):
767
765
        buf = self._global_message_text_view.get_buffer()
768
766
        start, end = buf.get_bounds()
769
 
        text = buf.get_text(start, end)
 
767
        text = buf.get_text(start, end, True)
770
768
        return _sanitize_and_decode_message(text)
771
769
 
772
770
    def _set_global_commit_message(self, message):