/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: 2012-03-23 12:56:39 UTC
  • Revision ID: jelmer@samba.org-20120323125639-z3qgalx8qodxr2zw
bzr-handle-patch: Use spaces rather than tabs for indentation.

Show diffs side-by-side

added added

removed removed

Lines of Context:
commit.py
16
16
 
17
17
import re
18
18
 
 
19
from gi.repository import Gdk
19
20
from gi.repository import Gtk
20
21
from gi.repository import GObject
21
22
from gi.repository import Pango
22
23
 
23
24
from bzrlib import (
 
25
    bencode,
24
26
    errors,
25
27
    osutils,
 
28
    revision as _mod_revision,
26
29
    trace,
 
30
    tsort,
27
31
    )
28
 
try:
29
 
    from bzrlib import bencode
30
 
except ImportError:
31
 
    from bzrlib.util import bencode
32
 
 
33
32
from bzrlib.plugins.gtk.dialog import question_dialog
 
33
from bzrlib.plugins.gtk.diff import DiffView
34
34
from bzrlib.plugins.gtk.errors import show_bzr_error
35
35
from bzrlib.plugins.gtk.i18n import _i18n
 
36
from bzrlib.plugins.gtk.commitmsgs import SavedCommitMessagesManager
36
37
 
37
38
try:
38
39
    import dbus
42
43
    have_dbus = False
43
44
 
44
45
 
 
46
def _get_sorted_revisions(tip_revision, revision_ids, parent_map):
 
47
    """Get an iterator which will return the revisions in merge sorted order.
 
48
 
 
49
    This will build up a list of all nodes, such that only nodes in the list
 
50
    are referenced. It then uses MergeSorter to return them in 'merge-sorted'
 
51
    order.
 
52
 
 
53
    :param revision_ids: A set of revision_ids
 
54
    :param parent_map: The parent information for each node. Revisions which
 
55
        are considered ghosts should not be present in the map.
 
56
    :return: iterator from MergeSorter.iter_topo_order()
 
57
    """
 
58
    # MergeSorter requires that all nodes be present in the graph, so get rid
 
59
    # of any references pointing outside of this graph.
 
60
    parent_graph = {}
 
61
    for revision_id in revision_ids:
 
62
        if revision_id not in parent_map: # ghost
 
63
            parent_graph[revision_id] = []
 
64
        else:
 
65
            # Only include parents which are in this sub-graph
 
66
            parent_graph[revision_id] = [p for p in parent_map[revision_id]
 
67
                                            if p in revision_ids]
 
68
    sorter = tsort.MergeSorter(parent_graph, tip_revision)
 
69
    return sorter.iter_topo_order()
 
70
 
 
71
 
45
72
def pending_revisions(wt):
46
73
    """Return a list of pending merges or None if there are none of them.
47
74
 
52
79
    """
53
80
    parents = wt.get_parent_ids()
54
81
    if len(parents) < 2:
55
 
        return None
 
82
        return
56
83
 
57
84
    # The basic pending merge algorithm uses the same algorithm as
58
85
    # bzrlib.status.show_pending_merges
60
87
    branch = wt.branch
61
88
    last_revision = parents[0]
62
89
 
63
 
    if last_revision is not None:
64
 
        try:
65
 
            ignore = set(branch.repository.get_ancestry(last_revision,
66
 
                                                        topo_sorted=False))
67
 
        except errors.NoSuchRevision:
68
 
            # the last revision is a ghost : assume everything is new
69
 
            # except for it
70
 
            ignore = set([None, last_revision])
71
 
    else:
72
 
        ignore = set([None])
 
90
    graph = branch.repository.get_graph()
 
91
    other_revisions = [last_revision]
73
92
 
74
93
    pm = []
75
94
    for merge in pending:
76
 
        ignore.add(merge)
77
 
        try:
78
 
            rev = branch.repository.get_revision(merge)
79
 
            children = []
80
 
            pm.append((rev, children))
81
 
 
82
 
            # This does need to be topo sorted, so we search backwards
83
 
            inner_merges = branch.repository.get_ancestry(merge)
84
 
            assert inner_merges[0] is None
85
 
            inner_merges.pop(0)
86
 
            for mmerge in reversed(inner_merges):
87
 
                if mmerge in ignore:
88
 
                    continue
89
 
                rev = branch.repository.get_revision(mmerge)
90
 
                children.append(rev)
91
 
 
92
 
                ignore.add(mmerge)
93
 
        except errors.NoSuchRevision:
