Merge pull request #179 from bfredl/nohook

Refactor: let Nvim be the session wrapper and simplify API remote

Author: bfredl

neovim/__init__.py

@@ -6,7 +6,7 @@
 import os
 import sys
 
-from .api import DecodeHook, Nvim, SessionHook
+from .api import DecodeHook, Nvim
 from .msgpack_rpc import (ErrorResponse, child_session, socket_session,
                           stdio_session, tcp_session)
 from .plugin import (Host, autocmd, command, encoding, function, plugin,
@@ -16,8 +16,7 @@
 __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',
-           'ErrorResponse')
+           'shutdown_hook', 'attach', 'setup_logging', 'ErrorResponse')
 
 
 def start_host(session=None):

neovim/api/__init__.py

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

neovim/api/buffer.py

@@ -1,5 +1,5 @@
 """API for working with Nvim buffers."""
-from .common import Remote, RemoteMap
+from .common import Remote
 from ..compat import IS_PYTHON3
 
 
@@ -14,22 +14,11 @@ class Buffer(Remote):
 
     """A remote Nvim buffer."""
 
-    def __init__(self, session, code_data):
-        """Initialize from session and code_data immutable object.
-
-        The `code_data` contains serialization information required for
-        msgpack-rpc calls. It must be immutable for Buffer equality to work.
-        """
-        self._session = session
-        self.code_data = code_data
-        self.vars = RemoteMap(session, 'buffer_get_var', 'buffer_set_var',
-                              self)
-        self.options = RemoteMap(session, 'buffer_get_option',
-                                 'buffer_set_option', self)
+    _api_prefix = "buffer_"
 
     def __len__(self):
         """Return the number of lines contained in a Buffer."""
-        return self._session.request('buffer_line_count', self)
+        return self.request('buffer_line_count')
 
     def __getitem__(self, idx):
         """Get a buffer line or slice by integer index.
@@ -121,7 +110,7 @@ def append(self, lines, index=-1):
 
     def mark(self, name):
         """Return (row, col) tuple for a named mark."""
-        return self._session.request('buffer_get_mark', self, name)
+        return self.request('buffer_get_mark', name)
 
     def range(self, start, end):
         """Return a `Range` object, which represents part of the Buffer."""
@@ -132,34 +121,33 @@ def add_highlight(self, hl_group, line, col_start=0,
         """Add a highlight to the buffer."""
         if async is None:
             async = (src_id != 0)
-        return self._session.request('buffer_add_highlight', self, src_id,
-                                     hl_group, line, col_start,
-                                     col_end, async=async)
+        return self.request('buffer_add_highlight', src_id, hl_group,
+                            line, col_start, col_end, async=async)
 
     def clear_highlight(self, src_id, line_start=0, line_end=-1, async=True):
         """clear highlights from the buffer."""
-        self._session.request('buffer_clear_highlight', self, src_id,
-                              line_start, line_end, async=async)
+        self.request('buffer_clear_highlight', src_id,
+                     line_start, line_end, async=async)
 
     @property
     def name(self):
         """Get the buffer name."""
-        return self._session.request('buffer_get_name', self)
+        return self.request('buffer_get_name')
 
     @name.setter
     def name(self, value):
         """Set the buffer name. BufFilePre/BufFilePost are triggered."""
-        return self._session.request('buffer_set_name', self, value)
+        return self.request('buffer_set_name', value)
 
     @property
     def valid(self):
         """Return True if the buffer still exists."""
-        return self._session.request('buffer_is_valid', self)
+        return self.request('buffer_is_valid')
 
     @property
     def number(self):
         """Get the buffer number."""
-        return self._session.request('buffer_get_number', self)
+        return self.request('buffer_get_number')
 
 
 class Range(object):

neovim/api/common.py

@@ -1,4 +1,5 @@
 """Code shared between the API classes."""
+import functools
 
 
 class Remote(object):
@@ -10,6 +11,20 @@ class Remote(object):
     object handle into consideration.
     """
 
