mirror of
https://github.com/neovim/neovim.git
synced 2024-12-20 11:15:14 -07:00
python: move script_host.py to python-client
This commit is contained in:
Björn Linse
parent
e7a9c006e1
commit
89bb5a8ab8
@ -24,12 +24,10 @@ if s:prog == ''
|
||||
finish
|
||||
endif
|
||||
|
||||
let s:plugin_path = expand('<sfile>:p:h').'/script_host.py'
|
||||
|
||||
" The Python provider plugin will run in a separate instance of the Python
|
||||
" host.
|
||||
call remote#host#RegisterClone('legacy-python-provider', 'python')
|
||||
call remote#host#RegisterPlugin('legacy-python-provider', s:plugin_path, [])
|
||||
call remote#host#RegisterPlugin('legacy-python-provider', 'script_host.py', [])
|
||||
|
||||
function! provider#python#Call(method, args)
|
||||
if s:err != ''
|
||||
|
||||
@ -24,12 +24,10 @@ if s:prog == ''
|
||||
finish
|
||||
endif
|
||||
|
||||
let s:plugin_path = expand('<sfile>:p:h').'/script_host.py'
|
||||
|
||||
" The Python3 provider plugin will run in a separate instance of the Python3
|
||||
" host.
|
||||
call remote#host#RegisterClone('legacy-python3-provider', 'python3')
|
||||
call remote#host#RegisterPlugin('legacy-python3-provider', s:plugin_path, [])
|
||||
call remote#host#RegisterPlugin('legacy-python3-provider', 'script_host.py', [])
|
||||
|
||||
function! provider#python3#Call(method, args)
|
||||
if s:err != ''
|
||||
|
||||
@ -1,247 +0,0 @@
|
||||
"""Legacy python/python3-vim emulation."""
|
||||
import imp
|
||||
import io
|
||||
import logging
|
||||
import os
|
||||
import sys
|
||||
|
||||
import neovim
|
||||
|
||||
__all__ = ('ScriptHost',)
|
||||
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
debug, info, warn = (logger.debug, logger.info, logger.warn,)
|
||||
|
||||
IS_PYTHON3 = sys.version_info >= (3, 0)
|
||||
|
||||
if IS_PYTHON3:
|
||||
basestring = str
|
||||
|
||||
if sys.version_info >= (3, 4):
|
||||
from importlib.machinery import PathFinder
|
||||
|
||||
|
||||
@neovim.plugin
|
||||
class ScriptHost(object):
|
||||
|
||||
"""Provides an environment for running python plugins created for Vim."""
|
||||
|
||||
def __init__(self, nvim):
|
||||
"""Initialize the legacy python-vim environment."""
|
||||
self.setup(nvim)
|
||||
# context where all code will run
|
||||
self.module = imp.new_module('__main__')
|
||||
nvim.script_context = self.module
|
||||
# it seems some plugins assume 'sys' is already imported, so do it now
|
||||
exec('import sys', self.module.__dict__)
|
||||
self.legacy_vim = nvim.with_hook(LegacyEvalHook())
|
||||
sys.modules['vim'] = self.legacy_vim
|
||||
|
||||
def setup(self, nvim):
|
||||
"""Setup import hooks and global streams.
|
||||
|
||||
This will add import hooks for importing modules from runtime
|
||||
directories and patch the sys module so 'print' calls will be
|
||||
forwarded to Nvim.
|
||||
"""
|
||||
self.nvim = nvim
|
||||
info('install import hook/path')
|
||||
self.hook = path_hook(nvim)
|
||||
sys.path_hooks.append(self.hook)
|
||||
nvim.VIM_SPECIAL_PATH = '_vim_path_'
|
||||
sys.path.append(nvim.VIM_SPECIAL_PATH)
|
||||
info('redirect sys.stdout and sys.stderr')
|
||||
self.saved_stdout = sys.stdout
|
||||
self.saved_stderr = sys.stderr
|
||||
sys.stdout = RedirectStream(lambda data: nvim.out_write(data))
|
||||
sys.stderr = RedirectStream(lambda data: nvim.err_write(data))
|
||||
|
||||
def teardown(self):
|
||||
"""Restore state modified from the `setup` call."""
|
||||
for plugin in self.installed_plugins:
|
||||
if hasattr(plugin, 'on_teardown'):
|
||||
plugin.teardown()
|
||||
nvim = self.nvim
|
||||
info('uninstall import hook/path')
|
||||
sys.path.remove(nvim.VIM_SPECIAL_PATH)
|
||||
sys.path_hooks.remove(self.hook)
|
||||
info('restore sys.stdout and sys.stderr')
|
||||
sys.stdout = self.saved_stdout
|
||||
sys.stderr = self.saved_stderr
|
||||
|
||||
@neovim.rpc_export('python_execute', sync=True)
|
||||
def python_execute(self, script, range_start, range_stop):
|
||||
"""Handle the `python` ex command."""
|
||||
self._set_current_range(range_start, range_stop)
|
||||
exec(script, self.module.__dict__)
|
||||
|
||||
@neovim.rpc_export('python_execute_file', sync=True)
|
||||
def python_execute_file(self, file_path, range_start, range_stop):
|
||||
"""Handle the `pyfile` ex command."""
|
||||
self._set_current_range(range_start, range_stop)
|
||||
with open(file_path) as f:
|
||||
script = compile(f.read(), file_path, 'exec')
|
||||
exec(script, self.module.__dict__)
|
||||
|
||||
@neovim.rpc_export('python_do_range', sync=True)
|
||||
def python_do_range(self, start, stop, code):
|
||||
"""Handle the `pydo` ex command."""
|
||||
self._set_current_range(start, stop)
|
||||
nvim = self.nvim
|
||||
start -= 1
|
||||
stop -= 1
|
||||
fname = '_vim_pydo'
|
||||
|
||||
# define the function
|
||||
function_def = 'def %s(line, linenr):\n %s' % (fname, code,)
|
||||
exec(function_def, self.module.__dict__)
|
||||
# get the function
|
||||
function = self.module.__dict__[fname]
|
||||
while start <= stop:
|
||||
# Process batches of 5000 to avoid the overhead of making multiple
|
||||
# API calls for every line. Assuming an average line length of 100
|
||||
# bytes, approximately 488 kilobytes will be transferred per batch,
|
||||
# which can be done very quickly in a single API call.
|
||||
sstart = start
|
||||
sstop = min(start + 5000, stop)
|
||||
lines = nvim.current.buffer.get_line_slice(sstart, sstop, True,
|
||||
True)
|
||||
|
||||
exception = None
|
||||
newlines = []
|
||||
linenr = sstart + 1
|
||||
for i, line in enumerate(lines):
|
||||
result = function(line, linenr)
|
||||
if result is None:
|
||||
# Update earlier lines, and skip to the next
|
||||
if newlines:
|
||||
end = sstart + len(newlines) - 1
|
||||
nvim.current.buffer.set_line_slice(sstart, end,
|
||||
True, True,
|
||||
newlines)
|
||||
sstart += len(newlines) + 1
|
||||
newlines = []
|
||||
pass
|
||||
elif isinstance(result, basestring):
|
||||
newlines.append(result)
|
||||
else:
|
||||
exception = TypeError('pydo should return a string ' +
|
||||
'or None, found %s instead'
|
||||
% result.__class__.__name__)
|
||||
break
|
||||
linenr += 1
|
||||
|
||||
start = sstop + 1
|
||||
if newlines:
|
||||
end = sstart + len(newlines) - 1
|
||||
nvim.current.buffer.set_line_slice(sstart, end, True, True,
|
||||
newlines)
|
||||
if exception:
|
||||
raise exception
|
||||
# delete the function
|
||||
del self.module.__dict__[fname]
|
||||
|
||||
@neovim.rpc_export('python_eval', sync=True)
|
||||
def python_eval(self, expr):
|
||||
"""Handle the `pyeval` vim function."""
|
||||
return eval(expr, self.module.__dict__)
|
||||
|
||||
def _set_current_range(self, start, stop):
|
||||
current = self.legacy_vim.current
|
||||
current.range = current.buffer.range(start, stop)
|
||||
|
||||
|
||||
class RedirectStream(io.IOBase):
|
||||
def __init__(self, redirect_handler):
|
||||
self.redirect_handler = redirect_handler
|
||||
|
||||
def write(self, data):
|
||||
self.redirect_handler(data)
|
||||
|
||||
def writelines(self, seq):
|
||||
self.redirect_handler('\n'.join(seq))
|
||||
|
||||
|
||||
class LegacyEvalHook(neovim.SessionHook):
|
||||
|
||||
"""Injects legacy `vim.eval` behavior to a Nvim instance."""
|
||||
|
||||
def __init__(self):
|
||||
super(LegacyEvalHook, self).__init__(from_nvim=self._string_eval)
|
||||
|
||||
def _string_eval(self, obj, session, method, kind):
|
||||
if method == 'vim_eval':
|
||||
if IS_PYTHON3:
|
||||
if isinstance(obj, (int, float)):
|
||||
return str(obj)
|
||||
elif isinstance(obj, (int, long, float)):
|
||||
return str(obj)
|
||||
return obj
|
||||
|
||||
|
||||
# This was copied/adapted from nvim-python help
|
||||
def path_hook(nvim):
|
||||
def _get_paths():
|
||||
return discover_runtime_directories(nvim)
|
||||
|
||||
def _find_module(fullname, oldtail, path):
|
||||
idx = oldtail.find('.')
|
||||
if idx > 0:
|
||||
name = oldtail[:idx]
|
||||
tail = oldtail[idx+1:]
|
||||
fmr = imp.find_module(name, path)
|
||||
module = imp.find_module(fullname[:-len(oldtail)] + name, *fmr)
|
||||
return _find_module(fullname, tail, module.__path__)
|
||||
else:
|
||||
return imp.find_module(fullname, path)
|
||||
|
||||
class VimModuleLoader(object):
|
||||
def __init__(self, module):
|
||||
self.module = module
|
||||
|
||||
def load_module(self, fullname, path=None):
|
||||
# Check sys.modules, required for reload (see PEP302).
|
||||
if fullname in sys.modules:
|
||||
return sys.modules[fullname]
|
||||
return imp.load_module(fullname, *self.module)
|
||||
|
||||
class VimPathFinder(object):
|
||||
@staticmethod
|
||||
def find_module(fullname, path=None):
|
||||
"Method for Python 2.7 and 3.3."
|
||||
try:
|
||||
return VimModuleLoader(
|
||||
_find_module(fullname, fullname, path or _get_paths()))
|
||||
except ImportError:
|
||||
return None
|
||||
|
||||
@staticmethod
|
||||
def find_spec(fullname, path=None, target=None):
|
||||
"Method for Python 3.4+."
|
||||
return PathFinder.find_spec(fullname, path or _get_paths(), target)
|
||||
|
||||
def hook(path):
|
||||
if path == nvim.VIM_SPECIAL_PATH:
|
||||
return VimPathFinder
|
||||
else:
|
||||
raise ImportError
|
||||
|
||||
return hook
|
||||
|
||||
|
||||
def discover_runtime_directories(nvim):
|
||||
rv = []
|
||||
for path in nvim.list_runtime_paths():
|
||||
if not os.path.exists(path):
|
||||
continue
|
||||
path1 = os.path.join(path, 'pythonx')
|
||||
if IS_PYTHON3:
|
||||
path2 = os.path.join(path, 'python3')
|
||||
else:
|
||||
path2 = os.path.join(path, 'python2')
|
||||
if os.path.exists(path1):
|
||||
rv.append(path1)
|
||||
if os.path.exists(path2):
|
||||
rv.append(path2)
|
||||
return rv
|
||||
Loading…
Reference in New Issue
Block a user