94
 
            print "DEBUG: NoSuchRevision:", merge
95
 
 
96
 
    return pm
 
95
        try:
 
96
            merge_rev = branch.repository.get_revision(merge)
 
97
        except errors.NoSuchRevision:
 
98
            # If we are missing a revision, just print out the revision id
 
99
            trace.mutter("ghost: %r", merge)
 
100
            other_revisions.append(merge)
 
101
            continue
 
102
 
 
103
        # Find all of the revisions in the merge source, which are not in the
 
104
        # last committed revision.
 
105
        merge_extra = graph.find_unique_ancestors(merge, other_revisions)
 
106
        other_revisions.append(merge)
 
107
        merge_extra.discard(_mod_revision.NULL_REVISION)
 
108
 
 
109
        # Get a handle to all of the revisions we will need
 
110
        try:
 
111
            revisions = dict((rev.revision_id, rev) for rev in
 
112
                             branch.repository.get_revisions(merge_extra))
 
113
        except errors.NoSuchRevision:
 
114
            # One of the sub nodes is a ghost, check each one
 
115
            revisions = {}
 
116
            for revision_id in merge_extra:
 
117
                try:
 
118
                    rev = branch.repository.get_revisions([revision_id])[0]
 
119
                except errors.NoSuchRevision:
 
120
                    revisions[revision_id] = None
 
121
                else:
 
122
                    revisions[revision_id] = rev
 
123
 
 
124
         # Display the revisions brought in by this merge.
 
125
        rev_id_iterator = _get_sorted_revisions(merge, merge_extra,
 
126
                            branch.repository.get_parent_map(merge_extra))
 
127
        # Skip the first node
 
128
        num, first, depth, eom = rev_id_iterator.next()
 
129
        if first != merge:
 
130
            raise AssertionError('Somehow we misunderstood how'
 
131
                ' iter_topo_order works %s != %s' % (first, merge))
 
132
        children = []
 
133
        for num, sub_merge, depth, eom in rev_id_iterator:
 
134
            rev = revisions[sub_merge]
 
135
            if rev is None:
 
136
                trace.warning("ghost: %r", sub_merge)
 
137
                continue
 
138
            children.append(rev)
 
139
        yield (merge_rev, children)
97
140
 
98
141
 
99
142
_newline_variants_re = re.compile(r'\r\n?')
100
143
def _sanitize_and_decode_message(utf8_message):
101
144
    """Turn a utf-8 message into a sanitized Unicode message."""
102
145
    fixed_newline = _newline_variants_re.sub('\n', utf8_message)
103
 
    return fixed_newline.decode('utf-8')
 
146
    return osutils.safe_unicode(fixed_newline)
104
147
 
105
148
 
106
149
class CommitDialog(Gtk.Dialog):
107
150
    """Implementation of Commit."""
108
151
 
109
152
    def __init__(self, wt, selected=None, parent=None):
110
 
        GObject.GObject.__init__(self, title="Commit to %s" % wt.basedir,
111
 
                            parent=parent, flags=0,)
 
153
        super(CommitDialog, self).__init__(
 
154
            title="Commit to %s" % wt.basedir, parent=parent, flags=0)
112
155
        self.connect('delete-event', self._on_delete_window)
113
156
        self._question_dialog = question_dialog
114
157
 
121
164
        self._enable_per_file_commits = True
122
165
        self._commit_all_changes = True
123
166
        self.committed_revision_id = None # Nothing has been committed yet
124
 
        self._saved_commit_messages_manager = SavedCommitMessagesManager(self._wt, self._wt.branch)
 
167
        self._last_selected_file = None
 
168
        self._saved_commit_messages_manager = SavedCommitMessagesManager(
 
169
            self._wt, self._wt.branch)
125
170
 
126
171
        self.setup_params()
127
172
        self.construct()
131
176
        """Setup the member variables for state."""
132
177
        self._basis_tree = self._wt.basis_tree()
133
178
        self._delta = None
134
 
        self._pending = pending_revisions(self._wt)
 
179
        self._wt.lock_read()
 
180
        try:
 
181
            self._pending = list(pending_revisions(self._wt))
 
182
        finally:
 
183
            self._wt.unlock()
135
184
 
136
185
        self._is_checkout = (self._wt.branch.get_bound_location() is not None)
137
186
 
189
238
 
190
239
        all_enabled = (self._selected is None)
191
240
        # The first entry is always the 'whole tree'
