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

  • Committer: Vincent Ladeuil
  • Date: 2008-05-05 18:16:46 UTC
  • mto: (487.1.1 gtk)
  • mto: This revision was merged to the branch mainline in revision 490.
  • Revision ID: v.ladeuil+lp@free.fr-20080505181646-n95l8ltw2u6jtr26
Fix bug #187283 fix replacing _() by _i18n().

* genpot.sh 
Remove duplication. Add the ability to specify the genrated pot
file on command-line for debugging purposes.

* po/olive-gtk.pot:
Regenerated.

* __init__.py, branch.py, branchview/treeview.py, checkout.py,
commit.py, conflicts.py, diff.py, errors.py, initialize.py,
merge.py, nautilus-bzr.py, olive/__init__.py, olive/add.py,
olive/bookmark.py, olive/guifiles.py, olive/info.py,
olive/menu.py, olive/mkdir.py, olive/move.py, olive/remove.py,
olive/rename.py, push.py, revbrowser.py, status.py, tags.py:
Replace all calls to _() by calls to _i18n(), the latter being
defined in __init__.py and imported in the other modules from
there. This fix the problem encountered countless times when
running bzr selftest and getting silly error messages about
boolean not being callables.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
1
# Copyright (C) 2006 by Szilveszter Farkas (Phanatic) <szilveszter.farkas@gmail.com>
 
2
# Copyright (C) 2007 by Jelmer Vernooij <jelmer@samba.org>
2
3
#
3
4
# This program is free software; you can redistribute it and/or modify
4
5
# it under the terms of the GNU General Public License as published by
14
15
# along with this program; if not, write to the Free Software
15
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
17
 
17
 
import sys
18
 
 
19
18
try:
20
19
    import pygtk
21
20
    pygtk.require("2.0")
22
21
except:
23
22
    pass
24
 
try:
25
 
    import gtk
26
 
    import gtk.gdk
27
 
    import gtk.glade
28
 
except:
29
 
    sys.exit(1)
30
 
 
31
 
import olive.backend.commit as commit
32
 
import olive.backend.errors as errors
33
 
import olive.backend.info as info
34
 
 
35
 
class OlivePush:
36
 
    """ Display Push dialog and perform the needed actions. """
37
 
    def __init__(self, gladefile, comm, dialog):
 
23
    
 
24
import gtk
 
25
 
 
26
from errors import show_bzr_error
 
27
 
 
28
# FIXME: This needs to be public JRV 20070714
 
29
from bzrlib.builtins import _create_prefix
 
30
from bzrlib.config import LocationConfig
 
31
import bzrlib.errors as errors
 
32
 
 
33
from bzrlib.plugins.gtk import _i18n
 
34
from dialog import error_dialog, info_dialog, question_dialog
 
35
 
 
36
from history import UrlHistory
 
37
 
 
38
class PushDialog(gtk.Dialog):
 
39
    """ New implementation of the Push dialog. """
 
40
    def __init__(self, repository, revid, branch=None, parent=None):
38
41
        """ Initialize the Push dialog. """
39
 
        self.gladefile = gladefile
40
 
        self.glade = gtk.glade.XML(self.gladefile, 'window_push')
41
 
        
42
 
        # Communication object
43
 
        self.comm = comm
44
 
        # Dialog object
45
 
        self.dialog = dialog
46
 
        
47
 
        self.window = self.glade.get_widget('window_push')
48
 
        
49
 
        # Dictionary for signal_autoconnect
50
 
        dic = { "on_button_push_push_clicked": self.push,
51
 
                "on_button_push_cancel_clicked": self.close,
52
 
                "on_button_push_test_clicked": self.test,
53
 
                "on_radiobutton_push_stored_toggled": self.stored_toggled,
54
 
                "on_radiobutton_push_specific_toggled": self.specific_toggled, }
55
 
        
56
 
        # Connect the signals to the handlers
57
 
        self.glade.signal_autoconnect(dic)
58
 
        
59
 
        # Get some useful widgets
60
 
        self.radio_stored = self.glade.get_widget('radiobutton_push_stored')
61
 
        self.radio_specific = self.glade.get_widget('radiobutton_push_specific')
62
 
        self.entry_stored = self.glade.get_widget('entry_push_stored')
