Merge pull request #189 from bfredl/decode

remove decodehook

Author: bfredl

neovim/__init__.py

@@ -6,16 +6,17 @@
 import os
 import sys
 
-from .api import DecodeHook, Nvim
+from .api import Nvim
+from .compat import IS_PYTHON3
 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)
+from .plugin import (Host, autocmd, command, decode, 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',
+           'start_host', 'autocmd', 'command', 'encoding', 'decode',
+           'function', 'plugin', 'rpc_export', 'Host', 'Nvim',
            'shutdown_hook', 'attach', 'setup_logging', 'ErrorResponse')
 
 
@@ -63,7 +64,8 @@ def start_host(session=None):
     host.start(plugins)
 
 
-def attach(session_type, address=None, port=None, path=None, argv=None):
+def attach(session_type, address=None, port=None,
+           path=None, argv=None, decode=None):
     """Provide a nicer interface to create python api sessions.
 
     Previous machinery to create python api sessions is still there. This only
@@ -89,7 +91,10 @@ def attach(session_type, address=None, port=None, path=None, argv=None):
     if not session:
         raise Exception('Unknown session type "%s"' % session_type)
 
-    return Nvim.from_session(session)
+    if decode is None:
+        decode = IS_PYTHON3
+
+    return Nvim.from_session(session).with_decode(decode)
 
 
 def setup_logging():

neovim/api/__init__.py

@@ -5,11 +5,11 @@
 """
 
 from .buffer import Buffer
-from .common import DecodeHook
+from .common import decode_if_bytes, walk
 from .nvim import Nvim, NvimError
 from .tabpage import Tabpage
 from .window import Window
 
 
 __all__ = ('Nvim', 'Buffer', 'Window', 'Tabpage', 'NvimError',
-           'DecodeHook')
+           'decode_if_bytes', 'walk')

neovim/api/common.py

@@ -153,38 +153,20 @@ def _identity(obj, session, method, kind):
     return obj
 
 
-class DecodeHook(object):
-
-    """SessionHook subclass that decodes utf-8 strings coming from Nvim.
-
-    This class is useful for python3, where strings are now unicode by
-    default(byte strings need to be prefixed with "b").
-    """
-
-    def __init__(self, encoding='utf-8', encoding_errors='strict'):
-        """Initialize with encoding and encoding errors policy."""
-        self.encoding = encoding
-        self.encoding_errors = encoding_errors
-
-    def decode_if_bytes(self, obj):
-        """Decode obj if it is bytes."""
-        if isinstance(obj, bytes):
-            return obj.decode(self.encoding, errors=self.encoding_errors)
-        return obj
-
-    def walk(self, obj):
-        """Decode bytes found in obj (any msgpack object).
-
-        Uses encoding and policy specified in constructor.
-        """
-        return walk(self.decode_if_bytes, obj)
+def decode_if_bytes(obj, mode=True):
+    """Decode obj if it is bytes."""
+    if mode is True:
+        mode = "strict"
+    if isinstance(obj, bytes):
+        return obj.decode("utf-8", errors=mode)
+    return obj
 
 
-def walk(fn, obj, *args):
+def walk(fn, obj, *args, **kwargs):
     """Recursively walk an object graph applying `fn`/`args` to objects."""
     if type(obj) in [list, tuple]:
         return list(walk(fn, o, *args) for o in obj)
     if type(obj) is dict:
         return dict((walk(fn, k, *args), walk(fn, v, *args)) for k, v in
                     obj.items())
-    return fn(obj, *args)
+    return fn(obj, *args, **kwargs)

neovim/api/nvim.py

@@ -8,8 +8,8 @@
 from msgpack import ExtType
 
 from .buffer import Buffer
-from .common import (DecodeHook, Remote, RemoteApi,
-                     RemoteMap, RemoteSequence, walk)
+from .common import (Remote, RemoteApi, RemoteMap, RemoteSequence,
+                     decode_if_bytes, walk)
 from .tabpage import Tabpage
 from .window import Window
 from ..compat import IS_PYTHON3
@@ -33,7 +33,7 @@ class Nvim(object):
     from a raw `Session` instance.
 
     Subsequent instances for the same session can be created by calling the
-    `with_decodehook` instance method to change the decoding behavior or
+    `with_decode` instance method to change the decoding behavior or
     `SubClass.from_nvim(nvim)` where `SubClass` is a subclass of `Nvim`, which
     is useful for having multiple `Nvim` objects that behave differently
     without one affecting the other.
@@ -52,7 +52,7 @@ def from_session(cls, session):
 
         if IS_PYTHON3:
             # decode all metadata strings for python3
-            metadata = DecodeHook().walk(metadata)
+            metadata = walk(decode_if_bytes, metadata)
 
         types = {
             metadata['types']['Buffer']['id']: Buffer,
@@ -66,10 +66,10 @@ def from_session(cls, session):
     def from_nvim(cls, nvim):
         """Create a new Nvim instance from an existing instance."""
         return cls(nvim._session, nvim.channel_id, nvim.metadata,
-                   nvim.types, nvim._decodehook, nvim._err_cb)
+                   nvim.types, nvim._decode, nvim._err_cb)
 
     def __init__(self, session, channel_id, metadata, types,
-                 decodehook=None, err_cb=None):
+                 decode=False, err_cb=None):
         """Initialize a new Nvim instance. This method is module-private."""
         self._session = session
         self.channel_id = channel_id
