Merge pull request #178 from bfredl/urm_err

be more verbose about import errors

Author: bfredl

neovim/__init__.py

@@ -7,16 +7,17 @@
 import sys
 
 from .api import DecodeHook, Nvim, SessionHook
-from .msgpack_rpc import (child_session, socket_session, stdio_session,
-                          tcp_session)
+from .msgpack_rpc import (ErrorResponse, child_session, socket_session,
+                          stdio_session, tcp_session)
 from .plugin import (Host, autocmd, command, encoding, function, plugin,
                      rpc_export, shutdown_hook)
 
 
 __all__ = ('tcp_session', 'socket_session', 'stdio_session', 'child_session',
            'start_host', 'autocmd', 'command', 'encoding', 'function',
            'plugin', 'rpc_export', 'Host', 'DecodeHook', 'Nvim',
-           'SessionHook', 'shutdown_hook', 'attach', 'setup_logging')
+           'SessionHook', 'shutdown_hook', 'attach', 'setup_logging',
+           'ErrorResponse')
 
 
 def start_host(session=None):

neovim/msgpack_rpc/__init__.py

@@ -7,10 +7,11 @@
 from .async_session import AsyncSession
 from .event_loop import EventLoop
 from .msgpack_stream import MsgpackStream
-from .session import Session
+from .session import ErrorResponse, Session
 
 
-__all__ = ('tcp_session', 'socket_session', 'stdio_session', 'child_session')
+__all__ = ('tcp_session', 'socket_session', 'stdio_session', 'child_session',
+           'ErrorResponse')
 
 
 def session(transport_type='stdio', *args, **kwargs):

neovim/msgpack_rpc/session.py

@@ -182,6 +182,10 @@ def handler():
                 debug('greenlet %s finished executing, ' +
                       'sending %s as response', gr, rv)
                 response.send(rv)
+            except ErrorResponse as err:
+                warn("error response from request '%s %s': %s", name,
+                     args, format_exc())
+                response.send(err.args[0], error=True)
             except Exception as err:
                 warn("error caught while processing request '%s %s': %s", name,
                      args, format_exc())
@@ -207,3 +211,15 @@ def handler():
         gr = greenlet.greenlet(handler)
         debug('received rpc notification, greenlet %s will handle it', gr)
         gr.switch()
+
+
+class ErrorResponse(BaseException):
+
+    """Raise this in a request handler to respond with a given error message.
+
+    Unlike when other exceptions are caught, this gives full control off the
+    error response sent. When "ErrorResponse(msg)" is caught "msg" will be
+    sent verbatim as the error response.No traceback will be appended.
+    """
+
+    pass

neovim/plugin/host.py

@@ -5,11 +5,13 @@
 import logging
 import os
 import os.path
+import re
 
 from traceback import format_exc
 
 from ..api import DecodeHook
 from ..compat import IS_PYTHON3, find_module
+from ..msgpack_rpc import ErrorResponse
 
 __all__ = ('Host')
 
@@ -31,6 +33,7 @@ def __init__(self, nvim):
         self.nvim = nvim
         self._specs = {}
         self._loaded = {}
+        self._load_errors = {}
         self._notification_handlers = {}
         self._request_handlers = {
             'poll': lambda: 'ok',
@@ -58,9 +61,9 @@ def _on_request(self, name, args):
             name = name.decode(self._nvim_encoding)
         handler = self._request_handlers.get(name, None)
         if not handler:
-            msg = 'no request handler registered for "%s"' % name
-            warn(msg)
-            raise Exception(msg)
+            msg = self._missing_handler_error(name, 'request')
+            error(msg)
+            raise ErrorResponse(msg)
 
         debug('calling request handler for "%s", args: "%s"', name, args)
         rv = handler(*args)
@@ -73,7 +76,9 @@ def _on_notification(self, name, args):
             name = name.decode(self._nvim_encoding)
         handler = self._notification_handlers.get(name, None)
         if not handler:
-            warn('no notification handler registered for "%s"', name)
+            msg = self._missing_handler_error(name, 'notification')
+            error(msg)
+            self.nvim.err_write(msg + "\n")
             return
 
         debug('calling notification handler for "%s", args: "%s"', name, args)
@@ -85,8 +90,18 @@ def _on_notification(self, name, args):
             self.nvim.err_write(msg, async=True)
             raise
 
+    def _missing_handler_error(self, name, kind):
+        msg = 'no {} handler registered for "{}"'.format(kind, name)
+        pathmatch = re.match(r'(.+):[^:]+:[^:]+', name)
+        if pathmatch:
+            loader_error = self._load_errors.get(pathmatch.group(1))
+            if loader_error is not None:
+                msg = msg + "\n" + loader_error
+        return msg
+
     def _load(self, plugins):
         for path in plugins:
+            err = None
             if path in self._loaded:
                 error('{0} is already loaded'.format(path))
                 continue
@@ -105,12 +120,11 @@ def _load(self, plugins):
                     error('{0} exports no handlers'.format(path))
                     continue
                 self._loaded[path] = {'handlers': handlers, 'module': module}
-            except (ImportError, SyntaxError) as e:
-                error(('Encountered import error loading '
-                       'plugin at {0}: {1}').format(path, e))
             except Exception as e:
-                error('Error loading plugin at {0} {1}: {2}'.format(
-                    path, type(e).__name__, e))
+                err = ('Encountered {} loading plugin at {}: {}\n{}'
+                       .format(type(e).__name__, path, e, format_exc(5)))
+                error(err)
+                self._load_errors[path] = err
 
     def _unload(self):
         for path, plugin in self._loaded.items():
@@ -183,6 +197,8 @@ def _copy_attributes(self, fn, fn2):
     def _on_specs_request(self, path):
         if IS_PYTHON3 and isinstance(path, bytes):
             path = path.decode(self._nvim_encoding)
+        if path in self._load_errors:
+            self.nvim.out_write(self._load_errors[path] + '\n')
         return self._specs.get(path, 0)
 
     def _decodehook_for(self, encoding):