63
 
        self.entry_location = self.glade.get_widget('entry_push_location')
64
 
        self.check_remember = self.glade.get_widget('checkbutton_push_remember')
65
 
        self.check_overwrite = self.glade.get_widget('checkbutton_push_overwrite')
66
 
        self.check_create = self.glade.get_widget('checkbutton_push_create')
67
 
        self.label_test = self.glade.get_widget('label_push_test')
68
 
        self.image_test = self.glade.get_widget('image_push_test')
69
 
        
70
 
        # Set initial state
71
 
        self.entry_location.set_sensitive(0)
72
 
        self.check_remember.set_sensitive(0)
73
 
        self.check_create.set_sensitive(0)
74
 
                
75
 
        # Get stored location
76
 
        self.notbranch = False
77
 
        try:
78
 
            loc = info.get_push_location(self.comm.get_path())
79
 
        except errors.NotBranchError:
80
 
            self.notbranch = True
81
 
            return
82
 
 
83
 
        if loc is not None:
84
 
            self.entry_stored.set_text(loc)
85
 
    
86
 
    def display(self):
87
 
        """ Display the Push dialog. """
88
 
        if self.notbranch:
89
 
            self.dialog.error_dialog(_('Directory is not a branch'),
90
 
                                     _('You can perform this action only in a branch.'))
91
 
            self.close()
92
 
        else:
93
 
            self.window.show()
94
 
            self.width, self.height = self.window.get_size()
95
 
    
96
 
    def stored_toggled(self, widget):
97
 
        if widget.get_active():
98
 
            self.entry_stored.set_sensitive(1)
99
 
            self.entry_location.set_sensitive(0)
100
 
            self.check_remember.set_sensitive(0)
101
 
            self.check_create.set_sensitive(0)
102
 
        else:
103
 
            self.entry_stored.set_sensitive(0)
104
 
            self.entry_location.set_sensitive(1)
105
 
            self.check_remember.set_sensitive(1)
106
 
            self.check_create.set_sensitive(1)
107
 
    
108
 
    def specific_toggled(self, widget):
109
 
        if widget.get_active():
110
 
            self.entry_stored.set_sensitive(0)
111
 
            self.entry_location.set_sensitive(1)
112
 
            self.check_remember.set_sensitive(1)
113
 
            self.check_create.set_sensitive(1)
114
 
        else:
115
 
            self.entry_stored.set_sensitive(1)
116
 
            self.entry_location.set_sensitive(0)
117
 
            self.check_remember.set_sensitive(0)
118
 
            self.check_create.set_sensitive(0)
119
 
    
120
 
    def push(self, widget):
 
42
        gtk.Dialog.__init__(self, title="Push - Olive",
 
43
                                  parent=parent,
 
44
                                  flags=0,
 
45
                                  buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL))
 
46
        
 
47
        # Get arguments
 
48
        self.repository = repository
 
49
        self.revid = revid
 
50
        self.branch = branch
 
51
        
 
52
        # Create the widgets
 
53
        self._label_location = gtk.Label(_i18n("Location:"))
 
54
        self._combo = gtk.ComboBoxEntry()
 
55
        self._button_push = gtk.Button(_i18n("_Push"), use_underline=True)
 
56
        self._hbox_location = gtk.HBox()
 
57
        
 
58
        # Set callbacks
 
59
        self._button_push.connect('clicked', self._on_push_clicked)
 
60
        
 
61
        # Set properties
 
62
        self._label_location.set_alignment(0, 0.5)
 
63
        self._hbox_location.set_spacing(3)
 
64
        self.vbox.set_spacing(3)
 
65
        
 
66
        # Pack widgets
 
67
        self._hbox_location.pack_start(self._label_location, False, False)
 
68
        self._hbox_location.pack_start(self._combo, True, True)
 
69
        self.vbox.pack_start(self._hbox_location)
 
70
        self.action_area.pack_end(self._button_push)
 
71
        
 
72
        # Show the dialog
 
73
        self.vbox.show_all()
 
74
        
 
75
        # Build location history
 
76
        self._history = UrlHistory(self.branch.get_config(), 'push_history')
 
77
        self._build_history()
 
