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

  • Committer: Jelmer Vernooij
  • Date: 2007-02-01 15:50:40 UTC
  • Revision ID: jelmer@samba.org-20070201155040-3hq4mfbxs99kzazy
add framework for tests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
olive/commit.py
 
1
# Copyright (C) 2006 by Szilveszter Farkas (Phanatic) <szilveszter.farkas@gmail.com>
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
try:
 
18
    import pygtk
 
19
    pygtk.require("2.0")
 
20
except:
 
21
    pass
 
22
 
 
23
import gtk
 
24
import gtk.glade
 
25
import gobject
 
26
import pango
 
27
 
 
28
import os.path
 
29
 
 
30
import bzrlib.errors as errors
 
31
from bzrlib import osutils
 
32
 
 
33
from dialog import error_dialog, question_dialog
 
34
from errors import show_bzr_error
 
35
from guifiles import GLADEFILENAME
 
36
 
 
37
class CommitDialog(gtk.Dialog):
 
38
    """ New implementation of the Commit dialog. """
 
39
    def __init__(self, wt, wtpath, notbranch, selected=None, parent=None):
 
40
        """ Initialize the Commit Dialog. """
 
41
        gtk.Dialog.__init__(self, title="Commit - Olive",
 
42
                                  parent=parent,
 
43
                                  flags=0,
 
44
                                  buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL))
 
45
        
 
46
        # Get arguments
 
47
        self.wt = wt
 
48
        self.wtpath = wtpath
 
49
        self.notbranch = notbranch
 
50
        self.selected = selected
 
51
        
 
52
        # Set the delta
 
53
        self.old_tree = self.wt.branch.repository.revision_tree(self.wt.branch.last_revision())
 
54
        self.delta = self.wt.changes_from(self.old_tree)
 
55
        
 
56
        # Get pending merges
 
57
        self.pending = self._pending_merges(self.wt)
 
58
        
 
59
        # Do some preliminary checks
 
60
        self._is_checkout = False
 
61
        self._is_pending = False
 
62
        if self.wt is None and not self.notbranch:
 
63
            error_dialog(_('Directory does not have a working tree'),
 
64
                         _('Operation aborted.'))
 
65
            self.close()
 
66
            return
 
67
 
 
68
        if self.notbranch:
 
69
            error_dialog(_('Directory is not a branch'),
 
70
                         _('You can perform this action only in a branch.'))
 
71
            self.close()
 
72
            return
 
73
        else:
 
74
            if self.wt.branch.get_bound_location() is not None:
 
75
                # we have a checkout, so the local commit checkbox must appear
 
76
                self._is_checkout = True
 
77
            
 
78
            if self.pending:
 
79
                # There are pending merges, file selection not supported
 
80
                self._is_pending = True
 
81
        
 
82
        # Create the widgets
 
83
        self._button_commit = gtk.Button(_("Comm_it"), use_underline=True)
 
84
        if self._is_checkout:
 
85
            self._check_local = gtk.CheckButton(_("_Local only commit (works in checkouts)"),
 
86
                                                use_underline=True)
 
87
        self._check_strict = gtk.CheckButton(_("_Strict commit (fails if unknown files are present)"),
 
88
                                             use_underline=True)
 
89
        self._expander_files = gtk.Expander(_("Please select the file(s) to commit"))
 
90
        self._vpaned_main = gtk.VPaned()
 
91
        self._scrolledwindow_files = gtk.ScrolledWindow()
 
92
        self._scrolledwindow_message = gtk.ScrolledWindow()
 
93
        self._treeview_files = gtk.TreeView()
 
94
        self._vbox_message = gtk.VBox()
 
95
        self._label_message = gtk.Label(_("Please specify a commit message:"))
 
96
        self._textview_message = gtk.TextView()
 
97
        
 
98
        if self._is_pending:
 
99
            self._expander_merges = gtk.Expander(_("Pending merges"))
 
100
            self._vpaned_list = gtk.VPaned()
 
101
            self._scrolledwindow_merges = gtk.ScrolledWindow()
 
102
            self._treeview_merges = gtk.TreeView()
 
103
 
 
104
        # Set callbacks
 
105
        self._button_commit.connect('clicked', self._on_commit_clicked)
 
106
        self._treeview_files.connect('row_activated', self._on_treeview_files_row_activated)
 
107
        
 
108
        # Set properties
 
