Refactor Remote and implement RemoteApi object

Author: bfredl

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."""
@@ -155,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)

neovim/api/nvim.py

@@ -7,7 +7,8 @@
 from msgpack import ExtType
 
 from .buffer import Buffer
-from .common import (DecodeHook, Remote, RemoteMap, RemoteSequence, walk)
+from .common import (DecodeHook, Remote, RemoteApi,
+                     RemoteMap, RemoteSequence, walk)
 from .tabpage import Tabpage
 from .window import Window
 from ..compat import IS_PYTHON3
@@ -65,6 +66,7 @@ def __init__(self, session, channel_id, metadata, types, decodehook=None):
         self.channel_id = channel_id
         self.metadata = metadata
         self.types = types
+        self.api = RemoteApi(self, 'vim_')
         self.vars = RemoteMap(self, 'vim_get_var', 'vim_set_var')
         self.vvars = RemoteMap(self, 'vim_get_vvar', None)
         self.options = RemoteMap(self, 'vim_get_option', 'vim_set_option')
@@ -90,15 +92,24 @@ def _to_nvim(self, obj):
         return obj
 
     def request(self, name, *args, **kwargs):
-        """Send an API request or notification to nvim.
+        r"""Send an API request or notification to nvim.
 
-        It is rarely needed for a plugin to call this function directly, as high
-        As most API functions have python wrapper functions.
+        It is rarely needed to call this function directly, as most API
+        functions have python wrapper functions. The `api` object can
+        be also be used to call API functions as methods:
 
-        Normally a blocking request will be sent.
-        If the `async` flag is present and True, a asynchronous notification is
-        sent instead. This will never block, and the return value or error is
-        ignored.
+            vim.api.err_write('ERROR\n', async=True)
+            vim.current.buffer.api.get_mark('.')
+
+        is equivalent to
+
+            vim.request('vim_err_write', 'ERROR\n', async=True)
+            vim.request('buffer_get_mark', vim.current.buffer, '.')
+
+
+        Normally a blocking request will be sent.  If the `async` flag is
+        present and True, a asynchronous notification is sent instead. This
+        will never block, and the return value or error is ignored.
         """
         args = walk(self._to_nvim, args)
         res = self._session.request(name, *args, **kwargs)

neovim/api/tabpage.py

@@ -1,32 +1,30 @@
 """API for working with Nvim tabpages."""
-from .common import Remote, RemoteMap, RemoteSequence
+from .common import Remote, RemoteSequence
 
 
 __all__ = ('Tabpage')
 
 
 class Tabpage(Remote):
-
     """A remote Nvim tabpage."""
 
-    def __init__(self, session, code_data):
+    _api_prefix = "tabpage_"
+
+    def __init__(self, *args):
         """Initialize from session and code_data immutable object.
 
         The `code_data` contains serialization information required for
-        msgpack-rpc calls. It must be immutable for Tabpage equality to work.
+        msgpack-rpc calls. It must be immutable for Buffer equality to work.
         """
-        self._session = session
-        self.code_data = code_data
-        self.windows = RemoteSequence(session, 'tabpage_get_windows', self)
-        self.vars = RemoteMap(session, 'tabpage_get_var', 'tabpage_set_var',
-                              self)
+        super(Tabpage, self).__init__(*args)
+        self.windows = RemoteSequence(self, 'tabpage_get_windows')
 
     @property
     def window(self):
         """Get the `Window` currently focused on the tabpage."""
-        return self._session.request('tabpage_get_window', self)
+        return self.request('tabpage_get_window')
 
     @property
     def valid(self):
         """Return True if the tabpage still exists."""
-        return self._session.request('tabpage_is_valid', self)
+        return self.request('tabpage_is_valid')

neovim/api/window.py

@@ -1,5 +1,5 @@
 """API for working with Nvim windows."""
-from .common import Remote, RemoteMap
+from .common import Remote
 
 
 __all__ = ('Window')
@@ -9,70 +9,59 @@ class Window(Remote):
 
     """A remote Nvim window."""
 
-    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 Window equality to work.
-        """
-        self._session = session
-        self.code_data = code_data
-        self.vars = RemoteMap(session, 'window_get_var', 'window_set_var',
-                              self)
-        self.options = RemoteMap(session, 'window_get_option',
-                                 'window_set_option', self)
+    _api_prefix = "window_"
 
     @property
     def buffer(self):
         """Get the `Buffer` currently being displayed by the window."""
-        return self._session.request('window_get_buffer', self)
+        return self.request('window_get_buffer')
 
     @property
     def cursor(self):
         """Get the (row, col) tuple with the current cursor position."""
-        return self._session.request('window_get_cursor', self)
+        return self.request('window_get_cursor')
 
     @cursor.setter
     def cursor(self, pos):
         """Set the (row, col) tuple as the new cursor position."""
-        return self._session.request('window_set_cursor', self, pos)
+        return self.request('window_set_cursor', pos)
 
     @property
     def height(self):
         """Get the window height in rows."""
-        return self._session.request('window_get_height', self)
+        return self.request('window_get_height')
 
     @height.setter
     def height(self, height):
         """Set the window height in rows."""
-        return self._session.request('window_set_height', self, height)
+        return self.request('window_set_height', height)
 
     @property
     def width(self):
         """Get the window width in rows."""
-        return self._session.request('window_get_width', self)
+        return self.request('window_get_width')
 
     @width.setter
     def width(self, width):
         """Set the window height in rows."""
-        return self._session.request('window_set_width', self, width)
+        return self.request('window_set_width', width)
 
     @property
     def row(self):
         """0-indexed, on-screen window position(row) in display cells."""
-        return self._session.request('window_get_position', self)[0]
+        return self.request('window_get_position')[0]
 
     @property
     def col(self):
         """0-indexed, on-screen window position(col) in display cells."""
-        return self._session.request('window_get_position', self)[1]
+        return self.request('window_get_position')[1]
 
     @property
     def tabpage(self):
         """Get the `Tabpage` that contains the window."""
-        return self._session.request('window_get_tabpage', self)
+        return self.request('window_get_tabpage')
 
     @property
     def valid(self):
         """Return True if the window still exists."""
-        return self._session.request('window_is_valid', self)
+        return self.request('window_is_valid')