78
        
 
79
    def _build_history(self):
 
80
        """ Build up the location history. """
 
81
        self._combo_model = gtk.ListStore(str)
 
82
        for item in self._history.get_entries():
 
83
            self._combo_model.append([ item ])
 
84
        self._combo.set_model(self._combo_model)
 
85
        self._combo.set_text_column(0)
 
86
        
 
87
        if self.branch is not None:
 
88
            location = self.branch.get_push_location()
 
89
            if location is not None:
 
90
                self._combo.get_child().set_text(location)
 
91
    
 
92
    @show_bzr_error
 
93
    def _on_push_clicked(self, widget):
 
94
        """ Push button clicked handler. """
 
95
        location = self._combo.get_child().get_text()
121
96
        revs = 0
122
 
        self.comm.set_busy(self.window)
123
 
        if self.radio_stored.get_active():
124
 
            try:
125
 
                revs = commit.push(self.comm.get_path(),
126
 
                                   overwrite=self.check_overwrite.get_active())
127
 
            except errors.NotBranchError:
128
 
                self.dialog.error_dialog(_('Directory is not a branch'),
129
 
                                         _('You can perform this action only in a branch.'))
130
 
                return
131
 
            except errors.NoLocationKnown:
132
 
                self.dialog.error_dialog(_('Push location is unknown'),
133
 
                                         _('Please specify a location manually.'))
134
 
                return
135
 
            except errors.NonExistingParent, errmsg:
136
 
                self.dialog.error_dialog(_('Non existing parent directory'),
137
 
                                         _("The parent directory (%s)\ndoesn't exist.") % errmsg)
138
 
                return
139
 
            except errors.DivergedBranchesError:
140
 
                self.dialog.error_dialog(_('Branches have been diverged'),
141
 
                                         _('You cannot push if branches have diverged. Use the\noverwrite option if you want to push anyway.'))
142
 
                return
143
 
            except:
144
 
                raise
145
 
        elif self.radio_specific.get_active():
146
 
            location = self.entry_location.get_text()
147
 
            if location == '':
148
 
                self.dialog.error_dialog(_('No location specified'),
149
 
                                         _('Please specify a location or use the default.'))
150
 
                return
151
 
            
152
 
            try:
153
 
                revs = commit.push(self.comm.get_path(), location,
154
 
                                   self.check_remember.get_active(),
155
 
                                   self.check_overwrite.get_active(),
156
 
                                   self.check_create.get_active())
157
 
            except errors.NotBranchError:
158
 
                self.dialog.error_dialog(_('Directory is not a branch'),
159
 
                                         _('You can perform this action only in a branch.'))
160
 
                self.comm.set_busy(self.window, False)
161
 
                return
162
 
            except errors.NonExistingParent, errmsg:
163
 
                self.dialog.error_dialog(_('Non existing parent directory'),
164
 
                                         _("The parent directory (%s)\ndoesn't exist.") % errmsg)
165
 
                self.comm.set_busy(self.window, False)
166
 
                return
167
 
            except errors.DivergedBranchesError:
168
 
                self.dialog.error_dialog(_('Branches have been diverged'),
169
 
                                         _('You cannot push if branches have diverged. Use the\noverwrite option if you want to push anyway.'))
170
 
                self.comm.set_busy(self.window, False)
171
 
                return
172
 
            except errors.PathPrefixNotCreated:
173
 
                self.dialog.error_dialog(_('Path prefix not created'),
174
 
                                         _("The path leading up to the specified location couldn't\nbe created."))
175
 
                self.comm.set_busy(self.window, False)
176
 
                return
177
 
            except:
178
 
                raise
179
 
        else:
180
 
            # This should really never happen
181
 
            pass
182
 
        
183
 
        self.close()
184
 
        self.dialog.info_dialog(_('Push successful'),
185
 
                                _('%d revision(s) pushed.') % revs)
186
 
    
187
 
    def test(self, widget):
188
 
        """ Test if write access possible. """
189
 
        import re
190
 
        _urlRE = re.compile(r'^(?P<proto>[^:/\\]+)://(?P<path>.*)$')
191
 
        
192
 
        if self.radio_stored.get_active():
193
 
            url = self.entry_stored.get_text()