192
 
        all_iter = store.append([None, None, all_enabled, 'All Files', '', ''])
 
241
        all_iter = store.append(["", "", all_enabled, 'All Files', '', ''])
193
242
        initial_cursor = store.get_path(all_iter)
194
243
        # should we pass specific_files?
195
244
        self._wt.lock_read()
226
275
        # This sets the cursor, which causes the expander to close, which
227
276
        # causes the _file_message_text_view to never get realized. So we have
228
277
        # to give it a little kick, or it warns when we try to grab the focus
229
 
        self._treeview_files.set_cursor(initial_cursor)
 
278
        self._treeview_files.set_cursor(initial_cursor, None, False)
230
279
 
231
280
        def _realize_file_message_tree_view(*args):
232
281
            self._file_message_text_view.realize()
240
289
            self._check_local.hide()
241
290
            return
242
291
        if have_dbus:
243
 
            bus = dbus.SystemBus()
 
292
            try:
 
293
                bus = dbus.SystemBus()
 
294
            except dbus.DBusException:
 
295
                trace.mutter("DBus system bus not available")
 
296
                self._check_local.show()
 
297
                return
244
298
            try:
245
299
                proxy_obj = bus.get_object('org.freedesktop.NetworkManager',
246
300
                                           '/org/freedesktop/NetworkManager')
248
302
                trace.mutter("networkmanager not available.")
249
303
                self._check_local.show()
250
304
                return
251
 
            
 
305
 
252
306
            dbus_iface = dbus.Interface(proxy_obj,
253
307
                                        'org.freedesktop.NetworkManager')
254
308
            try:
280
334
        """Build up the dialog widgets."""
281
335
        # The primary pane which splits it into left and right (adjustable)
282
336
        # sections.
283
 
        self._hpane = Gtk.HPaned()
 
337
        self._hpane = Gtk.Paned.new(Gtk.Orientation.HORIZONTAL)
284
338
 
285
339
        self._construct_left_pane()
286
340
        self._construct_right_pane()
287
341
        self._construct_action_pane()
288
342
 
289
 
        self.vbox.pack_start(self._hpane, True, True, 0)
 
343
        self.get_content_area().pack_start(self._hpane, True, True, 0)
290
344
        self._hpane.show()
291
345
        self.set_focus(self._global_message_text_view)
292
346
 
312
366
 
313
367
    def _construct_accelerators(self):
314
368
        group = Gtk.AccelGroup()
315
 
        group.connect_group(Gdk.keyval_from_name('N'),
316
 
                            Gdk.EventMask.CONTROL_MASK, 0, self._on_accel_next)
 
369
        group.connect(Gdk.keyval_from_name('N'),
 
370
                      Gdk.ModifierType.CONTROL_MASK, 0, self._on_accel_next)
317
371
        self.add_accel_group(group)
318
372
 
319
373
        # ignore the escape key (avoid closing the window)
326
380
 
327
381
        self._check_local = Gtk.CheckButton(_i18n("_Only commit locally"),
328
382
                                            use_underline=True)
329
 
        self._left_pane_box.pack_end(self._check_local, False, False)
 
383
        self._left_pane_box.pack_end(self._check_local, False, False, 0)
330
384
        self._check_local.set_active(False)
331
385
 
332
386
        self._hpane.pack1(self._left_pane_box, resize=False, shrink=False)
354
408
        self._button_cancel = Gtk.Button(stock=Gtk.STOCK_CANCEL)
355
409
        self._button_cancel.connect('clicked', self._on_cancel_clicked)
356
410
        self._button_cancel.show()
357
 
        self.action_area.pack_end(self._button_cancel)
 
411
        self.get_action_area().pack_end(
 
412
            self._button_cancel, True, True, 0)
358
413
        self._button_commit = Gtk.Button(_i18n("Comm_it"), use_underline=True)
359
414
        self._button_commit.connect('clicked', self._on_commit_clicked)
360
415
        self._button_commit.set_can_default(True)
361
416
        self._button_commit.show()
362
 
        self.action_area.pack_end(self._button_commit)
 
417
        self.get_action_area().pack_end(
 
418
            self._button_commit, True, True, 0)
363
419
        self._button_commit.grab_default()
364
420
 
365
421
    def _add_to_right_table(self, widget, weight, expanding=False):
385
441
        # file_label.show()
386
442
        self._files_box.pack_start(file_label, False, True, 0)
387
443
 
