+++ /dev/null
-"""Legacy python/python3-vim emulation."""
-import imp
-import io
-import logging
-import os
-import sys
-from types import ModuleType
-
-from pynvim.api import Nvim, walk
-from pynvim.compat import IS_PYTHON3
-from pynvim.msgpack_rpc import ErrorResponse
-from pynvim.plugin.decorators import plugin, rpc_export
-from pynvim.util import format_exc_skip
-
-__all__ = ('ScriptHost',)
-
-
-logger = logging.getLogger(__name__)
-debug, info, warn = (logger.debug, logger.info, logger.warn,)
-
-if IS_PYTHON3:
- basestring = str
-
- if sys.version_info >= (3, 4):
- from importlib.machinery import PathFinder
-
- PYTHON_SUBDIR = 'python3'
-else:
- PYTHON_SUBDIR = 'python2'
-
-
-@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 = ModuleType('__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 = LegacyVim.from_nvim(nvim)
- sys.modules['vim'] = self.legacy_vim
- # mimic Vim by importing vim module by default.
- exec('import vim', self.module.__dict__)
- # Handle DirChanged. #296
- nvim.command(
- 'au DirChanged * call rpcnotify({}, "python_chdir", v:event.cwd)'
- .format(nvim.channel_id), async_=True)
- # XXX: Avoid race condition.
- # https://github.com/neovim/pynvim/pull/296#issuecomment-358970531
- # TODO(bfredl): when host initialization has been refactored,
- # to make __init__ safe again, the following should work:
- # os.chdir(nvim.eval('getcwd()', async_=False))
- nvim.command('call rpcnotify({}, "python_chdir", getcwd())'
- .format(nvim.channel_id), async_=True)
-
- 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
- pass # replaces next logging statement
- #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)
- pass # replaces next logging statement
- #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."""
- nvim = self.nvim
- pass # replaces next logging statement
- #info('uninstall import hook/path')
- sys.path.remove(nvim.VIM_SPECIAL_PATH)
- sys.path_hooks.remove(self.hook)
- pass # replaces next logging statement
- #info('restore sys.stdout and sys.stderr')
- sys.stdout = self.saved_stdout
- sys.stderr = self.saved_stderr
-
- @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)
- try:
- exec(script, self.module.__dict__)
- except Exception:
- raise ErrorResponse(format_exc_skip(1))
-
- @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')
- try:
- exec(script, self.module.__dict__)
- except Exception:
- raise ErrorResponse(format_exc_skip(1))
-
- @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
- 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.api.get_lines(sstart, sstop, 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.api.set_lines(sstart, end,
- 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
- if newlines:
- end = sstart + len(newlines)
- nvim.current.buffer.api.set_lines(sstart, end, True, newlines)
- if exception:
- raise exception
- # delete the function
- del self.module.__dict__[fname]
-
- @rpc_export('python_eval', sync=True)
- def python_eval(self, expr):
- """Handle the `pyeval` vim function."""
- return eval(expr, self.module.__dict__)
-
- @rpc_export('python_chdir', sync=False)
- def python_chdir(self, cwd):
- """Handle working directory changes."""
- os.chdir(cwd)
-
- 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))
-
-
-if IS_PYTHON3:
- num_types = (int, float)
-else:
- num_types = (int, long, float) # noqa: F821
-
-
-def num_to_str(obj):
- if isinstance(obj, num_types):
- return str(obj)
- else:
- return obj
-
-
-class LegacyVim(Nvim):
- def eval(self, expr):
- obj = self.request("vim_eval", expr)
- return walk(num_to_str, obj)
-
-
-# Copied/adapted from :help if_pyth.
-def path_hook(nvim):
- def _get_paths():
- if nvim._thread_invalid():
- return []
- 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).
- try:
- return sys.modules[fullname]
- except KeyError:
- pass
- 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, target=None):
- """Method for Python 3.4+."""
- return PathFinder.find_spec(fullname, _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 rtp in nvim.list_runtime_paths():
- if not os.path.exists(rtp):
- continue
- for subdir in ['pythonx', PYTHON_SUBDIR]:
- path = os.path.join(rtp, subdir)
- if os.path.exists(path):
- rv.append(path)
- return rv
projects / dotfiles / .git / blobdiff