194
 
        elif self.radio_specific.get_active():
195
 
            url = self.entry_location.get_text()
196
 
        
197
 
        m = _urlRE.match(url)
198
 
        if m:
199
 
            proto = m.groupdict()['proto']
200
 
            if (proto == 'sftp') or (proto == 'file') or (proto == 'ftp'):
201
 
                # have write acces (most probably)
202
 
                self.image_test.set_from_stock(gtk.STOCK_YES, 4)
203
 
                self.label_test.set_markup(_('<b>Write access is probably available</b>'))
 
97
        if self.branch is not None and self.branch.get_push_location() is None:
 
98
            response = question_dialog(_i18n('Set default push location'),
 
99
                                       _i18n('There is no default push location set.\nSet %r as default now?') % location)
 
100
            if response == gtk.RESPONSE_OK:
 
101
                self.branch.set_push_location(location)
 
102
 
 
103
        try:
 
104
            revs = do_push(self.branch, location=location, overwrite=False)
 
105
        except errors.DivergedBranches:
 
106
            response = question_dialog(_i18n('Branches have been diverged'),
 
107
                                       _i18n('You cannot push if branches have diverged.\nOverwrite?'))
 
108
            if response == gtk.RESPONSE_YES:
 
109
                revs = do_push(self.branch, location=location, overwrite=True)
 
110
        
 
111
        self._history.add_entry(location)
 
112
        info_dialog(_i18n('Push successful'),
 
113
                    _i18n("%d revision(s) pushed.") % revs)
 
114
        
 
115
        self.response(gtk.RESPONSE_OK)
 
116
 
 
117
def do_push(br_from, location, overwrite):
 
118
    """ Update a mirror of a branch.
 
119
    
 
120
    :param br_from: the source branch
 
121
    
 
122
    :param location: the location of the branch that you'd like to update
 
123
    
 
124
    :param overwrite: overwrite target location if it diverged
 
125
    
 
126
    :return: number of revisions pushed
 
127
    """
 
128
    from bzrlib.bzrdir import BzrDir
 
129
    from bzrlib.transport import get_transport
 
130
        
 
131
    transport = get_transport(location)
 
132
    location_url = transport.base
 
133
 
 
134
    old_rh = []
 
135
 
 
136
    try:
 
137
        dir_to = BzrDir.open(location_url)
 
138
        br_to = dir_to.open_branch()
 
139
    except errors.NotBranchError:
 
140
        # create a branch.
 
141
        transport = transport.clone('..')
 
142
        try:
 
143
            relurl = transport.relpath(location_url)
 
144
            transport.mkdir(relurl)
 
145
        except errors.NoSuchFile:
 
146
            response = question_dialog(_i18n('Non existing parent directory'),
 
147
                         _i18n("The parent directory (%s)\ndoesn't exist. Create?") % location)
 
148
            if response == gtk.RESPONSE_OK:
 
149
                _create_prefix(transport)
204
150
            else:
205
 
                # no write access
206
 
                self.image_test.set_from_stock(gtk.STOCK_NO, 4)
207
 
                self.label_test.set_markup(_('<b>No write access</b>'))
 
151
                return
 
152
        dir_to = br_from.bzrdir.clone(location_url,
 
153
            revision_id=br_from.last_revision())
 
154
        br_to = dir_to.open_branch()
 
155
        count = len(br_to.revision_history())
 
156
    else:
 
157
        old_rh = br_to.revision_history()
 
158
        try:
 
159
            tree_to = dir_to.open_workingtree()
 
160
        except errors.NotLocalUrl:
 
161
            # FIXME - what to do here? how should we warn the user?
 
162
            count = br_to.pull(br_from, overwrite)
 
163
        except errors.NoWorkingTree:
 
164
            count = br_to.pull(br_from, overwrite)
208
165
        else:
209
 
            # couldn't determine
210
 
            self.image_test.set_from_stock(gtk.STOCK_DIALOG_QUESTION, 4)
211
 
            self.label_test.set_markup(_('<b>Could not determine</b>'))
212
 
    
213
 
    def close(self, widget=None):
214
 
        self.window.destroy()
 
166
            count = tree_to.pull(br_from, overwrite)
 
167
 
 
168
    return count