Merge pull request #232 from bfredl/newapi

update to api level 1

Author: bfredl

neovim/__init__.py

@@ -12,14 +12,18 @@
                           stdio_session, tcp_session)
 from .plugin import (Host, autocmd, command, decode, encoding, function,
                      plugin, rpc_export, shutdown_hook)
+from .util import Version
 
 
 __all__ = ('tcp_session', 'socket_session', 'stdio_session', 'child_session',
            'start_host', 'autocmd', 'command', 'encoding', 'decode',
-           'function', 'plugin', 'rpc_export', 'Host', 'Nvim',
+           'function', 'plugin', 'rpc_export', 'Host', 'Nvim', 'VERSION',
            'shutdown_hook', 'attach', 'setup_logging', 'ErrorResponse')
 
 
+VERSION = Version(major=0, minor=1, patch=11, prerelease="dev")
+
+
 def start_host(session=None):
     """Promote the current process into python plugin host for Nvim.
 
@@ -64,7 +68,14 @@ def start_host(session=None):
 
     if not session:
         session = stdio_session()
-    host = Host(Nvim.from_session(session))
+    nvim = Nvim.from_session(session)
+
+    if nvim.version.api_level < 1:
+        sys.stderr.write("This version of the neovim python package "
+                         "requires nvim 0.1.6 or later")
+        sys.exit(1)
+
+    host = Host(nvim)
     host.start(plugins)
 
 

neovim/api/buffer.py

@@ -24,7 +24,7 @@ class Buffer(Remote):
 
     """A remote Nvim buffer."""
 
-    _api_prefix = "buffer_"
+    _api_prefix = "nvim_buf_"
 
     def __len__(self):
         """Return the number of lines contained in a Buffer."""
@@ -42,10 +42,10 @@ def __getitem__(self, idx):
         """
         if not isinstance(idx, slice):
             i = adjust_index(idx)
-            return self.request('buffer_get_lines', i, i + 1, True)[0]
+            return self.request('nvim_buf_get_lines', i, i + 1, True)[0]
         start = adjust_index(idx.start, 0)
         end = adjust_index(idx.stop, -1)
