← Back to branch summary

~neovim-ppa/neovim-ppa/python-neovim

« back to all changes in this revision

Viewing changes to neovim/plugin_host.py

  • Committer: Thiago de Arruda
  • Date: 2014-08-09 16:06:27 UTC
  • mfrom: (44.2.7)
  • Revision ID: git-v1:04f48115bd9263b8f370b8b38c411d468a988c69
Tags: 0.0.8
Merge pull request #17 from tarruda/refactor-concurrency

Refactor concurrency model

Show diffs side-by-side

added added

removed removed

Lines of Context:
neovim/plugin_host.py
32
32
        self.installed_plugins = []
33
33
        sys.modules['vim'] = vim
34
34
 
 
35
 
35
36
    def __enter__(self):
36
37
        vim = self.vim
37
38
        info('install import hook/path')
48
49
        self.install_plugins()
49
50
        return self
50
51
 
 
52
 
51
53
    def __exit__(self, type, value, traceback):
52
54
        for plugin in self.installed_plugins:
53
55
            if hasattr(plugin, 'on_plugin_teardown'):
60
62
        sys.stdout = self.saved_stdout
61
63
        sys.stderr = self.saved_stderr
62
64
 
 
65
 
63
66
    def discover_plugins(self):
64
67
        loaded = set()
65
68
        for directory in discover_runtime_directories(self.vim):
136
139
            self.installed_plugins.append(plugin)
137
140
 
138
141
 
139
 
    def on_message(self, message):
140
 
        method_handlers = self.method_handlers
141
 
        event_handlers = self.event_handlers
142
 
        if message.type == 'request':
143
 
            handler = method_handlers.get(message.name, None)
144
 
            if not handler:
145
 
                msg = 'no method handlers registered for %s' % message.name
146
 
                debug(msg)
147
 
                message.reply(msg , error=True)
148
 
                return
149
 
            try:
150
 
                debug("running method handler for '%s %s'", message.name,
151
 
                      message.arg)
152
 
                if message.arg:
153
 
                    rv = handler(message.arg)
154
 
                else:
155
 
                    rv = handler()
156
 
                debug("method handler for '%s %s' returns: %s",
157
 
                      message.name,
158
 
                      message.arg,
159
 
                      rv)
160
 
                message.reply(rv)
161
 
            except Exception as e:
162
 
                if isinstance(e, VimExit):
163
 
                    raise e
164
 
                err_str = format_exc(5)
165
 
                warn("error caught while processing call '%s %s': %s",
166
 
                     message.name,
167
 
                     message.arg,
168
 
                     err_str)
169
 
                message.reply(err_str, error=True)
170
 
        elif message.type == 'event':
171
 
            handlers = event_handlers.get(message.name, None)
172
 
            if not handlers:
173
 
                debug("no event handlers registered for %s", message.name)
174
 
                return
175
 
            debug('running event handler for %s', message.name)
176
 
            try:
177
 
                for handler in handlers:
178
 
                    handler(message.arg)
179
 
            except Exception as e:
180
 
                if isinstance(e, VimExit):
181
 
                    raise e
182
 
                err_str = format_exc(5)
183
 
                warn("error caught while processing event '%s %s': %s",
184
 
                     message.name,
185
 
                     message.arg,
186
 
                     err_str)
 
142
    def on_request(self, name, args):
 
143
        handler = self.method_handlers.get(name, None)
 
144
        if not handler:
 
145
            msg = 'no method handlers registered for %s' % name
 
146
            debug(msg)
 
147
            raise Exception(msg)
 
148
 
 
149
        debug("running method handler for '%s %s'", name, args)
 
150
        if args:
 
151
            rv = handler(args)
187
152
        else:
188
 
            assert False
 
153
            rv = handler()
 
154
        debug("method handler for '%s %s' returns: %s", name, args, rv)
 
155
        return rv
 
156
 
 
157
 
 
158
    def on_notification(self, name, args):
 
159
        handlers = self.event_handlers.get(name, None)
 
160
        if not handlers:
 
161
            debug("no event handlers registered for %s", name)
 
162
            return
 
163
 
 
164
        debug('running event handlers for %s', name)
 
165
        for handler in handlers:
 
166
            handler(args)
 
167
 
 
168
 
 
169
    def on_error(self, err):
 
170
        warn('exiting due to error: %s', err)
 
171
        self.vim.loop_stop()
 
172
 
189
173
 
190
174
    def run(self):
191
 
        self.vim.message_loop(lambda m: self.on_message(m))
 
175
        self.vim.loop_start(self.on_request,
 
176
                            self.on_notification,
 
177
                            self.on_error)
192
178
 
193
179
 
194
180
# This was copied/adapted from vim-python help