+    def __init__(self, session, code_data):
+        """Initialize from session and code_data immutable object.
+
+        The `code_data` contains serialization information required for
+        msgpack-rpc calls. It must be immutable for Buffer equality to work.
+        """
+        self._session = session
+        self.code_data = code_data
+        self.api = RemoteApi(self, self._api_prefix)
+        self.vars = RemoteMap(self, self._api_prefix + 'get_var',
+                              self._api_prefix + 'set_var')
+        self.options = RemoteMap(self, self._api_prefix + 'get_option',
+                                 self._api_prefix + 'set_option')
+
     def __eq__(self, other):
         """Return True if `self` and `other` are the same object."""
         return (hasattr(other, 'code_data') and
@@ -19,6 +34,24 @@ def __hash__(self):
         """Return hash based on remote object id."""
         return self.code_data.__hash__()
 
+    def request(self, name, *args, **kwargs):
+        """Wrapper for nvim.request."""
+        return self._session.request(name, self, *args, **kwargs)
+
+
+class RemoteApi(object):
+
+    """Wrapper to allow api methods to be called like python methods."""
+
+    def __init__(self, obj, api_prefix):
+        """Initialize a RemoteApi with object and api prefix."""
+        self._obj = obj
+        self._api_prefix = api_prefix
+
+    def __getattr__(self, name):
+        """Return wrapper to named api method."""
+        return functools.partial(self._obj.request, self._api_prefix + name)
+
 
 class RemoteMap(object):
 
@@ -31,12 +64,12 @@ class RemoteMap(object):
     It is used to provide a dict-like API to vim variables and options.
     """
 
-    def __init__(self, session, get_method, set_method, self_obj=None):
+    def __init__(self, obj, get_method, set_method=None, self_obj=None):
         """Initialize a RemoteMap with session, getter/setter and self_obj."""
-        self._get = _wrap(session, get_method, self_obj)
+        self._get = functools.partial(obj.request, get_method)
         self._set = None
         if set_method:
-            self._set = _wrap(session, set_method, self_obj)
+            self._set = functools.partial(obj.request, set_method)
 
     def __getitem__(self, key):
         """Return a map value by key."""
@@ -91,9 +124,9 @@ class RemoteSequence(object):
     locally(iteration, indexing, counting, etc).
     """
 
-    def __init__(self, session, method, self_obj=None):
+    def __init__(self, session, method):
         """Initialize a RemoteSequence with session, method and self_obj."""
-        self._fetch = _wrap(session, method, self_obj)
+        self._fetch = functools.partial(session.request, method)
 
     def __len__(self):
         """Return the length of the remote sequence."""
@@ -120,48 +153,7 @@ def _identity(obj, session, method, kind):
     return obj
 
 
-class SessionHook(object):
-
-    """Pair of functions to filter objects coming/going from/to Nvim.
-
-    Filter functions receive the following arguments:
-
-    - obj: The object to process
-    - session: The current session object
-    - method: The method name
-    - kind: Kind of filter, can be one of:
-        - 'request' for requests coming from Nvim
-        - 'notification' for notifications coming from Nvim
-        - 'out-request' for requests going to Nvim
-
-    Whatever is returned from the function is used as a replacement for `obj`.
-
-    This class also provides a `compose` method for composing hooks.
-    """
-
-    def __init__(self, from_nvim=_identity, to_nvim=_identity):
-        """Initialize a SessionHook with from/to filters."""
-        self.from_nvim = from_nvim
-        self.to_nvim = to_nvim
-
-    def compose(self, other):
-        """Compose two SessionHook instances.
-
-        This works by composing the individual from/to filters and creating
-        a new SessionHook instance with the composed filters.
-        """
-        def comp(f1, f2):
-            if f1 is _identity:
-                return f2
-            if f2 is _identity:
-                return f1
-            return lambda o, s, m, k: f1(f2(o, s, m, k), s, m, k)
-
-        return SessionHook(comp(other.from_nvim, self.from_nvim),
-                           comp(other.to_nvim, self.to_nvim))
-
-
-class DecodeHook(SessionHook):
+class DecodeHook(object):
 
     """SessionHook subclass that decodes utf-8 strings coming from Nvim.
 
@@ -173,9 +165,9 @@ def __init__(self, encoding='utf-8', encoding_errors='strict'):
         """Initialize with encoding and encoding errors policy."""
         self.encoding = encoding
         self.encoding_errors = encoding_errors
-        super(DecodeHook, self).__init__(from_nvim=self._decode_if_bytes)
 
-    def _decode_if_bytes(self, obj, session, method, kind):
+    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
@@ -185,67 +177,7 @@ def walk(self, obj):
 
         Uses encoding and policy specified in constructor.
         """
-        return walk(self._decode_if_bytes, obj, None, None, None)
-
-
-class SessionFilter(object):
-
-    """Wraps a session-like object with a SessionHook instance.
-
-    This class can be used as a drop-in replacement for a sessions, the
-    difference is that a hook is applied to all data passing through a
-    SessionFilter instance.
-    """
-
-    def __init__(self, session, hook):
-        """Initialize with a Session(or SessionFilter) and a hook.
-
-        If `session` is already a SessionFilter, it's hook will be extracted
-        and composed with `hook`.
-        """
-        if isinstance(session, SessionFilter):
-            self._hook = session._hook.compose(hook)
-            self._session = session._session
-        else:
-            self._hook = hook
-            self._session = session
-        # Both filters are applied to `walk` so objects are transformed
-        # recursively
-        self._in = self._hook.from_nvim
-        self._out = self._hook.to_nvim
-
-    def threadsafe_call(self, fn, *args, **kwargs):
-        """Wrapper for Session.threadsafe_call."""
-        self._session.threadsafe_call(fn, *args, **kwargs)
-
-    def next_message(self):
-        """Wrapper for Session.next_message."""
-        msg = self._session.next_message()
-        if msg:
-            return walk(self._in, msg, self, msg[1], msg[0])
-
-    def request(self, name, *args, **kwargs):
-        """Wrapper for Session.request."""
-        args = walk(self._out, args, self, name, 'out-request')
-        return walk(self._in, self._session.request(name, *args, **kwargs),
-                    self, name, 'out-request')
-
-    def run(self, request_cb, notification_cb, setup_cb=None):
-        """Wrapper for Session.run."""
-        def filter_request_cb(name, args):
-            result = request_cb(self._in(name, self, name, 'request'),
-                                walk(self._in, args, self, name, 'request'))
-            return walk(self._out, result, self, name, 'request')
-
-        def filter_notification_cb(name, args):
-            notification_cb(self._in(name, self, name, 'notification'),
-                            walk(self._in, args, self, name, 'notification'))
-
-        self._session.run(filter_request_cb, filter_notification_cb, setup_cb)
-
-    def stop(self):
-        """Wrapper for Session.stop."""
-        self._session.stop()
+        return walk(self.decode_if_bytes, obj)
 
 
 def walk(fn, obj, *args):
@@ -256,10 +188,3 @@ def walk(fn, obj, *args):
         return dict((walk(fn, k, *args), walk(fn, v, *args)) for k, v in
                     obj.items())
     return fn(obj, *args)
-
-
-def _wrap(session, method, self_obj):
-    if self_obj is not None:
-        return lambda *args: session.request(method, self_obj, *args)
-    else:
-        return lambda *args: session.request(method, *args)