-        return self.request('buffer_get_lines', start, end, False)
+        return self.request('nvim_buf_get_lines', start, end, False)
 
     def __setitem__(self, idx, item):
         """Replace a buffer line or slice by integer index.
@@ -58,7 +58,7 @@ def __setitem__(self, idx, item):
         if not isinstance(idx, slice):
             i = adjust_index(idx)
             lines = [item] if item is not None else []
-            return self.request('buffer_set_lines', i, i + 1, True, lines)
+            return self.request('nvim_buf_set_lines', i, i + 1, True, lines)
         lines = item if item is not None else []
         start = adjust_index(idx.start, 0)
         end = adjust_index(idx.stop, -1)
@@ -87,11 +87,11 @@ def append(self, lines, index=-1):
         """Append a string or list of lines to the buffer."""
         if isinstance(lines, (basestring, bytes)):
             lines = [lines]
-        return self.request('buffer_set_lines', index, index, True, lines)
+        return self.request('nvim_buf_set_lines', index, index, True, lines)
 
     def mark(self, name):
         """Return (row, col) tuple for a named mark."""
-        return self.request('buffer_get_mark', name)
+        return self.request('nvim_buf_get_mark', name)
 
     def range(self, start, end):
         """Return a `Range` object, which represents part of the Buffer."""
@@ -102,33 +102,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.request('buffer_add_highlight', src_id, hl_group,
+        return self.request('nvim_buf_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.request('buffer_clear_highlight', src_id,
+        self.request('nvim_buf_clear_highlight', src_id,
                      line_start, line_end, async=async)
 
     @property
     def name(self):
         """Get the buffer name."""
-        return self.request('buffer_get_name')
+        return self.request('nvim_buf_get_name')
 
     @name.setter
     def name(self, value):
         """Set the buffer name. BufFilePre/BufFilePost are triggered."""
-        return self.request('buffer_set_name', value)
+        return self.request('nvim_buf_set_name', value)
 
     @property
     def valid(self):
         """Return True if the buffer still exists."""
-        return self.request('buffer_is_valid')
+        return self.request('nvim_buf_is_valid')
 
     @property
     def number(self):
         """Get the buffer number."""
-        return self.request('buffer_get_number')
+        return self.request('nvim_buf_get_number')
 
 
 class Range(object):

neovim/api/nvim.py

@@ -13,7 +13,7 @@
 from .tabpage import Tabpage
 from .window import Window
 from ..compat import IS_PYTHON3
-from ..util import format_exc_skip
+from ..util import Version, format_exc_skip
 
 __all__ = ('Nvim')
 
@@ -74,14 +74,16 @@ def __init__(self, session, channel_id, metadata, types,
         self._session = session
         self.channel_id = channel_id
         self.metadata = metadata
+        version = metadata.get("version", {"api_level": 0})
+        self.version = Version(**version)
         self.types = types
-        self.api = RemoteApi(self, 'vim_')
-        self.vars = RemoteMap(self, 'vim_get_var', 'vim_set_var')
+        self.api = RemoteApi(self, 'nvim_')
+        self.vars = RemoteMap(self, 'nvim_get_var', 'nvim_set_var')
         self.vvars = RemoteMap(self, 'vim_get_vvar', None)
-        self.options = RemoteMap(self, 'vim_get_option', 'vim_set_option')
+        self.options = RemoteMap(self, 'nvim_get_option', 'nvim_set_option')
         self.buffers = Buffers(self)
-        self.windows = RemoteSequence(self, 'vim_get_windows')
-        self.tabpages = RemoteSequence(self, 'vim_get_tabpages')
+        self.windows = RemoteSequence(self, 'nvim_list_wins')
+        self.tabpages = RemoteSequence(self, 'nvim_list_tabpages')
         self.current = Current(self)
         self.session = CompatibilitySession(self)
         self.funcs = Funcs(self)
@@ -116,8 +118,8 @@ def request(self, name, *args, **kwargs):
 
         is equivalent to
 
-            vim.request('vim_err_write', 'ERROR\n', async=True)
-            vim.request('buffer_get_mark', vim.current.buffer, '.')
+            vim.request('nvim_err_write', 'ERROR\n', async=True)
+            vim.request('nvim_buf_get_mark', vim.current.buffer, '.')
 
 
         Normally a blocking request will be sent.  If the `async` flag is
@@ -205,38 +207,38 @@ def ui_try_resize(self, width, height):
 
     def subscribe(self, event):
         """Subscribe to a Nvim event."""
-        return self.request('vim_subscribe', event)
+        return self.request('nvim_subscribe', event)
 
     def unsubscribe(self, event):
         """Unsubscribe to a Nvim event."""
-        return self.request('vim_unsubscribe', event)
+        return self.request('nvim_unsubscribe', event)
 
     def command(self, string, **kwargs):
         """Execute a single ex command."""
-        return self.request('vim_command', string, **kwargs)
+        return self.request('nvim_command', string, **kwargs)
 
     def command_output(self, string):
         """Execute a single ex command and return the output."""
-        return self.request('vim_command_output', string)
+        return self.request('nvim_command_output', string)
 
     def eval(self, string, **kwargs):
         """Evaluate a vimscript expression."""
-        return self.request('vim_eval', string, **kwargs)
+        return self.request('nvim_eval', string, **kwargs)
 
     def call(self, name, *args, **kwargs):
         """Call a vimscript function."""
-        return self.request('vim_call_function', name, args, **kwargs)
+        return self.request('nvim_call_function', name, args, **kwargs)
 
     def strwidth(self, string):
         """Return the number of display cells `string` occupies.
 
         Tab is counted as one cell.
         """
-        return self.request('vim_strwidth', string)
+        return self.request('nvim_strwidth', string)
 
     def list_runtime_paths(self):
         """Return a list of paths contained in the 'runtimepath' option."""
-        return self.request('vim_list_runtime_paths')
+        return self.request('nvim_list_runtime_paths')
 
     def foreach_rtp(self, cb):
         """Invoke `cb` for each path in 'runtimepath'.
@@ -246,7 +248,7 @@ def foreach_rtp(self, cb):
         are no longer paths. If stopped in case callable returned non-None,
         vim.foreach_rtp function returns the value returned by callable.
         """
-        for path in self.request('vim_list_runtime_paths'):
+        for path in self.request('nvim_list_runtime_paths'):
             try:
                 if cb(path) is not None:
                     break
@@ -256,7 +258,7 @@ def foreach_rtp(self, cb):
     def chdir(self, dir_path):
         """Run os.chdir, then all appropriate vim stuff."""
         os_chdir(dir_path)
-        return self.request('vim_change_directory', dir_path)
+        return self.request('nvim_set_current_dir', dir_path)
 
     def feedkeys(self, keys, options='', escape_csi=True):
         """Push `keys` to Nvim user input buffer.