388
 
        self._commit_all_files_radio = Gtk.RadioButton(
 
444
        self._commit_all_files_radio = Gtk.RadioButton.new_with_label(
389
445
            None, _i18n("Commit all changes"))
390
446
        self._files_box.pack_start(self._commit_all_files_radio, False, True, 0)
391
447
        self._commit_all_files_radio.show()
392
448
        self._commit_all_files_radio.connect('toggled',
393
449
            self._toggle_commit_selection)
394
 
        self._commit_selected_radio = Gtk.RadioButton(
 
450
        self._commit_selected_radio = Gtk.RadioButton.new_with_label_from_widget(
395
451
            self._commit_all_files_radio, _i18n("Only commit selected changes"))
396
452
        self._files_box.pack_start(self._commit_selected_radio, False, True, 0)
397
453
        self._commit_selected_radio.show()
409
465
        scroller.add(self._treeview_files)
410
466
        scroller.set_shadow_type(Gtk.ShadowType.IN)
411
467
        scroller.show()
412
 
        self._files_box.pack_start(scroller,
413
 
                                   expand=True, fill=True)
 
468
        self._files_box.pack_start(scroller, True, True, 0)
414
469
        self._files_box.show()
415
470
        self._left_pane_box.pack_start(self._files_box, True, True, 0)
416
471
 
445
500
                                     self._on_treeview_files_cursor_changed)
446
501
 
447
502
    def _toggle_commit(self, cell, path, model):
448
 
        if model[path][0] is None: # No file_id means 'All Files'
 
503
        if model[path][0] == "": # No file_id means 'All Files'
449
504
            new_val = not model[path][2]
450
505
            for node in model:
451
506
                node[2] = new_val
461
516
                checked_col.set_visible(False)
462
517
            else:
463
518
                checked_col.set_visible(True)
464
 
            renderer = checked_col.get_cell_renderers()[0]
 
519
            renderer = checked_col.get_cells()[0]
465
520
            renderer.set_property('activatable', not all_files)
466
521
 
467
522
    def _construct_pending_list(self):
473
528
        pending_message = Gtk.Label()
474
529
        pending_message.set_markup(
475
530
            _i18n('<i>* Cannot select specific files when merging</i>'))
476
 
        self._pending_box.pack_start(pending_message, expand=False, padding=5)
 
531
        self._pending_box.pack_start(pending_message, False, True, 5)
477
532
        pending_message.show()
478
533
 
479
534
        pending_label = Gtk.Label(label=_i18n('Pending Revisions'))
480
 
        self._pending_box.pack_start(pending_label, expand=False, padding=0)
 
535
        self._pending_box.pack_start(pending_label, False, True, 0)
481
536
        pending_label.show()
482
537
 
483
538
        scroller = Gtk.ScrolledWindow()
486
541
        scroller.add(self._treeview_pending)
487
542
        scroller.set_shadow_type(Gtk.ShadowType.IN)
488
543
        scroller.show()
489
 
        self._pending_box.pack_start(scroller,
490
 
                                     expand=True, fill=True, padding=5)
 
544
        self._pending_box.pack_start(scroller, True, True, 5)
491
545
        self._treeview_pending.show()
492
546
        self._left_pane_box.pack_start(self._pending_box, True, True, 0)
493
547
 
506
560
                                             Gtk.CellRendererText(), text=3))
507
561
 
508
562
    def _construct_diff_view(self):
509
 
        from bzrlib.plugins.gtk.diff import DiffView
510
 
 
511
563
        # TODO: jam 2007-10-30 The diff label is currently disabled. If we
512
564
        #       decide that we really don't ever want to display it, we should
513
565
        #       actually remove it, and other references to it, along with the
522
574
        self._add_to_right_table(self._diff_view, 4, True)
523
575
        self._diff_view.show()
524
576
 
 
577
    @staticmethod
 
578
    def get_line_height(widget):
 
579
        pango_layout = widget.create_pango_layout("X");
 
580
        ink_rectangle, logical_rectangle = pango_layout.get_pixel_extents()
 
581
        return logical_rectangle.height
 
582
 
525
583
    def _construct_file_message(self):
526
584
        scroller = Gtk.ScrolledWindow()
527
585
        scroller.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
534
592
        self._file_message_text_view.modify_font(Pango.FontDescription("Monospace"))
535
593
        self._file_message_text_view.set_wrap_mode(Gtk.WrapMode.WORD)
536
594
        self._file_message_text_view.set_accepts_tab(False)
 
595
        line_height = self.get_line_height(self._file_message_text_view)
 