109
        self._scrolledwindow_files.set_policy(gtk.POLICY_AUTOMATIC,
 
110
                                              gtk.POLICY_AUTOMATIC)
 
111
        self._scrolledwindow_message.set_policy(gtk.POLICY_AUTOMATIC,
 
112
                                                gtk.POLICY_AUTOMATIC)
 
113
        self._textview_message.modify_font(pango.FontDescription("Monospace"))
 
114
        self.set_default_size(500, 500)
 
115
        self._vpaned_main.set_position(200)
 
116
 
 
117
        if self._is_pending:
 
118
            self._scrolledwindow_merges.set_policy(gtk.POLICY_AUTOMATIC,
 
119
                                                   gtk.POLICY_AUTOMATIC)
 
120
            self._treeview_files.set_sensitive(False)
 
121
        
 
122
        # Construct the dialog
 
123
        self.action_area.pack_end(self._button_commit)
 
124
        
 
125
        self._scrolledwindow_files.add(self._treeview_files)
 
126
        self._scrolledwindow_message.add(self._textview_message)
 
127
        
 
128
        self._expander_files.add(self._scrolledwindow_files)
 
129
        
 
130
        self._vbox_message.pack_start(self._label_message, False, False)
 
131
        self._vbox_message.pack_start(self._scrolledwindow_message, True, True)
 
132
        
 
133
        if self._is_pending:        
 
134
            self._expander_merges.add(self._scrolledwindow_merges)
 
135
            self._scrolledwindow_merges.add(self._treeview_merges)
 
136
            self._vpaned_list.add1(self._expander_files)
 
137
            self._vpaned_list.add2(self._expander_merges)
 
138
            self._vpaned_main.add1(self._vpaned_list)
 
139
        else:
 
140
            self._vpaned_main.add1(self._expander_files)
 
141
 
 
142
        self._vpaned_main.add2(self._vbox_message)
 
143
        
 
144
        self.vbox.pack_start(self._vpaned_main, True, True)
 
145
        if self._is_checkout:
 
146
            self.vbox.pack_start(self._check_local, False, False)
 
147
        self.vbox.pack_start(self._check_strict, False, False)
 
148
        
 
149
        # Create the file list
 
150
        self._create_file_view()
 
151
        # Create the pending merges
 
152
        self._create_pending_merges()
 
153
        
 
154
        # Expand the corresponding expander
 
155
        if self._is_pending:
 
156
            self._expander_merges.set_expanded(True)
 
157
        else:
 
158
            self._expander_files.set_expanded(True)
 
159
        
 
160
        # Display dialog
 
161
        self.vbox.show_all()
 
162
    
 
163
    def _on_treeview_files_row_activated(self, treeview, path, view_column):
 
164
        # FIXME: the diff window freezes for some reason
 
165
        treeselection = treeview.get_selection()
 
166
        (model, iter) = treeselection.get_selected()
 
167
        
 
168
        if iter is not None:
 
169
            from olive import DiffWindow
 
170
            
 
171
            _selected = model.get_value(iter, 1)
 
172
            
 
173
            diff = DiffWindow()
 
174
            parent_tree = self.wt.branch.repository.revision_tree(self.wt.branch.last_revision())
 
175
            diff.set_diff(self.wt.branch.nick, self.wt, parent_tree)
 
176
            try:
 
177
                diff.set_file(_selected)
 
178
            except errors.NoSuchFile:
 
179
                pass
 
180
            diff.show()
 
181
    
 
182
    @show_bzr_error
 
183
    def _on_commit_clicked(self, button):
 
184
        """ Commit button clicked handler. """
 
185
        textbuffer = self._textview_message.get_buffer()
 
186
        start, end = textbuffer.get_bounds()
 
187
        message = textbuffer.get_text(start, end).decode('utf-8')
 
188
        
 
189
        if not self.pending:
 
190
            specific_files = self._get_specific_files()
 
191
        else:
 
192
            specific_files = None
 
193
 
 
194
        if message == '':
 
195
            response = question_dialog(_('Commit with an empty message?'),
 
196
                                       _('You can describe your commit intent in the message.'))
 
197
            if response == gtk.RESPONSE_NO:
 
198
                # Kindly give focus to message area
 
199
                self._textview_message.grab_focus()
 
200
                return
 
201
 
 
202
        if self._is_checkout:
 
203
            local = self._check_local.get_active()
 
