1211 lines
40 KiB
Python
1211 lines
40 KiB
Python
# -*- coding: utf-8 -*-
|
|
"""
|
|
The Python parts of the Jedi library for VIM. It is mostly about communicating
|
|
with VIM.
|
|
"""
|
|
|
|
from typing import Optional
|
|
import traceback # for exception output
|
|
import re
|
|
import os
|
|
import sys
|
|
from shlex import split as shsplit
|
|
from contextlib import contextmanager
|
|
from pathlib import Path
|
|
try:
|
|
from itertools import zip_longest
|
|
except ImportError:
|
|
from itertools import izip_longest as zip_longest # Python 2
|
|
|
|
import vim
|
|
|
|
is_py3 = sys.version_info[0] >= 3
|
|
if is_py3:
|
|
ELLIPSIS = "…"
|
|
unicode = str
|
|
else:
|
|
ELLIPSIS = u"…"
|
|
|
|
|
|
try:
|
|
# Somehow sys.prefix is set in combination with VIM and virtualenvs.
|
|
# However the sys path is not affected. Just reset it to the normal value.
|
|
sys.prefix = sys.base_prefix
|
|
sys.exec_prefix = sys.base_exec_prefix
|
|
except AttributeError:
|
|
# If we're not in a virtualenv we don't care. Everything is fine.
|
|
pass
|
|
|
|
|
|
class PythonToVimStr(unicode):
|
|
""" Vim has a different string implementation of single quotes """
|
|
__slots__ = []
|
|
|
|
def __new__(cls, obj, encoding='UTF-8'):
|
|
if not (is_py3 or isinstance(obj, unicode)):
|
|
obj = unicode.__new__(cls, obj, encoding)
|
|
|
|
# Vim cannot deal with zero bytes:
|
|
obj = obj.replace('\0', '\\0')
|
|
return unicode.__new__(cls, obj)
|
|
|
|
def __repr__(self):
|
|
# this is totally stupid and makes no sense but vim/python unicode
|
|
# support is pretty bad. don't ask how I came up with this... It just
|
|
# works...
|
|
# It seems to be related to that bug: http://bugs.python.org/issue5876
|
|
if unicode is str:
|
|
s = self
|
|
else:
|
|
s = self.encode('UTF-8')
|
|
return '"%s"' % s.replace('\\', '\\\\').replace('"', r'\"')
|
|
|
|
|
|
class VimError(Exception):
|
|
def __init__(self, message, throwpoint, executing):
|
|
super(type(self), self).__init__(message)
|
|
self.message = message
|
|
self.throwpoint = throwpoint
|
|
self.executing = executing
|
|
|
|
def __str__(self):
|
|
return "{}; created by {!r} (in {})".format(
|
|
self.message, self.executing, self.throwpoint
|
|
)
|
|
|
|
|
|
def _catch_exception(string, is_eval):
|
|
"""
|
|
Interface between vim and python calls back to it.
|
|
Necessary, because the exact error message is not given by `vim.error`.
|
|
"""
|
|
result = vim.eval('jedi#_vim_exceptions({0}, {1})'.format(
|
|
repr(PythonToVimStr(string, 'UTF-8')), int(is_eval)))
|
|
if 'exception' in result:
|
|
raise VimError(result['exception'], result['throwpoint'], string)
|
|
return result['result']
|
|
|
|
|
|
def vim_command(string):
|
|
_catch_exception(string, is_eval=False)
|
|
|
|
|
|
def vim_eval(string):
|
|
return _catch_exception(string, is_eval=True)
|
|
|
|
|
|
def no_jedi_warning(error=None):
|
|
vim.command('echohl WarningMsg')
|
|
vim.command('echom "Please install Jedi if you want to use jedi-vim."')
|
|
if error:
|
|
vim.command('echom "The error was: {0}"'.format(error))
|
|
vim.command('echohl None')
|
|
|
|
|
|
def echo_highlight(msg):
|
|
vim_command('echohl WarningMsg | echom "jedi-vim: {0}" | echohl None'.format(
|
|
str(msg).replace('"', '\\"')))
|
|
|
|
|
|
jedi_path = os.path.join(os.path.dirname(__file__), 'jedi')
|
|
sys.path.insert(0, jedi_path)
|
|
parso_path = os.path.join(os.path.dirname(__file__), 'parso')
|
|
sys.path.insert(0, parso_path)
|
|
|
|
try:
|
|
import jedi
|
|
except ImportError:
|
|
jedi = None
|
|
jedi_import_error = sys.exc_info()
|
|
else:
|
|
try:
|
|
version = jedi.__version__
|
|
except Exception as e: # e.g. AttributeError
|
|
echo_highlight(
|
|
"Error when loading the jedi python module ({0}). "
|
|
"Please ensure that Jedi is installed correctly (see Installation "
|
|
"in the README.".format(e))
|
|
jedi = None
|
|
else:
|
|
if isinstance(version, str):
|
|
# the normal use case, now.
|
|
from jedi import utils
|
|
version = utils.version_info()
|
|
if version < (0, 7):
|
|
echo_highlight('Please update your Jedi version, it is too old.')
|
|
finally:
|
|
sys.path.remove(jedi_path)
|
|
sys.path.remove(parso_path)
|
|
|
|
|
|
class VimCompat:
|
|
_eval_cache = {}
|
|
_func_cache = {}
|
|
|
|
@classmethod
|
|
def has(cls, what):
|
|
try:
|
|
return cls._eval_cache[what]
|
|
except KeyError:
|
|
ret = cls._eval_cache[what] = cls.call('has', what)
|
|
return ret
|
|
|
|
@classmethod
|
|
def call(cls, func, *args):
|
|
try:
|
|
f = cls._func_cache[func]
|
|
except KeyError:
|
|
if IS_NVIM:
|
|
f = cls._func_cache[func] = getattr(vim.funcs, func)
|
|
else:
|
|
f = cls._func_cache[func] = vim.Function(func)
|
|
return f(*args)
|
|
|
|
@classmethod
|
|
def setqflist(cls, items, title, context):
|
|
if cls.has('patch-7.4.2200'): # can set qf title.
|
|
what = {'title': title}
|
|
if cls.has('patch-8.0.0590'): # can set qf context
|
|
what['context'] = {'jedi_usages': context}
|
|
if cls.has('patch-8.0.0657'): # can set items via "what".
|
|
what['items'] = items
|
|
cls.call('setqflist', [], ' ', what)
|
|
else:
|
|
# Can set title (and maybe context), but needs two calls.
|
|
cls.call('setqflist', items)
|
|
cls.call('setqflist', items, 'a', what)
|
|
else:
|
|
cls.call('setqflist', items)
|
|
|
|
@classmethod
|
|
def setqflist_title(cls, title):
|
|
if cls.has('patch-7.4.2200'):
|
|
cls.call('setqflist', [], 'a', {'title': title})
|
|
|
|
@classmethod
|
|
def can_update_current_qflist_for_context(cls, context):
|
|
if cls.has('patch-8.0.0590'): # can set qf context
|
|
return cls.call('getqflist', {'context': 1})['context'] == {
|
|
'jedi_usages': context,
|
|
}
|
|
|
|
|
|
def catch_and_print_exceptions(func):
|
|
def wrapper(*args, **kwargs):
|
|
try:
|
|
return func(*args, **kwargs)
|
|
except (Exception, vim.error):
|
|
print(traceback.format_exc())
|
|
return None
|
|
return wrapper
|
|
|
|
|
|
def _check_jedi_availability(show_error=False):
|
|
def func_receiver(func):
|
|
def wrapper(*args, **kwargs):
|
|
if jedi is None:
|
|
if show_error:
|
|
no_jedi_warning()
|
|
return
|
|
else:
|
|
return func(*args, **kwargs)
|
|
return wrapper
|
|
return func_receiver
|
|
|
|
|
|
# Tuple of cache key / project
|
|
_current_project_cache = None, None
|
|
|
|
|
|
def get_project():
|
|
vim_environment_path = vim_eval(
|
|
"get(b:, 'jedi_environment_path', g:jedi#environment_path)"
|
|
)
|
|
vim_project_path = vim_eval("g:jedi#project_path")
|
|
|
|
vim_added_sys_path = vim_eval("get(g:, 'jedi#added_sys_path', [])")
|
|
vim_added_sys_path += vim_eval("get(b:, 'jedi_added_sys_path', [])")
|
|
|
|
global _current_project_cache
|
|
cache_key = dict(project_path=vim_project_path,
|
|
environment_path=vim_environment_path,
|
|
added_sys_path=vim_added_sys_path)
|
|
if cache_key == _current_project_cache[0]:
|
|
return _current_project_cache[1]
|
|
|
|
if vim_environment_path in ("auto", "", None):
|
|
environment_path = None
|
|
else:
|
|
environment_path = vim_environment_path
|
|
|
|
if vim_project_path in ("auto", "", None):
|
|
project_path = jedi.get_default_project().path
|
|
else:
|
|
project_path = vim_project_path
|
|
|
|
project = jedi.Project(project_path,
|
|
environment_path=environment_path,
|
|
added_sys_path=vim_added_sys_path)
|
|
|
|
_current_project_cache = cache_key, project
|
|
return project
|
|
|
|
|
|
@catch_and_print_exceptions
|
|
def choose_environment():
|
|
args = shsplit(vim.eval('a:args'))
|
|
|
|
envs = list(jedi.find_system_environments())
|
|
envs.extend(jedi.find_virtualenvs(paths=args or None))
|
|
|
|
env_paths = [env.executable for env in envs]
|
|
|
|
vim_command('belowright new')
|
|
vim.current.buffer[:] = env_paths
|
|
vim.current.buffer.name = "Hit Enter to Choose an Environment"
|
|
vim_command(
|
|
'setlocal buftype=nofile bufhidden=wipe noswapfile nobuflisted readonly nomodifiable')
|
|
vim_command('noremap <buffer> <ESC> :bw<CR>')
|
|
vim_command('noremap <buffer> <CR> :python3 jedi_vim.choose_environment_hit_enter()<CR>')
|
|
|
|
|
|
@catch_and_print_exceptions
|
|
def choose_environment_hit_enter():
|
|
vim.vars['jedi#environment_path'] = vim.current.line
|
|
vim_command('bd')
|
|
|
|
|
|
@catch_and_print_exceptions
|
|
def load_project():
|
|
path = vim.eval('a:args')
|
|
vim.vars['jedi#project_path'] = path
|
|
env_path = vim_eval("g:jedi#environment_path")
|
|
if env_path == 'auto':
|
|
env_path = None
|
|
if path:
|
|
try:
|
|
project = jedi.Project.load(path)
|
|
except FileNotFoundError:
|
|
project = jedi.Project(path, environment_path=env_path)
|
|
project.save()
|
|
else:
|
|
project = jedi.get_default_project()
|
|
path = project.path
|
|
project.save()
|
|
|
|
global _current_project_cache
|
|
cache_key = dict(project_path=path,
|
|
environment_path=env_path,
|
|
added_sys_path=[])
|
|
_current_project_cache = cache_key, project
|
|
|
|
|
|
@catch_and_print_exceptions
|
|
def get_script(source=None):
|
|
jedi.settings.additional_dynamic_modules = [
|
|
b.name for b in vim.buffers if (
|
|
b.name is not None and
|
|
b.name.endswith('.py') and
|
|
b.options['buflisted'])]
|
|
if source is None:
|
|
source = '\n'.join(vim.current.buffer)
|
|
buf_path = vim.current.buffer.name
|
|
if not buf_path:
|
|
# If a buffer has no name its name is an empty string.
|
|
buf_path = None
|
|
|
|
return jedi.Script(source, path=buf_path, project=get_project())
|
|
|
|
|
|
def get_pos(column=None):
|
|
row = vim.current.window.cursor[0]
|
|
if column is None:
|
|
column = vim.current.window.cursor[1]
|
|
return row, column
|
|
|
|
|
|
@_check_jedi_availability(show_error=False)
|
|
@catch_and_print_exceptions
|
|
def completions():
|
|
jedi.settings.case_insensitive_completion = \
|
|
bool(int(vim_eval("get(b:, 'jedi_case_insensitive_completion', "
|
|
"g:jedi#case_insensitive_completion)")))
|
|
|
|
row, column = vim.current.window.cursor
|
|
# Clear call signatures in the buffer so they aren't seen by the completer.
|
|
# Call signatures in the command line can stay.
|
|
if int(vim_eval("g:jedi#show_call_signatures")) == 1:
|
|
clear_call_signatures()
|
|
if vim.eval('a:findstart') == '1':
|
|
count = 0
|
|
for char in reversed(vim.current.line[:column]):
|
|
if not re.match(r'[\w\d]', char):
|
|
break
|
|
count += 1
|
|
vim.command('return %i' % (column - count))
|
|
else:
|
|
base = vim.eval('a:base')
|
|
source = ''
|
|
for i, line in enumerate(vim.current.buffer):
|
|
# enter this path again, otherwise source would be incomplete
|
|
if i == row - 1:
|
|
source += line[:column] + base + line[column:]
|
|
else:
|
|
source += line
|
|
source += '\n'
|
|
# here again hacks, because jedi has a different interface than vim
|
|
column += len(base)
|
|
try:
|
|
script = get_script(source=source)
|
|
completions = script.complete(*get_pos(column))
|
|
signatures = script.get_signatures(*get_pos(column))
|
|
|
|
add_info = "preview" in vim.eval("&completeopt").split(",")
|
|
out = []
|
|
for c in completions:
|
|
d = dict(word=PythonToVimStr(c.name[:len(base)] + c.complete),
|
|
abbr=PythonToVimStr(c.name_with_symbols),
|
|
# stuff directly behind the completion
|
|
menu=PythonToVimStr(c.description),
|
|
icase=1, # case insensitive
|
|
dup=1 # allow duplicates (maybe later remove this)
|
|
)
|
|
if add_info:
|
|
try:
|
|
d["info"] = PythonToVimStr(c.docstring())
|
|
except Exception:
|
|
print("jedi-vim: error with docstring for %r: %s" % (
|
|
c, traceback.format_exc()))
|
|
out.append(d)
|
|
|
|
strout = str(out)
|
|
except Exception:
|
|
# print to stdout, will be in :messages
|
|
print(traceback.format_exc())
|
|
strout = ''
|
|
completions = []
|
|
signatures = []
|
|
|
|
show_call_signatures(signatures)
|
|
vim.command('return ' + strout)
|
|
|
|
|
|
@contextmanager
|
|
def tempfile(content):
|
|
# Using this instead of the tempfile module because Windows won't read
|
|
# from a file not yet written to disk
|
|
with open(vim_eval('tempname()'), 'w') as f:
|
|
f.write(content)
|
|
try:
|
|
yield f
|
|
finally:
|
|
os.unlink(f.name)
|
|
|
|
|
|
@_check_jedi_availability(show_error=True)
|
|
@catch_and_print_exceptions
|
|
def goto(mode="goto"):
|
|
"""
|
|
:param str mode: "definition", "assignment", "goto"
|
|
:rtype: list of jedi.api.classes.Name
|
|
"""
|
|
script = get_script()
|
|
pos = get_pos()
|
|
if mode == "goto":
|
|
names = script.goto(*pos, follow_imports=True)
|
|
elif mode == "definition":
|
|
names = script.infer(*pos)
|
|
elif mode == "assignment":
|
|
names = script.goto(*pos)
|
|
elif mode == "stubs":
|
|
names = script.goto(*pos, follow_imports=True, only_stubs=True)
|
|
|
|
if not names:
|
|
echo_highlight("Couldn't find any definitions for this.")
|
|
elif len(names) == 1 and mode != "related_name":
|
|
n = list(names)[0]
|
|
_goto_specific_name(n)
|
|
else:
|
|
show_goto_multi_results(names, mode)
|
|
return names
|
|
|
|
|
|
def _goto_specific_name(n, options=''):
|
|
if n.column is None:
|
|
if n.is_keyword:
|
|
echo_highlight("Cannot get the definition of Python keywords.")
|
|
else:
|
|
name = 'Namespaces' if n.type == 'namespace' else 'Builtin modules'
|
|
echo_highlight(
|
|
"%s cannot be displayed (%s)."
|
|
% (name, n.full_name or n.name)
|
|
)
|
|
else:
|
|
using_tagstack = int(vim_eval('g:jedi#use_tag_stack')) == 1
|
|
result = set_buffer(n.module_path, options=options,
|
|
using_tagstack=using_tagstack)
|
|
if not result:
|
|
return []
|
|
if (using_tagstack and n.module_path and
|
|
n.module_path.exists()):
|
|
tagname = n.name
|
|
with tempfile('{0}\t{1}\t{2}'.format(
|
|
tagname, n.module_path, 'call cursor({0}, {1})'.format(
|
|
n.line, n.column + 1))) as f:
|
|
old_tags = vim.eval('&tags')
|
|
old_wildignore = vim.eval('&wildignore')
|
|
try:
|
|
# Clear wildignore to ensure tag file isn't ignored
|
|
vim.command('set wildignore=')
|
|
vim.command('let &tags = %s' %
|
|
repr(PythonToVimStr(f.name)))
|
|
vim.command('tjump %s' % tagname)
|
|
finally:
|
|
vim.command('let &tags = %s' %
|
|
repr(PythonToVimStr(old_tags)))
|
|
vim.command('let &wildignore = %s' %
|
|
repr(PythonToVimStr(old_wildignore)))
|
|
vim.current.window.cursor = n.line, n.column
|
|
|
|
|
|
def relpath(path):
|
|
"""Make path relative to cwd if it is below."""
|
|
abspath = os.path.abspath(path)
|
|
if abspath.startswith(os.getcwd()):
|
|
return os.path.relpath(path)
|
|
return path
|
|
|
|
|
|
def annotate_description(n):
|
|
code = n.get_line_code().strip()
|
|
if n.type == 'statement':
|
|
return code
|
|
if n.type == 'function':
|
|
if code.startswith('def'):
|
|
return code
|
|
typ = 'def'
|
|
else:
|
|
typ = n.type
|
|
return '[%s] %s' % (typ, code)
|
|
|
|
|
|
def show_goto_multi_results(names, mode):
|
|
"""Create (or reuse) a quickfix list for multiple names."""
|
|
global _current_names
|
|
|
|
lst = []
|
|
(row, col) = vim.current.window.cursor
|
|
current_idx = None
|
|
current_def = None
|
|
for n in names:
|
|
if n.column is None:
|
|
# Typically a namespace, in the future maybe other things as
|
|
# well.
|
|
lst.append(dict(text=PythonToVimStr(n.description)))
|
|
else:
|
|
text = annotate_description(n)
|
|
lst.append(dict(filename=PythonToVimStr(relpath(str(n.module_path))),
|
|
lnum=n.line, col=n.column + 1,
|
|
text=PythonToVimStr(text)))
|
|
|
|
# Select current/nearest entry via :cc later.
|
|
if n.line == row and n.column <= col:
|
|
if (current_idx is None
|
|
or (abs(lst[current_idx]["col"] - col)
|
|
> abs(n.column - col))):
|
|
current_idx = len(lst)
|
|
current_def = n
|
|
|
|
# Build qflist title.
|
|
qf_title = mode
|
|
if current_def is not None:
|
|
if current_def.full_name:
|
|
qf_title += ": " + current_def.full_name
|
|
else:
|
|
qf_title += ": " + str(current_def)
|
|
select_entry = current_idx
|
|
else:
|
|
select_entry = 0
|
|
|
|
qf_context = id(names)
|
|
if (_current_names
|
|
and VimCompat.can_update_current_qflist_for_context(qf_context)):
|
|
# Same list, only adjust title/selected entry.
|
|
VimCompat.setqflist_title(qf_title)
|
|
vim_command('%dcc' % select_entry)
|
|
else:
|
|
VimCompat.setqflist(lst, title=qf_title, context=qf_context)
|
|
for_usages = mode == "usages"
|
|
vim_eval('jedi#add_goto_window(%d, %d)' % (for_usages, len(lst)))
|
|
vim_command('%d' % select_entry)
|
|
|
|
|
|
def _same_names(a, b):
|
|
"""Compare without _inference_state.
|
|
|
|
Ref: https://github.com/davidhalter/jedi-vim/issues/952)
|
|
"""
|
|
return all(
|
|
x._name.start_pos == y._name.start_pos
|
|
and x.module_path == y.module_path
|
|
and x.name == y.name
|
|
for x, y in zip(a, b)
|
|
)
|
|
|
|
|
|
@catch_and_print_exceptions
|
|
def usages(visuals=True):
|
|
script = get_script()
|
|
names = script.get_references(*get_pos())
|
|
if not names:
|
|
echo_highlight("No usages found here.")
|
|
return names
|
|
|
|
if visuals:
|
|
global _current_names
|
|
|
|
if _current_names:
|
|
if _same_names(_current_names, names):
|
|
names = _current_names
|
|
else:
|
|
clear_usages()
|
|
assert not _current_names
|
|
|
|
show_goto_multi_results(names, "usages")
|
|
if not _current_names:
|
|
_current_names = names
|
|
highlight_usages()
|
|
else:
|
|
assert names is _current_names # updated above
|
|
return names
|
|
|
|
|
|
_current_names = None
|
|
"""Current definitions to use for highlighting."""
|
|
_pending_names = {}
|
|
"""Pending definitions for unloaded buffers."""
|
|
_placed_names_in_buffers = set()
|
|
"""Set of buffers for faster cleanup."""
|
|
|
|
|
|
IS_NVIM = hasattr(vim, 'from_nvim')
|
|
if IS_NVIM:
|
|
vim_prop_add = None
|
|
else:
|
|
vim_prop_type_added = False
|
|
try:
|
|
vim_prop_add = vim.Function("prop_add")
|
|
except ValueError:
|
|
vim_prop_add = None
|
|
else:
|
|
vim_prop_remove = vim.Function("prop_remove")
|
|
|
|
|
|
def clear_usages():
|
|
"""Clear existing highlights."""
|
|
global _current_names
|
|
if _current_names is None:
|
|
return
|
|
_current_names = None
|
|
|
|
if IS_NVIM:
|
|
for buf in _placed_names_in_buffers:
|
|
src_ids = buf.vars.get('_jedi_usages_src_ids')
|
|
if src_ids is not None:
|
|
for src_id in src_ids:
|
|
buf.clear_highlight(src_id)
|
|
elif vim_prop_add:
|
|
for buf in _placed_names_in_buffers:
|
|
vim_prop_remove({
|
|
'type': 'jediUsage',
|
|
'all': 1,
|
|
'bufnr': buf.number,
|
|
})
|
|
else:
|
|
# Unset current window only.
|
|
assert _current_names is None
|
|
highlight_usages_for_vim_win()
|
|
|
|
_placed_names_in_buffers.clear()
|
|
|
|
|
|
def highlight_usages():
|
|
"""Set usage names to be highlighted.
|
|
|
|
With Neovim it will use the nvim_buf_add_highlight API to highlight all
|
|
buffers already.
|
|
|
|
With Vim without support for text-properties only the current window is
|
|
highlighted via matchaddpos, and autocommands are setup to highlight other
|
|
windows on demand. Otherwise Vim's text-properties are used.
|
|
"""
|
|
global _current_names, _pending_names
|
|
|
|
names = _current_names
|
|
_pending_names = {}
|
|
|
|
if IS_NVIM or vim_prop_add:
|
|
bufs = {x.name: x for x in vim.buffers}
|
|
defs_per_buf = {}
|
|
for name in names:
|
|
try:
|
|
buf = bufs[str(name.module_path)]
|
|
except KeyError:
|
|
continue
|
|
defs_per_buf.setdefault(buf, []).append(name)
|
|
|
|
if IS_NVIM:
|
|
# We need to remember highlight ids with Neovim's API.
|
|
buf_src_ids = {}
|
|
for buf, names in defs_per_buf.items():
|
|
buf_src_ids[buf] = []
|
|
for name in names:
|
|
src_id = _add_highlighted_name(buf, name)
|
|
buf_src_ids[buf].append(src_id)
|
|
for buf, src_ids in buf_src_ids.items():
|
|
buf.vars['_jedi_usages_src_ids'] = src_ids
|
|
else:
|
|
for buf, names in defs_per_buf.items():
|
|
try:
|
|
for name in names:
|
|
_add_highlighted_name(buf, name)
|
|
except vim.error as exc:
|
|
if exc.args[0].startswith('Vim:E275:'):
|
|
# "Cannot add text property to unloaded buffer"
|
|
_pending_names.setdefault(buf.name, []).extend(
|
|
names)
|
|
else:
|
|
highlight_usages_for_vim_win()
|
|
|
|
|
|
def _handle_pending_usages_for_buf():
|
|
"""Add (pending) highlights for the current buffer (Vim with textprops)."""
|
|
buf = vim.current.buffer
|
|
bufname = buf.name
|
|
try:
|
|
buf_names = _pending_names[bufname]
|
|
except KeyError:
|
|
return
|
|
for name in buf_names:
|
|
_add_highlighted_name(buf, name)
|
|
del _pending_names[bufname]
|
|
|
|
|
|
def _add_highlighted_name(buf, name):
|
|
lnum = name.line
|
|
start_col = name.column
|
|
|
|
# Skip highlighting of module definitions that point to the start
|
|
# of the file.
|
|
if name.type == 'module' and lnum == 1 and start_col == 0:
|
|
return
|
|
|
|
_placed_names_in_buffers.add(buf)
|
|
|
|
# TODO: validate that name.name is at this position?
|
|
# Would skip the module definitions from above already.
|
|
|
|
length = len(name.name)
|
|
if vim_prop_add:
|
|
# XXX: needs jediUsage highlight (via after/syntax/python.vim).
|
|
global vim_prop_type_added
|
|
if not vim_prop_type_added:
|
|
vim.eval("prop_type_add('jediUsage', {'highlight': 'jediUsage'})")
|
|
vim_prop_type_added = True
|
|
vim_prop_add(lnum, start_col+1, {
|
|
'type': 'jediUsage',
|
|
'bufnr': buf.number,
|
|
'length': length,
|
|
})
|
|
return
|
|
|
|
assert IS_NVIM
|
|
end_col = name.column + length
|
|
src_id = buf.add_highlight('jediUsage', lnum-1, start_col, end_col,
|
|
src_id=0)
|
|
return src_id
|
|
|
|
|
|
def highlight_usages_for_vim_win():
|
|
"""Highlight usages in the current window.
|
|
|
|
It stores the matchids in a window-local variable.
|
|
|
|
(matchaddpos() only works for the current window.)
|
|
"""
|
|
win = vim.current.window
|
|
|
|
cur_matchids = win.vars.get('_jedi_usages_vim_matchids')
|
|
if cur_matchids:
|
|
if cur_matchids[0] == vim.current.buffer.number:
|
|
return
|
|
|
|
# Need to clear non-matching highlights.
|
|
for matchid in cur_matchids[1:]:
|
|
expr = 'matchdelete(%d)' % int(matchid)
|
|
vim.eval(expr)
|
|
|
|
matchids = []
|
|
if _current_names:
|
|
buffer_path = vim.current.buffer.name
|
|
for name in _current_names:
|
|
if (str(name.module_path) or '') == buffer_path:
|
|
positions = [
|
|
[name.line,
|
|
name.column + 1,
|
|
len(name.name)]
|
|
]
|
|
expr = "matchaddpos('jediUsage', %s)" % repr(positions)
|
|
matchids.append(int(vim_eval(expr)))
|
|
|
|
if matchids:
|
|
vim.current.window.vars['_jedi_usages_vim_matchids'] = [
|
|
vim.current.buffer.number] + matchids
|
|
elif cur_matchids is not None:
|
|
# Always set it (uses an empty list for "unset", which is not possible
|
|
# using del).
|
|
vim.current.window.vars['_jedi_usages_vim_matchids'] = []
|
|
|
|
# Remember if clearing is needed for later buffer autocommands.
|
|
vim.current.buffer.vars['_jedi_usages_needs_clear'] = bool(matchids)
|
|
|
|
|
|
@_check_jedi_availability(show_error=True)
|
|
@catch_and_print_exceptions
|
|
def show_documentation():
|
|
script = get_script()
|
|
try:
|
|
names = script.help(*get_pos())
|
|
except Exception:
|
|
# print to stdout, will be in :messages
|
|
names = []
|
|
print("Exception, this shouldn't happen.")
|
|
print(traceback.format_exc())
|
|
|
|
if not names:
|
|
echo_highlight('No documentation found for that.')
|
|
vim.command('return')
|
|
return
|
|
|
|
docs = []
|
|
for n in names:
|
|
doc = n.docstring()
|
|
if doc:
|
|
title = 'Docstring for %s %s' % (n.type, n.full_name or n.name)
|
|
underline = '=' * len(title)
|
|
docs.append('%s\n%s\n%s' % (title, underline, doc))
|
|
else:
|
|
docs.append('|No Docstring for %s|' % n)
|
|
text = ('\n' + '-' * 79 + '\n').join(docs)
|
|
vim.command('let l:doc = %s' % repr(PythonToVimStr(text)))
|
|
vim.command('let l:doc_lines = %s' % len(text.split('\n')))
|
|
return True
|
|
|
|
|
|
@catch_and_print_exceptions
|
|
def clear_call_signatures():
|
|
# Check if using command line call signatures
|
|
if int(vim_eval("g:jedi#show_call_signatures")) == 2:
|
|
vim_command('echo ""')
|
|
return
|
|
cursor = vim.current.window.cursor
|
|
e = vim_eval('g:jedi#call_signature_escape')
|
|
# We need two turns here to search and replace certain lines:
|
|
# 1. Search for a line with a call signature and save the appended
|
|
# characters
|
|
# 2. Actually replace the line and redo the status quo.
|
|
py_regex = r'%sjedi=([0-9]+), (.*?)%s.*?%sjedi%s'.replace(
|
|
'%s', re.escape(e))
|
|
for i, line in enumerate(vim.current.buffer):
|
|
match = re.search(py_regex, line)
|
|
if match is not None:
|
|
# Some signs were added to minimize syntax changes due to call
|
|
# signatures. We have to remove them again. The number of them is
|
|
# specified in `match.group(1)`.
|
|
after = line[match.end() + int(match.group(1)):]
|
|
line = line[:match.start()] + match.group(2) + after
|
|
vim.current.buffer[i] = line
|
|
vim.current.window.cursor = cursor
|
|
|
|
|
|
@_check_jedi_availability(show_error=False)
|
|
@catch_and_print_exceptions
|
|
def show_call_signatures(signatures=()):
|
|
if int(vim_eval("has('conceal') && g:jedi#show_call_signatures")) == 0:
|
|
return
|
|
|
|
# We need to clear the signatures before we calculate them again. The
|
|
# reason for this is that call signatures are unfortunately written to the
|
|
# buffer.
|
|
clear_call_signatures()
|
|
if signatures == ():
|
|
signatures = get_script().get_signatures(*get_pos())
|
|
|
|
if not signatures:
|
|
return
|
|
|
|
if int(vim_eval("g:jedi#show_call_signatures")) == 2:
|
|
return cmdline_call_signatures(signatures)
|
|
|
|
seen_sigs = []
|
|
for i, signature in enumerate(signatures):
|
|
line, column = signature.bracket_start
|
|
# signatures are listed above each other
|
|
line_to_replace = line - i - 1
|
|
# because there's a space before the bracket
|
|
insert_column = column - 1
|
|
if insert_column < 0 or line_to_replace <= 0:
|
|
# Edge cases, when the call signature has no space on the screen.
|
|
break
|
|
|
|
# TODO check if completion menu is above or below
|
|
line = vim_eval("getline(%s)" % line_to_replace)
|
|
|
|
# Descriptions are usually looking like `param name`, remove the param.
|
|
params = [p.description.replace('\n', '').replace('param ', '', 1)
|
|
for p in signature.params]
|
|
try:
|
|
# *_*PLACEHOLDER*_* makes something fat. See after/syntax file.
|
|
params[signature.index] = '*_*%s*_*' % params[signature.index]
|
|
except (IndexError, TypeError):
|
|
pass
|
|
|
|
# Skip duplicates.
|
|
if params in seen_sigs:
|
|
continue
|
|
seen_sigs.append(params)
|
|
|
|
# This stuff is reaaaaally a hack! I cannot stress enough, that
|
|
# this is a stupid solution. But there is really no other yet.
|
|
# There is no possibility in VIM to draw on the screen, but there
|
|
# will be one (see :help todo Patch to access screen under Python.
|
|
# (Marko Mahni, 2010 Jul 18))
|
|
text = " (%s) " % ', '.join(params)
|
|
text = ' ' * (insert_column - len(line)) + text
|
|
end_column = insert_column + len(text) - 2 # -2 due to bold symbols
|
|
|
|
# Need to decode it with utf8, because vim returns always a python 2
|
|
# string even if it is unicode.
|
|
e = vim_eval('g:jedi#call_signature_escape')
|
|
if hasattr(e, 'decode'):
|
|
e = e.decode('UTF-8')
|
|
# replace line before with cursor
|
|
regex = "xjedi=%sx%sxjedix".replace('x', e)
|
|
|
|
prefix, replace = line[:insert_column], line[insert_column:end_column]
|
|
|
|
# Check the replace stuff for strings, to append them
|
|
# (don't want to break the syntax)
|
|
regex_quotes = r'''\\*["']+'''
|
|
# `add` are all the quotation marks.
|
|
# join them with a space to avoid producing '''
|
|
add = ' '.join(re.findall(regex_quotes, replace))
|
|
# search backwards
|
|
if add and replace[0] in ['"', "'"]:
|
|
a = re.search(regex_quotes + '$', prefix)
|
|
add = ('' if a is None else a.group(0)) + add
|
|
|
|
tup = '%s, %s' % (len(add), replace)
|
|
repl = prefix + (regex % (tup, text)) + add + line[end_column:]
|
|
|
|
vim_eval('setline(%s, %s)' % (line_to_replace, repr(PythonToVimStr(repl))))
|
|
|
|
|
|
@catch_and_print_exceptions
|
|
def cmdline_call_signatures(signatures):
|
|
def get_params(s):
|
|
return [p.description.replace('\n', '').replace('param ', '', 1) for p in s.params]
|
|
|
|
def escape(string):
|
|
return string.replace('"', '\\"').replace(r'\n', r'\\n')
|
|
|
|
def join():
|
|
return ', '.join(filter(None, (left, center, right)))
|
|
|
|
def too_long():
|
|
return len(join()) > max_msg_len
|
|
|
|
if len(signatures) > 1:
|
|
params = zip_longest(*map(get_params, signatures), fillvalue='_')
|
|
params = ['(' + ', '.join(p) + ')' for p in params]
|
|
else:
|
|
params = get_params(signatures[0])
|
|
|
|
index = next(iter(s.index for s in signatures if s.index is not None), None)
|
|
|
|
# Allow 12 characters for showcmd plus 18 for ruler - setting
|
|
# noruler/noshowcmd here causes incorrect undo history
|
|
max_msg_len = int(vim_eval('&columns')) - 12
|
|
if int(vim_eval('&ruler')):
|
|
max_msg_len -= 18
|
|
max_msg_len -= len(signatures[0].name) + 2 # call name + parentheses
|
|
|
|
if max_msg_len < (1 if params else 0):
|
|
return
|
|
elif index is None:
|
|
text = escape(', '.join(params))
|
|
if params and len(text) > max_msg_len:
|
|
text = ELLIPSIS
|
|
elif max_msg_len < len(ELLIPSIS):
|
|
return
|
|
else:
|
|
left = escape(', '.join(params[:index]))
|
|
center = escape(params[index])
|
|
right = escape(', '.join(params[index + 1:]))
|
|
while too_long():
|
|
if left and left != ELLIPSIS:
|
|
left = ELLIPSIS
|
|
continue
|
|
if right and right != ELLIPSIS:
|
|
right = ELLIPSIS
|
|
continue
|
|
if (left or right) and center != ELLIPSIS:
|
|
left = right = None
|
|
center = ELLIPSIS
|
|
continue
|
|
if too_long():
|
|
# Should never reach here
|
|
return
|
|
|
|
max_num_spaces = max_msg_len
|
|
if index is not None:
|
|
max_num_spaces -= len(join())
|
|
_, column = signatures[0].bracket_start
|
|
spaces = min(int(vim_eval('g:jedi#first_col +'
|
|
'wincol() - col(".")')) +
|
|
column - len(signatures[0].name),
|
|
max_num_spaces) * ' '
|
|
|
|
if index is not None:
|
|
vim_command(' echon "%s" | '
|
|
'echohl Function | echon "%s" | '
|
|
'echohl None | echon "(" | '
|
|
'echohl jediFunction | echon "%s" | '
|
|
'echohl jediFat | echon "%s" | '
|
|
'echohl jediFunction | echon "%s" | '
|
|
'echohl None | echon ")"'
|
|
% (spaces, signatures[0].name,
|
|
left + ', ' if left else '',
|
|
center, ', ' + right if right else ''))
|
|
else:
|
|
vim_command(' echon "%s" | '
|
|
'echohl Function | echon "%s" | '
|
|
'echohl None | echon "(%s)"'
|
|
% (spaces, signatures[0].name, text))
|
|
|
|
|
|
@_check_jedi_availability(show_error=True)
|
|
@catch_and_print_exceptions
|
|
def rename():
|
|
if not int(vim.eval('a:0')):
|
|
# Need to save the cursor position before insert mode
|
|
cursor = vim.current.window.cursor
|
|
changenr = vim.eval('changenr()') # track undo tree
|
|
vim_command('augroup jedi_rename')
|
|
vim_command('autocmd InsertLeave <buffer> call jedi#rename'
|
|
'({}, {}, {})'.format(cursor[0], cursor[1], changenr))
|
|
vim_command('augroup END')
|
|
|
|
vim_command("let s:jedi_replace_orig = expand('<cword>')")
|
|
line = vim_eval('getline(".")')
|
|
vim_command('normal! diw')
|
|
if re.match(r'\w+$', line[cursor[1]:]):
|
|
# In case the deleted word is at the end of the line we need to
|
|
# move the cursor to the end.
|
|
vim_command('startinsert!')
|
|
else:
|
|
vim_command('startinsert')
|
|
|
|
else:
|
|
# Remove autocommand.
|
|
vim_command('autocmd! jedi_rename InsertLeave')
|
|
|
|
args = vim.eval('a:000')
|
|
cursor = tuple(int(x) for x in args[:2])
|
|
changenr = args[2]
|
|
|
|
# Get replacement, if there is something on the cursor.
|
|
# This won't be the case when the user ends insert mode right away,
|
|
# and `<cword>` would pick up the nearest word instead.
|
|
if vim_eval('getline(".")[getpos(".")[2]-1]') != ' ':
|
|
replace = vim_eval("expand('<cword>')")
|
|
else:
|
|
replace = None
|
|
|
|
vim_command('undo {}'.format(changenr))
|
|
|
|
vim.current.window.cursor = cursor
|
|
|
|
if replace:
|
|
return do_rename(replace)
|
|
|
|
|
|
def rename_visual():
|
|
replace = vim.eval('input("Rename to: ")')
|
|
orig = vim.eval('getline(".")[(getpos("\'<")[2]-1):getpos("\'>")[2]]')
|
|
do_rename(replace, orig)
|
|
|
|
|
|
def do_rename(replace, orig=None):
|
|
if not len(replace):
|
|
echo_highlight('No rename possible without name.')
|
|
return
|
|
|
|
if orig is None:
|
|
orig = vim_eval('s:jedi_replace_orig')
|
|
|
|
# Save original window / tab.
|
|
saved_tab = int(vim_eval('tabpagenr()'))
|
|
saved_win = int(vim_eval('winnr()'))
|
|
|
|
temp_rename = usages(visuals=False)
|
|
# Sort the whole thing reverse (positions at the end of the line
|
|
# must be first, because they move the stuff before the position).
|
|
temp_rename = sorted(temp_rename, reverse=True,
|
|
key=lambda x: (str(x.module_path), x.line, x.column))
|
|
buffers = set()
|
|
for r in temp_rename:
|
|
if r.in_builtin_module():
|
|
continue
|
|
|
|
result = set_buffer(r.module_path)
|
|
if not result:
|
|
echo_highlight('Failed to create buffer window for %s!' % (r.module_path))
|
|
continue
|
|
|
|
buffers.add(vim.current.buffer.name)
|
|
|
|
# Replace original word.
|
|
r_line = vim.current.buffer[r.line - 1]
|
|
vim.current.buffer[r.line - 1] = (r_line[:r.column] + replace +
|
|
r_line[r.column + len(orig):])
|
|
|
|
# Restore previous tab and window.
|
|
vim_command('tabnext {0:d}'.format(saved_tab))
|
|
vim_command('{0:d}wincmd w'.format(saved_win))
|
|
|
|
if len(buffers) > 1:
|
|
echo_highlight('Jedi did {0:d} renames in {1:d} buffers!'.format(
|
|
len(temp_rename), len(buffers)))
|
|
else:
|
|
echo_highlight('Jedi did {0:d} renames!'.format(len(temp_rename)))
|
|
|
|
|
|
@_check_jedi_availability(show_error=True)
|
|
@catch_and_print_exceptions
|
|
def py_import():
|
|
args = shsplit(vim.eval('a:args'))
|
|
import_path = args.pop()
|
|
name = next(get_project().search(import_path), None)
|
|
if name is None:
|
|
echo_highlight('Cannot find %s in your project or on sys.path!' % import_path)
|
|
else:
|
|
cmd_args = ' '.join([a.replace(' ', '\\ ') for a in args])
|
|
_goto_specific_name(name, options=cmd_args)
|
|
|
|
|
|
@catch_and_print_exceptions
|
|
def py_import_completions():
|
|
argl = vim.eval('a:argl')
|
|
if jedi is None:
|
|
print('Pyimport completion requires jedi module: https://github.com/davidhalter/jedi')
|
|
comps = []
|
|
else:
|
|
names = get_project().complete_search(argl)
|
|
comps = [argl + n for n in sorted(set(c.complete for c in names))]
|
|
vim.command("return '%s'" % '\n'.join(comps))
|
|
|
|
|
|
@catch_and_print_exceptions
|
|
def set_buffer(path: Optional[Path], options='', using_tagstack=False):
|
|
"""
|
|
Opens a new buffer if we have to or does nothing. Returns True in case of
|
|
success.
|
|
"""
|
|
path = str(path or '')
|
|
# Check both, because it might be an empty string
|
|
if path in (vim.current.buffer.name, os.path.abspath(vim.current.buffer.name)):
|
|
return True
|
|
|
|
path = relpath(path)
|
|
# options are what you can to edit the edit options
|
|
if int(vim_eval('g:jedi#use_tabs_not_buffers')) == 1:
|
|
_tabnew(path, options)
|
|
elif not vim_eval('g:jedi#use_splits_not_buffers') in [1, '1']:
|
|
user_split_option = vim_eval('g:jedi#use_splits_not_buffers')
|
|
split_options = {
|
|
'top': 'topleft split',
|
|
'left': 'topleft vsplit',
|
|
'right': 'botright vsplit',
|
|
'bottom': 'botright split',
|
|
'winwidth': 'vs'
|
|
}
|
|
if (user_split_option == 'winwidth' and
|
|
vim.current.window.width <= 2 * int(vim_eval(
|
|
"&textwidth ? &textwidth : 80"))):
|
|
split_options['winwidth'] = 'sp'
|
|
if user_split_option not in split_options:
|
|
print('Unsupported value for g:jedi#use_splits_not_buffers: {0}. '
|
|
'Valid options are: {1}.'.format(
|
|
user_split_option, ', '.join(split_options.keys())))
|
|
else:
|
|
vim_command(split_options[user_split_option] + " %s" % escape_file_path(path))
|
|
else:
|
|
if int(vim_eval("!&hidden && &modified")) == 1:
|
|
if not vim_eval("bufname('%')"):
|
|
echo_highlight('Cannot open a new buffer, use `:set hidden` or save your buffer')
|
|
return False
|
|
else:
|
|
vim_command('w')
|
|
if using_tagstack:
|
|
return True
|
|
vim_command('edit %s %s' % (options, escape_file_path(path)))
|
|
# sometimes syntax is being disabled and the filetype not set.
|
|
if int(vim_eval('!exists("g:syntax_on")')) == 1:
|
|
vim_command('syntax enable')
|
|
if int(vim_eval("&filetype != 'python'")) == 1:
|
|
vim_command('set filetype=python')
|
|
return True
|
|
|
|
|
|
@catch_and_print_exceptions
|
|
def _tabnew(path, options=''):
|
|
"""
|
|
Open a file in a new tab or switch to an existing one.
|
|
|
|
:param options: `:tabnew` options, read vim help.
|
|
"""
|
|
if int(vim_eval('has("gui")')) == 1:
|
|
vim_command('tab drop %s %s' % (options, escape_file_path(path)))
|
|
return
|
|
|
|
for tab_nr in range(int(vim_eval("tabpagenr('$')"))):
|
|
for buf_nr in vim_eval("tabpagebuflist(%i + 1)" % tab_nr):
|
|
buf_nr = int(buf_nr) - 1
|
|
try:
|
|
buf_path = vim.buffers[buf_nr].name
|
|
except (LookupError, ValueError):
|
|
# Just do good old asking for forgiveness.
|
|
# don't know why this happens :-)
|
|
pass
|
|
else:
|
|
if os.path.abspath(buf_path) == os.path.abspath(path):
|
|
# tab exists, just switch to that tab
|
|
vim_command('tabfirst | tabnext %i' % (tab_nr + 1))
|
|
# Goto the buffer's window.
|
|
vim_command('exec bufwinnr(%i) . " wincmd w"' % (buf_nr + 1))
|
|
break
|
|
else:
|
|
continue
|
|
break
|
|
else:
|
|
# tab doesn't exist, add a new one.
|
|
vim_command('tabnew %s' % escape_file_path(path))
|
|
|
|
|
|
def escape_file_path(path):
|
|
return path.replace(' ', r'\ ')
|
|
|
|
|
|
def print_to_stdout(level, str_out):
|
|
print(str_out)
|