@@ -85,15 +85,17 @@ def __init__(self, session, channel_id, metadata, types,
         self.current = Current(self)
         self.funcs = Funcs(self)
         self.error = NvimError
-        self._decodehook = decodehook
+        self._decode = decode
         self._err_cb = err_cb
 
-    def _from_nvim(self, obj):
+    def _from_nvim(self, obj, decode=None):
+        if decode is None:
+            decode = self._decode
         if type(obj) is ExtType:
             cls = self.types[obj.code]
             return cls(self, (obj.code, obj.data))
-        if self._decodehook is not None:
-            obj = self._decodehook.decode_if_bytes(obj)
+        if decode:
+            obj = decode_if_bytes(obj, decode)
         return obj
 
     def _to_nvim(self, obj):
@@ -121,9 +123,10 @@ def request(self, name, *args, **kwargs):
         present and True, a asynchronous notification is sent instead. This
         will never block, and the return value or error is ignored.
         """
+        decode = kwargs.pop('decode', self._decode)
         args = walk(self._to_nvim, args)
         res = self._session.request(name, *args, **kwargs)
-        return walk(self._from_nvim, res)
+        return walk(self._from_nvim, res, decode=decode)
 
     def next_message(self):
         """Block until a message(request or notification) is available.
@@ -160,10 +163,10 @@ def stop_loop(self):
         """Stop the event loop being started with `run_loop`."""
         self._session.stop()
 
-    def with_decodehook(self, hook):
+    def with_decode(self, decode=True):
         """Initialize a new Nvim instance."""
         return Nvim(self._session, self.channel_id,
-                    self.metadata, self.types, hook, self._err_cb)
+                    self.metadata, self.types, decode, self._err_cb)
 
     def ui_attach(self, width, height, rgb):
         """Register as a remote UI.
@@ -192,24 +195,20 @@ def unsubscribe(self, event):
         """Unsubscribe to a Nvim event."""
         return self.request('vim_unsubscribe', event)
 
-    def command(self, string, async=False):
+    def command(self, string, **kwargs):
         """Execute a single ex command."""
-        return self.request('vim_command', string, async=async)
+        return self.request('vim_command', string, **kwargs)
 
     def command_output(self, string):
         """Execute a single ex command and return the output."""
         return self.request('vim_command_output', string)
 
-    def eval(self, string, async=False):
+    def eval(self, string, **kwargs):
         """Evaluate a vimscript expression."""
-        return self.request('vim_eval', string, async=async)
+        return self.request('vim_eval', string, **kwargs)
 
     def call(self, name, *args, **kwargs):
         """Call a vimscript function."""
-        for k in kwargs:
-            if k != "async":
-                raise TypeError(
-                    "call() got an unexpected keyword argument '{}'".format(k))
         return self.request('vim_call_function', name, args, **kwargs)
 
     def strwidth(self, string):
@@ -285,9 +284,9 @@ def out_write(self, msg):
         """Print `msg` as a normal message."""
         return self.request('vim_out_write', msg)
 
-    def err_write(self, msg, async=False):
+    def err_write(self, msg, **kwargs):
         """Print `msg` as an error message."""
-        return self.request('vim_err_write', msg, async=async)
+        return self.request('vim_err_write', msg, **kwargs)
 
     def quit(self, quit_command='qa!'):
         """Send a quit command to Nvim.

neovim/msgpack_rpc/session.py

@@ -76,11 +76,15 @@ def request(self, method, *args, **kwargs):
         sent instead. This will never block, and the return value or error is
         ignored.
         """
-        async = kwargs.get('async', False)
+        async = kwargs.pop('async', False)
         if async:
             self._async_session.notify(method, args)
             return
 
+        if kwargs:
+            raise ValueError("request got unsupported keyword argument(s): {0}"
+                             .format(', '.join(kwargs.keys())))
+
         if self._is_running:
             v = self._yielding_request(method, args)
         else:

neovim/plugin/__init__.py

@@ -1,9 +1,9 @@
 """Nvim plugin/host subpackage."""
 
-from .decorators import (autocmd, command, encoding, function, plugin,
-                         rpc_export, shutdown_hook)
+from .decorators import (autocmd, command, decode, encoding, function,
+                         plugin, rpc_export, shutdown_hook)
 from .host import Host
 
 
 __all__ = ('Host', 'plugin', 'rpc_export', 'command', 'autocmd',
-           'function', 'encoding', 'shutdown_hook')
+           'function', 'encoding', 'decode', 'shutdown_hook')

neovim/plugin/decorators.py

@@ -8,7 +8,7 @@
 logger = logging.getLogger(__name__)
 debug, info, warn = (logger.debug, logger.info, logger.warning,)
 __all__ = ('plugin', 'rpc_export', 'command', 'autocmd', 'function',
-           'encoding', 'shutdown_hook')
+           'encoding', 'decode', 'shutdown_hook')
 
 
 def plugin(cls):
@@ -141,9 +141,20 @@ def shutdown_hook(f):
     return f
 
 
-def encoding(encoding=True):
+def decode(mode='strict'):
     """Configure automatic encoding/decoding of strings."""
     def dec(f):
-        f._nvim_encoding = encoding
+        f._nvim_decode = mode
+        return f
+    return dec
+
+
+def encoding(encoding=True):
+    """DEPRECATED: use neovim.decode()."""
+    if isinstance(encoding, str):
+        encoding = True
+
+    def dec(f):
+        f._nvim_decode = encoding
         return f
     return dec