204
        else:
 
205
            local = False
 
206
        
 
207
        try:
 
208
            self.wt.commit(message,
 
209
                       allow_pointless=False,
 
210
                       strict=self._check_strict.get_active(),
 
211
                       local=local,
 
212
                       specific_files=specific_files)
 
213
        except errors.PointlessCommit:
 
214
            response = question_dialog(_('Commit with no changes?'),
 
215
                                       _('There are no changes in the working tree.'))
 
216
            if response == gtk.RESPONSE_YES:
 
217
                self.wt.commit(message,
 
218
                               allow_pointless=True,
 
219
                               strict=self._check_strict.get_active(),
 
220
                               local=local,
 
221
                               specific_files=specific_files)
 
222
        self.response(gtk.RESPONSE_OK)
 
223
 
 
224
    def _pending_merges(self, wt):
 
225
        """ Return a list of pending merges or None if there are none of them. """
 
226
        parents = wt.get_parent_ids()
 
227
        if len(parents) < 2:
 
228
            return None
 
229
        
 
230
        import re
 
231
        from bzrlib.osutils import format_date
 
232
        
 
233
        pending = parents[1:]
 
234
        branch = wt.branch
 
235
        last_revision = parents[0]
 
236
        
 
237
        if last_revision is not None:
 
238
            try:
 
239
                ignore = set(branch.repository.get_ancestry(last_revision))
 
240
            except errors.NoSuchRevision:
 
241
                # the last revision is a ghost : assume everything is new 
 
242
                # except for it
 
243
                ignore = set([None, last_revision])
 
244
        else:
 
245
            ignore = set([None])
 
246
        
 
247
        pm = []
 
248
        for merge in pending:
 
249
            ignore.add(merge)
 
250
            try:
 
251
                m_revision = branch.repository.get_revision(merge)
 
252
                
 
253
                rev = {}
 
254
                rev['committer'] = re.sub('<.*@.*>', '', m_revision.committer).strip(' ')
 
255
                rev['summary'] = m_revision.get_summary()
 
256
                rev['date'] = format_date(m_revision.timestamp,
 
257
                                          m_revision.timezone or 0, 
 
258
                                          'original', date_fmt="%Y-%m-%d",
 
259
                                          show_offset=False)
 
260
                
 
261
                pm.append(rev)
 
262
                
 
263
                inner_merges = branch.repository.get_ancestry(merge)
 
264
                assert inner_merges[0] is None
 
265
                inner_merges.pop(0)
 
266
                inner_merges.reverse()
 
267
                for mmerge in inner_merges:
 
268
                    if mmerge in ignore:
 
269
                        continue
 
270
                    mm_revision = branch.repository.get_revision(mmerge)
 
271
                    
 
272
                    rev = {}
 
273
                    rev['committer'] = re.sub('<.*@.*>', '', mm_revision.committer).strip(' ')
 
274
                    rev['summary'] = mm_revision.get_summary()
 
275
                    rev['date'] = format_date(mm_revision.timestamp,
 
276
                                              mm_revision.timezone or 0, 
 
277
                                              'original', date_fmt="%Y-%m-%d",
 
278
                                              show_offset=False)
 
279
                
 
280
                    pm.append(rev)
 
281
                    
 
282
                    ignore.add(mmerge)
 
283
            except errors.NoSuchRevision:
 
284
                print "DEBUG: NoSuchRevision:", merge
 
285
        
 
286
        return pm
 
287
 
 
288
    def _create_file_view(self):
 
289
        self._file_store = gtk.ListStore(gobject.TYPE_BOOLEAN,   # [0] checkbox
 
290
                                         gobject.TYPE_STRING,    # [1] path to display
 
291
                                         gobject.TYPE_STRING,    # [2] changes type
 
292
                                         gobject.TYPE_STRING)    # [3] real path
 
293
        self._treeview_files.set_model(self._file_store)
 
294
        crt = gtk.CellRendererToggle()
 
295
        crt.set_property("activatable", True)
 
296
        crt.connect("toggled", self._toggle_commit, self._file_store)
 
297
        self._treeview_files.append_column(gtk.TreeViewColumn(_('Commit'),
 
298
                                     crt, active=0))
 
299
        self._treeview_files.append_column(gtk.TreeViewColumn(_('Path'),
 
300
                                     gtk.CellRendererText(), text=1))
 