@@ -267,7 +269,7 @@ def feedkeys(self, keys, options='', escape_csi=True):
         - 't': Handle keys as if typed; otherwise they are handled as if coming
                from a mapping. This matters for undo, opening folds, etc.
         """
-        return self.request('vim_feedkeys', keys, options, escape_csi)
+        return self.request('nvim_feedkeys', keys, options, escape_csi)
 
     def input(self, bytes):
         """Push `bytes` to Nvim low level input buffer.
@@ -277,7 +279,7 @@ def input(self, bytes):
         written(which can be less than what was requested if the buffer is
         full).
         """
-        return self.request('vim_input', bytes)
+        return self.request('nvim_input', bytes)
 
     def replace_termcodes(self, string, from_part=False, do_lt=True,
                           special=True):
@@ -298,11 +300,11 @@ def replace_termcodes(self, string, from_part=False, do_lt=True,
 
     def out_write(self, msg):
         """Print `msg` as a normal message."""
-        return self.request('vim_out_write', msg)
+        return self.request('nvim_out_write', msg)
 
     def err_write(self, msg, **kwargs):
         """Print `msg` as an error message."""
-        return self.request('vim_err_write', msg, **kwargs)
+        return self.request('nvim_err_write', msg, **kwargs)
 
     def quit(self, quit_command='qa!'):
         """Send a quit command to Nvim.
@@ -359,7 +361,7 @@ class Buffers(object):
 
     def __init__(self, nvim):
         """Initialize a Buffers object with Nvim object `nvim`."""
-        self._fetch_buffers = nvim.api.get_buffers
+        self._fetch_buffers = nvim.api.list_bufs
 
     def __len__(self):
         """Return the count of buffers."""
@@ -399,35 +401,35 @@ def __init__(self, session):
 
     @property
     def line(self):
-        return self._session.request('vim_get_current_line')
+        return self._session.request('nvim_get_current_line')
 
     @line.setter
     def line(self, line):
-        return self._session.request('vim_set_current_line', line)
+        return self._session.request('nvim_set_current_line', line)
 
     @property
     def buffer(self):
-        return self._session.request('vim_get_current_buffer')
+        return self._session.request('nvim_get_current_buf')
 
     @buffer.setter
     def buffer(self, buffer):
-        return self._session.request('vim_set_current_buffer', buffer)
+        return self._session.request('nvim_set_current_buf', buffer)
 
     @property
     def window(self):
-        return self._session.request('vim_get_current_window')
+        return self._session.request('nvim_get_current_win')
 
     @window.setter
     def window(self, window):
-        return self._session.request('vim_set_current_window', window)
+        return self._session.request('nvim_set_current_win', window)
 
     @property
     def tabpage(self):
-        return self._session.request('vim_get_current_tabpage')
+        return self._session.request('nvim_get_current_tabpage')
 
     @tabpage.setter
     def tabpage(self, tabpage):
-        return self._session.request('vim_set_current_tabpage', tabpage)
+        return self._session.request('nvim_set_current_tabpage', tabpage)
 
 
 class Funcs(object):

neovim/api/tabpage.py

@@ -8,7 +8,7 @@
 class Tabpage(Remote):
     """A remote Nvim tabpage."""
 
-    _api_prefix = "tabpage_"
+    _api_prefix = "nvim_tabpage_"
 
     def __init__(self, *args):
         """Initialize from session and code_data immutable object.
@@ -17,17 +17,17 @@ def __init__(self, *args):
         msgpack-rpc calls. It must be immutable for Buffer equality to work.
         """
         super(Tabpage, self).__init__(*args)
-        self.windows = RemoteSequence(self, 'tabpage_get_windows')
+        self.windows = RemoteSequence(self, 'nvim_tabpage_list_wins')
 
     @property
     def window(self):
         """Get the `Window` currently focused on the tabpage."""
-        return self.request('tabpage_get_window')
+        return self.request('nvim_tabpage_get_win')
 
     @property
     def valid(self):
         """Return True if the tabpage still exists."""
-        return self.request('tabpage_is_valid')
+        return self.request('nvim_tabpage_is_valid')
 
     @property
     def number(self):