596
        self._file_message_text_view.set_size_request(-1, line_height * 2)
537
597
        self._file_message_text_view.show()
538
598
 
539
 
        self._file_message_expander = Gtk.Expander(_i18n('File commit message'))
 
599
        self._file_message_expander = Gtk.Expander(
 
600
            label=_i18n('File commit message'))
540
601
        self._file_message_expander.set_expanded(True)
541
602
        self._file_message_expander.add(scroller)
542
603
        self._add_to_right_table(self._file_message_expander, 1, False)
568
629
 
569
630
    def _on_treeview_files_cursor_changed(self, treeview):
570
631
        treeselection = treeview.get_selection()
 
632
        if treeselection is None:
 
633
            # The treeview was probably destroyed as the dialog closes.
 
634
            return
571
635
        (model, selection) = treeselection.get_selected()
572
636
 
573
637
        if selection is not None:
574
638
            path, display_path = model.get(selection, 1, 3)
575
639
            self._diff_label.set_text(_i18n('Diff for ') + display_path)
576
 
            if path is None:
 
640
            if path == "":
577
641
                self._diff_view.show_diff(None)
578
642
            else:
579
 
                self._diff_view.show_diff([path.decode('UTF-8')])
 
643
                self._diff_view.show_diff([osutils.safe_unicode(path)])
580
644
            self._update_per_file_info(selection)
581
645
 
582
646
    def _on_accel_next(self, accel_group, window, keyval, modifier):
593
657
            # We have either made it to the end of the list, or nothing was
594
658
            # selected. Either way, select All Files, and jump to the global
595
659
            # commit message.
596
 
            self._treeview_files.set_cursor((0,))
 
660
            self._treeview_files.set_cursor(
 
661
                Gtk.TreePath(path=0), "", False)
597
662
            self._global_message_text_view.grab_focus()
598
663
        else:
599
664
            # Set the cursor to this entry, and jump to the per-file commit
600
665
            # message
601
 
            self._treeview_files.set_cursor(model.get_path(next))
 
666
            self._treeview_files.set_cursor(model.get_path(next), None, False)
602
667
            self._file_message_text_view.grab_focus()
603
668
 
604
669
    def _save_current_file_message(self):
606
671
            return # Nothing to save
607
672
        text_buffer = self._file_message_text_view.get_buffer()
608
673
        cur_text = text_buffer.get_text(text_buffer.get_start_iter(),
609
 
                                        text_buffer.get_end_iter())
 
674
                                        text_buffer.get_end_iter(), True)
610
675
        last_selected = self._files_store.get_iter(self._last_selected_file)
611
676
        self._files_store.set_value(last_selected, 5, cur_text)
612
677
 
618
683
        self._save_current_file_message()
619
684
        text_buffer = self._file_message_text_view.get_buffer()
620
685
        file_id, display_path, message = self._files_store.get(selection, 0, 3, 5)
621
 
        if file_id is None: # Whole tree
 
686
        if file_id == "": # Whole tree
622
687
            self._file_message_expander.set_label(_i18n('File commit message'))
623
688
            self._file_message_expander.set_expanded(False)
624
689
            self._file_message_expander.set_sensitive(False)
641
706
        files = []
642
707
        records = iter(self._files_store)
643
708
        rec = records.next() # Skip the All Files record
644
 
        assert rec[0] is None, "Are we skipping the wrong record?"
 
709
        assert rec[0] == "", "Are we skipping the wrong record?"
645
710
 
646
711
        file_info = []
647
712
        for record in records:
648
713
            if self._commit_all_changes or record[2]:# [2] checkbox
649
 
                file_id = record[0] # [0] file_id
650
 
                path = record[1]    # [1] real path
 
714
                file_id = osutils.safe_utf8(record[0]) # [0] file_id
 
715
                path = osutils.safe_utf8(record[1])    # [1] real path
651
716
                # [5] commit message
652
717
                file_message = _sanitize_and_decode_message(record[5])
653
718
                files.append(path.decode('UTF-8'))
760
825
    def _get_global_commit_message(self):
761
826
        buf = self._global_message_text_view.get_buffer()
762
827
        start, end = buf.get_bounds()
763
 
        text = buf.get_text(start, end)
 
828
        text = buf.get_text(start, end, True)
764
829
        return _sanitize_and_decode_message(text)
765
830
 
766
831
    def _set_global_commit_message(self, message):
789
854
        rev_dict['revision_id'] = rev.revision_id