301
        self._treeview_files.append_column(gtk.TreeViewColumn(_('Type'),
 
302
                                     gtk.CellRendererText(), text=2))
 
303
 
 
304
        for path, id, kind in self.delta.added:
 
305
            marker = osutils.kind_marker(kind)
 
306
            if self.selected is not None:
 
307
                if path == os.path.join(self.wtpath, self.selected):
 
308
                    self._file_store.append([ True, path+marker, _('added'), path ])
 
309
                else:
 
310
                    self._file_store.append([ False, path+marker, _('added'), path ])
 
311
            else:
 
312
                self._file_store.append([ True, path+marker, _('added'), path ])
 
313
 
 
314
        for path, id, kind in self.delta.removed:
 
315
            marker = osutils.kind_marker(kind)
 
316
            if self.selected is not None:
 
317
                if path == os.path.join(self.wtpath, self.selected):
 
318
                    self._file_store.append([ True, path+marker, _('removed'), path ])
 
319
                else:
 
320
                    self._file_store.append([ False, path+marker, _('removed'), path ])
 
321
            else:
 
322
                self._file_store.append([ True, path+marker, _('removed'), path ])
 
323
 
 
324
        for oldpath, newpath, id, kind, text_modified, meta_modified in self.delta.renamed:
 
325
            marker = osutils.kind_marker(kind)
 
326
            if text_modified or meta_modified:
 
327
                changes = _('renamed and modified')
 
328
            else:
 
329
                changes = _('renamed')
 
330
            if self.selected is not None:
 
331
                if newpath == os.path.join(self.wtpath, self.selected):
 
332
                    self._file_store.append([ True,
 
333
                                              oldpath+marker + '  =>  ' + newpath+marker,
 
334
                                              changes,
 
335
                                              newpath
 
336
                                            ])
 
337
                else:
 
338
                    self._file_store.append([ False,
 
339
                                              oldpath+marker + '  =>  ' + newpath+marker,
 
340
                                              changes,
 
341
                                              newpath
 
342
                                            ])
 
343
            else:
 
344
                self._file_store.append([ True,
 
345
                                          oldpath+marker + '  =>  ' + newpath+marker,
 
346
                                          changes,
 
347
                                          newpath
 
348
                                        ])
 
349
 
 
350
        for path, id, kind, text_modified, meta_modified in self.delta.modified:
 
351
            marker = osutils.kind_marker(kind)
 
352
            if self.selected is not None:
 
353
                if path == os.path.join(self.wtpath, self.selected):
 
354
                    self._file_store.append([ True, path+marker, _('modified'), path ])
 
355
                else:
 
356
                    self._file_store.append([ False, path+marker, _('modified'), path ])
 
357
            else:
 
358
                self._file_store.append([ True, path+marker, _('modified'), path ])
 
359
    
 
360
    def _create_pending_merges(self):
 
361
        if not self.pending:
 
362
            return
 
363
        
 
364
        liststore = gtk.ListStore(gobject.TYPE_STRING,
 
365
                                  gobject.TYPE_STRING,
 
366
                                  gobject.TYPE_STRING)
 
367
        self._treeview_merges.set_model(liststore)
 
368
        
 
369
        self._treeview_merges.append_column(gtk.TreeViewColumn(_('Date'),
 
370
                                            gtk.CellRendererText(), text=0))
 
371
        self._treeview_merges.append_column(gtk.TreeViewColumn(_('Committer'),
 
372
                                            gtk.CellRendererText(), text=1))
 
373
        self._treeview_merges.append_column(gtk.TreeViewColumn(_('Summary'),
 
374
                                            gtk.CellRendererText(), text=2))
 
375
        
 
376
        for item in self.pending:
 
377
            liststore.append([ item['date'],
 
378
                               item['committer'],
 
379
                               item['summary'] ])
 
380
    
 
381
    def _get_specific_files(self):
 
382
        ret = []
 
383
        it = self._file_store.get_iter_first()
 
384
        while it:
 
385
            if self._file_store.get_value(it, 0):
 
386
                # get real path from hidden column 3
 
387
                ret.append(self._file_store.get_value(it, 3))
 
388
            it = self._file_store.iter_next(it)
 
389
 
 
390
        return ret
 
391
    
 
392
    def _toggle_commit(self, cell, path, model):
 
393
        model[path][0] = not model[path][0]
 
394
        return