790
855
        return rev_dict
791
856
 
792
 
 
793
 
class SavedCommitMessagesManager:
794
 
    """Save glogal and per-file commit messages.
795
 
 
796
 
    Saves global commit message and utf-8 file_id->message dictionary
797
 
    of per-file commit messages on disk. Re-reads them later for re-using.
798
 
    """
799
 
 
800
 
    def __init__(self, tree=None, branch=None):
801
 
        """If branch is None, builds empty messages, otherwise reads them
802
 
        from branch's disk storage. 'tree' argument is for the future."""
803
 
        if branch is None:
804
 
            self.global_message = u''
805
 
            self.file_messages = {}
806
 
        else:
807
 
            config = branch.get_config()
808
 
            self.global_message = config.get_user_option(
809
 
                'gtk_global_commit_message')
810
 
            if self.global_message is None:
811
 
                self.global_message = u''
812
 
            file_messages = config.get_user_option('gtk_file_commit_messages')
813
 
            if file_messages: # unicode and B-encoded:
814
 
                self.file_messages = bencode.bdecode(
815
 
                    file_messages.encode('UTF-8'))
816
 
            else:
817
 
                self.file_messages = {}
818
 
 
819
 
    def get(self):
820
 
        return self.global_message, self.file_messages
821
 
 
822
 
    def is_not_empty(self):
823
 
        return bool(self.global_message or self.file_messages)
824
 
 
825
 
    def insert(self, global_message, file_info):
826
 
        """Formats per-file commit messages (list of dictionaries, one per file)
827
 
        into one utf-8 file_id->message dictionary and merges this with
828
 
        previously existing dictionary. Merges global commit message too."""
829
 
        file_messages = {}
830
 
        for fi in file_info:
831
 
            file_message = fi['message']
832
 
            if file_message:
833
 
                file_messages[fi['file_id']] = file_message # utf-8 strings
834
 
        for k,v in file_messages.iteritems():
835
 
            try:
836
 
                self.file_messages[k] = v + '\n******\n' + self.file_messages[k]
837
 
            except KeyError:
838
 
                self.file_messages[k] = v
839
 
        if self.global_message:
840
 
            self.global_message = global_message + '\n******\n' \
841
 
                + self.global_message
842
 
        else:
843
 
            self.global_message = global_message
844
 
 
845
 
    def save(self, tree, branch):
846
 
        # We store in branch's config, which can be a problem if two gcommit
847
 
        # are done in two checkouts of one single branch (comments overwrite
848
 
        # each other). Ideally should be in working tree. But uncommit does
849
 
        # not always have a working tree, though it always has a branch.
850
 
        # 'tree' argument is for the future
851
 
        config = branch.get_config()
852
 
        # should it be named "gtk_" or some more neutral name ("gui_" ?) to
853
 
        # be compatible with qbzr in the future?
854
 
        config.set_user_option('gtk_global_commit_message', self.global_message)
855
 
        # bencode() does not know unicode objects but set_user_option()
856
 
        # requires one:
857
 
        config.set_user_option(
858
 
            'gtk_file_commit_messages',
859
 
            bencode.bencode(self.file_messages).decode('UTF-8'))
860
 
 
861
 
 
862
 
def save_commit_messages(local, master, old_revno, old_revid,
863
 
                         new_revno, new_revid):
864
 
    b = local
865
 
    if b is None:
866
 
        b = master
867
 
    mgr = SavedCommitMessagesManager(None, b)
868
 
    revid_iterator = b.repository.iter_reverse_revision_history(old_revid)
869
 
    cur_revno = old_revno
870
 
    new_revision_id = old_revid
871
 
    graph = b.repository.get_graph()
872
 
    for rev_id in revid_iterator:
873
 
        if cur_revno == new_revno:
874
 
            break
875
 
        cur_revno -= 1
876
 
        rev = b.repository.get_revision(rev_id)
877
 
        file_info = rev.properties.get('file-info', None)
878
 
        if file_info is None:
879
 
            file_info = {}
880
 
        else:
881
 
            file_info = bencode.bdecode(file_info.encode('UTF-8'))
882
 
        global_message = osutils.safe_unicode(rev.message)
883
 
        # Concatenate comment of the uncommitted revision
884
 
        mgr.insert(global_message, file_info)
885
 
 
886
 
        parents = graph.get_parent_map([rev_id]).get(rev_id, None)
887
 
        if not parents:
888
 
            continue
889
 
    mgr.save(None, b)