jedi for python
This commit is contained in:
liushouda
parent
2a8d620b8a
commit
d931023720
27 changed files with 2517 additions and 0 deletions
|
|
@ -1,5 +1,6 @@
|
|||
nnoremap <F9> :exe 'NERDTreeToggle'<CR>
|
||||
"set pastetoggle=<F2>
|
||||
set mouse=
|
||||
|
||||
"for outside paste mistake
|
||||
nnoremap <F2> :set invpaste paste?<CR>
|
||||
|
|
@ -24,3 +25,5 @@ map <leader>6 :tabnext 6<CR>
|
|||
map <leader>7 :tabnext 7<CR>
|
||||
map <leader>8 :tabnext 8<CR>
|
||||
"let g:clang_library_path = '/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/'
|
||||
highlight OverLength ctermbg=red ctermfg=white guibg=#592929
|
||||
match OverLength /\%81v.\+/
|
||||
|
|
|
|||
6
sources_non_forked/jedi-vim/.gitignore
vendored
Normal file
6
sources_non_forked/jedi-vim/.gitignore
vendored
Normal file
|
|
@ -0,0 +1,6 @@
|
|||
*~
|
||||
*.sw?
|
||||
*.py[cod]
|
||||
.ropeproject
|
||||
doc/tags
|
||||
.cache
|
||||
3
sources_non_forked/jedi-vim/.gitmodules
vendored
Normal file
3
sources_non_forked/jedi-vim/.gitmodules
vendored
Normal file
|
|
@ -0,0 +1,3 @@
|
|||
[submodule "jedi"]
|
||||
path = jedi
|
||||
url = https://github.com/davidhalter/jedi.git
|
||||
6
sources_non_forked/jedi-vim/.travis.yml
Normal file
6
sources_non_forked/jedi-vim/.travis.yml
Normal file
|
|
@ -0,0 +1,6 @@
|
|||
language: python
|
||||
install:
|
||||
- pip install --quiet --use-mirrors pytest
|
||||
script:
|
||||
- vim --version
|
||||
- py.test
|
||||
51
sources_non_forked/jedi-vim/AUTHORS.txt
Normal file
51
sources_non_forked/jedi-vim/AUTHORS.txt
Normal file
|
|
@ -0,0 +1,51 @@
|
|||
Main Authors
|
||||
============
|
||||
|
||||
David Halter (@davidhalter) <davidhalter88@gmail.com>
|
||||
|
||||
|
||||
Contributors (in order of contributions)
|
||||
========================================
|
||||
|
||||
Patrice Peterson (@runiq)
|
||||
tek (@tek)
|
||||
heavenshell (@heavenshell) <heavenshell.jp@gmail.com>
|
||||
Danilo Bargen (@dbrgn) <gezuru@gmail.com>
|
||||
mattn (@mattn) <mattn.jp@gmail.com>
|
||||
Enrico Batista da Luz (@ricobl) <rico.bl@gmail.com>
|
||||
coot (@coot) <mszamot@gmail.com>
|
||||
Artur Dryomov (@ming13) <artur.dryomov@gmail.com>
|
||||
andviro (@andviro)
|
||||
Jean-Louis Fuchs (@ganwell) <ganwell@fangorn.ch>
|
||||
Mathieu Comandon (@strycore) <strider@strycore.com>
|
||||
Nick Hurley (@todesschaf) <hurley@todesschaf.org>
|
||||
gpoulin (@gpoulin)
|
||||
Akinori Hattori (@hattya)
|
||||
Luper Rouch (@flupke)
|
||||
Matthew Moses (@mlmoses) <moses.matthewl@gmail.com>
|
||||
Tyler Wymer (@twymer)
|
||||
Artem Nezvigin (@artnez)
|
||||
rogererens (@rogererens)
|
||||
Emily Strickland (@emilyst) <mail@emily.st>
|
||||
Tin Tvrtković (@Tinche) <tinchester@gmail.com>
|
||||
Zekeriya Koc (@zekzekus) <zekzekus@gmail.com>
|
||||
ethinx (@ethinx) <eth2net@gmail.com>
|
||||
Wouter Overmeire (@lodagro) <lodagro@gmail.com>
|
||||
Stephen J. Fuhry (@fuhrysteve) <fuhrysteve@gmail.com>
|
||||
Sheng Yun (@ShengYun) <uewing@gmail.com>
|
||||
Yann Thomas-Gérard (@inside) <inside@gmail.com>
|
||||
Colin Su (@littleq0903) <littleq0903@gmail.com>
|
||||
Arthur Jaron (@eyetracker)
|
||||
Justin M. Keyes (@justinmk)
|
||||
nagev (@np1)
|
||||
Chris Lasher (@gotgenes) <chris.lasher@gmail.com>
|
||||
Doan Thanh Nam (@tndoan)
|
||||
Markus Koller (@toupeira)
|
||||
Justin Cheevers @justincheevers
|
||||
Talha Ahmed (@talha81) <talha.ahmed@gmail.com>
|
||||
Matthew Tylee Atkinson (@matatk)
|
||||
Pedro Ferrari (@petobens)
|
||||
Dave Honneffer (@pearofducks)
|
||||
|
||||
|
||||
@something are github user names.
|
||||
9
sources_non_forked/jedi-vim/CONTRIBUTING.md
Normal file
9
sources_non_forked/jedi-vim/CONTRIBUTING.md
Normal file
|
|
@ -0,0 +1,9 @@
|
|||
We <3 pull requests!
|
||||
|
||||
1. Fork the Repo on github.
|
||||
2. Add yourself to AUTHORS.txt
|
||||
3. Add a test if possible.
|
||||
4. Push to your fork and submit a pull request.
|
||||
|
||||
Please use PEP8 as a Python code style. For VIM, just stick try to style your
|
||||
code similar to the jedi-vim code that's there.
|
||||
21
sources_non_forked/jedi-vim/LICENSE.txt
Normal file
21
sources_non_forked/jedi-vim/LICENSE.txt
Normal file
|
|
@ -0,0 +1,21 @@
|
|||
The MIT License (MIT)
|
||||
|
||||
Copyright (c) <2013> <David Halter and others, see AUTHORS.txt>
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE.
|
||||
226
sources_non_forked/jedi-vim/README.rst
Normal file
226
sources_non_forked/jedi-vim/README.rst
Normal file
|
|
@ -0,0 +1,226 @@
|
|||
#################################################
|
||||
jedi-vim - awesome Python autocompletion with VIM
|
||||
#################################################
|
||||
|
||||
.. image:: https://travis-ci.org/davidhalter/jedi-vim.png?branch=master
|
||||
:target: https://travis-ci.org/davidhalter/jedi-vim
|
||||
:alt: Travis-CI build status
|
||||
|
||||
jedi-vim is a VIM binding to the autocompletion library
|
||||
`Jedi <http://github.com/davidhalter/jedi>`_.
|
||||
|
||||
Here are some pictures:
|
||||
|
||||
.. image:: https://github.com/davidhalter/jedi/raw/master/docs/_screenshots/screenshot_complete.png
|
||||
|
||||
Completion for almost anything (Ctrl+Space).
|
||||
|
||||
.. image:: https://github.com/davidhalter/jedi/raw/master/docs/_screenshots/screenshot_function.png
|
||||
|
||||
Display of function/class bodies, docstrings.
|
||||
|
||||
.. image:: https://github.com/davidhalter/jedi/raw/master/docs/_screenshots/screenshot_pydoc.png
|
||||
|
||||
Documentation (Pydoc) support (with highlighting, Shift+k).
|
||||
|
||||
There is also support for goto and renaming.
|
||||
|
||||
|
||||
Get the latest from `github <http://github.com/davidhalter/jedi-vim>`_.
|
||||
|
||||
Documentation
|
||||
=============
|
||||
|
||||
Documentation is available in your vim: ``:help jedi-vim``. You can also look
|
||||
it up `on github <http://github.com/davidhalter/jedi-vim/blob/master/doc/jedi-vim.txt>`_.
|
||||
|
||||
You can read the Jedi library documentation `here <http://jedi.jedidjah.ch>`_.
|
||||
|
||||
If you want to report issues, just use the github issue tracker. In case of
|
||||
questions about the software, please use `stackoverflow
|
||||
<https://stackoverflow.com>`_ and tag your question with ``jedi-vim``.
|
||||
|
||||
|
||||
Contributing
|
||||
============
|
||||
|
||||
We love Pull Requests! Read the instructions in ``CONTRIBUTING.md``.
|
||||
|
||||
|
||||
Features
|
||||
========
|
||||
|
||||
The Jedi library understands most of Python's core features. From decorators to
|
||||
generators, there is broad support.
|
||||
|
||||
Apart from that, jedi-vim supports the following commands
|
||||
|
||||
- Completion ``<C-Space>``
|
||||
- Goto assignments ``<leader>g`` (typical goto function)
|
||||
- Goto definitions ``<leader>d`` (follow identifier as far as possible,
|
||||
includes imports and statements)
|
||||
- Show Documentation/Pydoc ``K`` (shows a popup with assignments)
|
||||
- Renaming ``<leader>r``
|
||||
- Usages ``<leader>n`` (shows all the usages of a name)
|
||||
- Open module, e.g. ``:Pyimport os`` (opens the ``os`` module)
|
||||
|
||||
|
||||
Installation
|
||||
============
|
||||
|
||||
You might want to use `pathogen <https://github.com/tpope/vim-pathogen>`_ or
|
||||
`vundle <https://github.com/gmarik/vundle>`_ to install jedi in VIM. Also you
|
||||
need a VIM version that was compiled with ``+python``, which is typical for most
|
||||
distributions on Linux. The Python version compiled into VIM must be 2.6 or later
|
||||
(you can check this from within VIM using ``:python import sys; print sys.version`` )
|
||||
|
||||
The first thing you need after that is an up-to-date version of Jedi. You can
|
||||
either get it via ``pip install jedi`` or with ``git submodule update --init``
|
||||
in your jedi-vim repository.
|
||||
|
||||
Example Installation Command using Pathogen:
|
||||
|
||||
.. code-block:: sh
|
||||
|
||||
cd ~/.vim/bundle/ && git clone --recursive https://github.com/davidhalter/jedi-vim.git
|
||||
|
||||
|
||||
On Arch Linux, you can also install jedi-vim from official repositories as `vim-jedi
|
||||
<https://www.archlinux.org/packages/community/any/vim-jedi/>`__. It is also available
|
||||
on `Debian (≥8) <https://packages.debian.org/vim-python-jedi>`__ and `Ubuntu (≥14.04)
|
||||
<http://packages.ubuntu.com/vim-python-jedi>`__ as vim-python-jedi.
|
||||
|
||||
Note that the `python-mode <https://github.com/klen/python-mode>`_ VIM plugin seems
|
||||
to conflict with jedi-vim, therefore you should disable it before enabling
|
||||
jedi-vim.
|
||||
|
||||
To enjoy the full features of jedi-vim, you should have VIM >= 7.3, compiled with
|
||||
``+conceal`` (which is not the case on some platforms, including OS X). If your VIM
|
||||
does not meet these requirements, the parameter recommendation list may not appear
|
||||
when you type an open bracket after a function name. Please read
|
||||
`the documentation <http://github.com/davidhalter/jedi-vim/blob/master/doc/jedi-vim.txt>`_
|
||||
for details.
|
||||
|
||||
|
||||
Settings
|
||||
========
|
||||
|
||||
Jedi is by default automatically initialized. If you don't want that I suggest
|
||||
you disable the auto-initialization in your ``.vimrc``:
|
||||
|
||||
.. code-block:: vim
|
||||
|
||||
let g:jedi#auto_initialization = 0
|
||||
|
||||
There are also some VIM options (like ``completeopt`` and key defaults) which
|
||||
are automatically initialized, but you can skip this:
|
||||
|
||||
.. code-block:: vim
|
||||
|
||||
let g:jedi#auto_vim_configuration = 0
|
||||
|
||||
|
||||
You can make jedi-vim use tabs when going to a definition etc:
|
||||
|
||||
.. code-block:: vim
|
||||
|
||||
let g:jedi#use_tabs_not_buffers = 1
|
||||
|
||||
If you are a person who likes to use VIM-splits, you might want to put this in your ``.vimrc``:
|
||||
|
||||
.. code-block:: vim
|
||||
|
||||
let g:jedi#use_splits_not_buffers = "left"
|
||||
|
||||
This options could be "left", "right", "top", "bottom" or "winwidth". It will decide the direction where the split open.
|
||||
|
||||
Jedi automatically starts the completion, if you type a dot, e.g. ``str.``, if
|
||||
you don't want this:
|
||||
|
||||
.. code-block:: vim
|
||||
|
||||
let g:jedi#popup_on_dot = 0
|
||||
|
||||
Jedi selects the first line of the completion menu: for a better typing-flow
|
||||
and usually saves one keypress.
|
||||
|
||||
.. code-block:: vim
|
||||
|
||||
let g:jedi#popup_select_first = 0
|
||||
|
||||
Jedi displays function call signatures in insert mode in real-time, highlighting
|
||||
the current argument. The call signatures can be displayed as a pop-up in the
|
||||
buffer (set to 1, the default), which has the advantage of being easier to refer
|
||||
to, or in Vim's command line aligned with the function call (set to 2), which
|
||||
can improve the integrity of Vim's undo history.
|
||||
|
||||
.. code-block:: vim
|
||||
|
||||
let g:jedi#show_call_signatures = "1"
|
||||
|
||||
Here are a few more defaults for actions, read the docs (``:help jedi-vim``) to
|
||||
get more information. If you set them to ``""``, they are not assigned.
|
||||
|
||||
.. code-block:: vim
|
||||
|
||||
NOTE: subject to change!
|
||||
|
||||
let g:jedi#goto_command = "<leader>d"
|
||||
let g:jedi#goto_assignments_command = "<leader>g"
|
||||
let g:jedi#goto_definitions_command = ""
|
||||
let g:jedi#documentation_command = "K"
|
||||
let g:jedi#usages_command = "<leader>n"
|
||||
let g:jedi#completions_command = "<C-Space>"
|
||||
let g:jedi#rename_command = "<leader>r"
|
||||
|
||||
|
||||
Finally, if you don't want completion, but all the other features, use:
|
||||
|
||||
.. code-block:: vim
|
||||
|
||||
let g:jedi#completions_enabled = 0
|
||||
|
||||
FAQ
|
||||
===
|
||||
|
||||
I don't want the docstring window to popup during completion
|
||||
------------------------------------------------------------
|
||||
|
||||
This depends on the ``completeopt`` option. Jedi initializes it in its
|
||||
``ftplugin``. Add the following line to your ``.vimrc`` to disable it:
|
||||
|
||||
.. code-block:: vim
|
||||
|
||||
autocmd FileType python setlocal completeopt-=preview
|
||||
|
||||
|
||||
I want <Tab> to do autocompletion
|
||||
---------------------------------
|
||||
|
||||
Don't even think about changing the Jedi command to ``<Tab>``,
|
||||
use `supertab <https://github.com/ervandew/supertab>`_!
|
||||
|
||||
|
||||
The completion is waaay too slow!
|
||||
---------------------------------
|
||||
|
||||
Completion of complex libraries (like Numpy) should only be slow the first time
|
||||
you complete it. After that, the results should be cached and very fast.
|
||||
|
||||
If it's still slow, in case you've installed the python-mode VIM plugin, disable
|
||||
it. It seems to conflict with jedi-vim. See issue `#163
|
||||
<https://github.com/davidhalter/jedi-vim/issues/163>`__.
|
||||
|
||||
|
||||
Testing
|
||||
=======
|
||||
|
||||
jedi-vim is being tested with a combination of `vspec
|
||||
<https://github.com/kana/vim-vspec>`_ and `py.test <http://pytest.org/>`_.
|
||||
|
||||
The tests are in the ``test`` subdirectory, you can run them calling::
|
||||
|
||||
py.test
|
||||
|
||||
The tests are automatically run with `travis
|
||||
<https://travis-ci.org/davidhalter/jedi-vim>`_.
|
||||
23
sources_non_forked/jedi-vim/after/ftplugin/python/jedi.vim
Normal file
23
sources_non_forked/jedi-vim/after/ftplugin/python/jedi.vim
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
if !jedi#init_python()
|
||||
finish
|
||||
endif
|
||||
|
||||
if g:jedi#auto_initialization
|
||||
if g:jedi#completions_enabled
|
||||
" We need our own omnifunc, so this overrides the omnifunc set by
|
||||
" $VIMRUNTIME/ftplugin/python.vim.
|
||||
setlocal omnifunc=jedi#completions
|
||||
|
||||
" map ctrl+space for autocompletion
|
||||
if g:jedi#completions_command == "<C-Space>"
|
||||
" In terminals, <C-Space> sometimes equals <Nul>.
|
||||
imap <buffer> <Nul> <C-Space>
|
||||
smap <buffer> <Nul> <C-Space>
|
||||
endif
|
||||
if g:jedi#completions_command != ""
|
||||
execute "inoremap <expr> <buffer> ".g:jedi#completions_command." jedi#complete_string(0)"
|
||||
" A separate mapping for select mode: deletes and completes.
|
||||
execute "snoremap <expr> <buffer> ".g:jedi#completions_command." '\<C-g>c'.jedi#complete_string(0)"
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
32
sources_non_forked/jedi-vim/after/syntax/python.vim
Normal file
32
sources_non_forked/jedi-vim/after/syntax/python.vim
Normal file
|
|
@ -0,0 +1,32 @@
|
|||
if !jedi#init_python()
|
||||
finish
|
||||
endif
|
||||
|
||||
if g:jedi#show_call_signatures > 0 && has('conceal')
|
||||
" +conceal is the default for vim >= 7.3
|
||||
|
||||
let s:e = g:jedi#call_signature_escape
|
||||
let s:full = s:e.'jedi=.\{-}'.s:e.'.\{-}'.s:e.'jedi'.s:e
|
||||
let s:ignore = s:e.'jedi.\{-}'.s:e
|
||||
exe 'syn match jediIgnore "'.s:ignore.'" contained conceal'
|
||||
setlocal conceallevel=2
|
||||
syn match jediFatSymbol "\*_\*" contained conceal
|
||||
syn match jediFat "\*_\*.\{-}\*_\*" contained contains=jediFatSymbol
|
||||
syn match jediSpace "\v[ ]+( )@=" contained
|
||||
exe 'syn match jediFunction "'.s:full.'" keepend extend '
|
||||
\ .' contains=jediIgnore,jediFat,jediSpace'
|
||||
\ .' containedin=pythonComment,pythonString,pythonRawString'
|
||||
unlet! s:e s:full s:ignore
|
||||
|
||||
hi def link jediIgnore Ignore
|
||||
hi def link jediFatSymbol Ignore
|
||||
hi def link jediSpace Normal
|
||||
|
||||
if exists('g:colors_name')
|
||||
hi def link jediFunction CursorLine
|
||||
hi def link jediFat TabLine
|
||||
else
|
||||
hi jediFunction term=NONE cterm=NONE ctermfg=6 guifg=Black gui=NONE ctermbg=0 guibg=Grey
|
||||
hi jediFat term=bold,underline cterm=bold,underline gui=bold,underline ctermbg=0 guibg=#555555
|
||||
endif
|
||||
endif
|
||||
428
sources_non_forked/jedi-vim/autoload/jedi.vim
Normal file
428
sources_non_forked/jedi-vim/autoload/jedi.vim
Normal file
|
|
@ -0,0 +1,428 @@
|
|||
scriptencoding utf-8
|
||||
|
||||
" ------------------------------------------------------------------------
|
||||
" Settings initialization
|
||||
" ------------------------------------------------------------------------
|
||||
let s:deprecations = {
|
||||
\ 'get_definition_command': 'goto_definitions_command',
|
||||
\ 'pydoc': 'documentation_command',
|
||||
\ 'related_names_command': 'usages_command',
|
||||
\ 'autocompletion_command': 'completions_command',
|
||||
\ 'show_function_definition': 'show_call_signatures',
|
||||
\ }
|
||||
|
||||
let s:default_settings = {
|
||||
\ 'use_tabs_not_buffers': 0,
|
||||
\ 'use_splits_not_buffers': 1,
|
||||
\ 'auto_initialization': 1,
|
||||
\ 'auto_vim_configuration': 1,
|
||||
\ 'goto_command': "'<leader>d'",
|
||||
\ 'goto_assignments_command': "'<leader>g'",
|
||||
\ 'goto_definitions_command': "''",
|
||||
\ 'completions_command': "'<C-Space>'",
|
||||
\ 'call_signatures_command': "'<leader>n'",
|
||||
\ 'usages_command': "'<leader>n'",
|
||||
\ 'rename_command': "'<leader>r'",
|
||||
\ 'popup_on_dot': 1,
|
||||
\ 'documentation_command': "'K'",
|
||||
\ 'show_call_signatures': 1,
|
||||
\ 'call_signature_escape': "'=`='",
|
||||
\ 'auto_close_doc': 1,
|
||||
\ 'max_doc_height': 30,
|
||||
\ 'popup_select_first': 1,
|
||||
\ 'quickfix_window_height': 10,
|
||||
\ 'completions_enabled': 1,
|
||||
\ 'force_py_version': "'auto'"
|
||||
\ }
|
||||
|
||||
for [key, val] in items(s:deprecations)
|
||||
if exists('g:jedi#'.key)
|
||||
echom "'g:jedi#".key."' is deprecated. Please use 'g:jedi#".val."' instead. Sorry for the inconvenience."
|
||||
exe 'let g:jedi#'.val.' = g:jedi#'.key
|
||||
endif
|
||||
endfor
|
||||
|
||||
for [key, val] in items(s:default_settings)
|
||||
if !exists('g:jedi#'.key)
|
||||
exe 'let g:jedi#'.key.' = '.val
|
||||
endif
|
||||
endfor
|
||||
|
||||
|
||||
" ------------------------------------------------------------------------
|
||||
" Python initialization
|
||||
" ------------------------------------------------------------------------
|
||||
let s:script_path = fnameescape(expand('<sfile>:p:h:h'))
|
||||
|
||||
function! s:init_python()
|
||||
if g:jedi#force_py_version != 'auto'
|
||||
" Always use the user supplied version.
|
||||
try
|
||||
return jedi#force_py_version(g:jedi#force_py_version)
|
||||
catch
|
||||
throw "Could not setup g:jedi#force_py_version: ".v:exception
|
||||
endtry
|
||||
endif
|
||||
|
||||
" Handle "auto" version.
|
||||
if has('nvim') || (has('python') && has('python3'))
|
||||
" Neovim usually has both python providers. Skipping the `has` check
|
||||
" avoids starting both of them.
|
||||
|
||||
" Get default python version from interpreter in $PATH.
|
||||
let s:def_py = system("python -c 'import sys; sys.stdout.write(str(sys.version_info[0]))'")
|
||||
if v:shell_error != 0 || !len(s:def_py)
|
||||
if !exists("g:jedi#squelch_py_warning")
|
||||
echohl WarningMsg
|
||||
echom "Warning: jedi-vim failed to get Python version from sys.version_info: " . s:def_py
|
||||
echom "Falling back to version 2."
|
||||
echohl None
|
||||
endif
|
||||
let s:def_py = 2
|
||||
elseif &verbose
|
||||
echom "jedi-vim: auto-detected Python: ".s:def_py
|
||||
endif
|
||||
|
||||
" Make sure that the auto-detected version is available in Vim.
|
||||
if !has('nvim') || has('python'.(s:def_py == 2 ? '' : s:def_py))
|
||||
return jedi#force_py_version(s:def_py)
|
||||
endif
|
||||
endif
|
||||
|
||||
if has('python')
|
||||
call jedi#setup_py_version(2)
|
||||
elseif has('python3')
|
||||
call jedi#setup_py_version(3)
|
||||
else
|
||||
throw "jedi-vim requires Vim with support for Python 2 or 3."
|
||||
endif
|
||||
return 1
|
||||
endfunction
|
||||
|
||||
|
||||
function! jedi#init_python()
|
||||
if !exists('s:_init_python')
|
||||
try
|
||||
let s:_init_python = s:init_python()
|
||||
catch
|
||||
if !exists("g:jedi#squelch_py_warning")
|
||||
echohl WarningMsg
|
||||
echom "Error: jedi-vim failed to initialize Python: ".v:exception." (in ".v:throwpoint.")"
|
||||
echohl None
|
||||
endif
|
||||
let s:_init_python = 0
|
||||
endtry
|
||||
endif
|
||||
return s:_init_python
|
||||
endfunction
|
||||
|
||||
|
||||
function! jedi#setup_py_version(py_version)
|
||||
if a:py_version == 2
|
||||
let cmd_init = 'pyfile'
|
||||
let cmd_exec = 'python'
|
||||
elseif a:py_version == 3
|
||||
let cmd_init = 'py3file'
|
||||
let cmd_exec = 'python3'
|
||||
else
|
||||
throw "jedi#setup_py_version: invalid py_version: ".a:py_version
|
||||
endif
|
||||
|
||||
try
|
||||
execute cmd_init.' '.s:script_path.'/initialize.py'
|
||||
execute 'command! -nargs=1 PythonJedi '.cmd_exec.' <args>'
|
||||
return 1
|
||||
catch
|
||||
throw "jedi#setup_py_version: ".v:exception
|
||||
endtry
|
||||
endfunction
|
||||
|
||||
|
||||
function! jedi#force_py_version(py_version)
|
||||
let g:jedi#force_py_version = a:py_version
|
||||
return jedi#setup_py_version(a:py_version)
|
||||
endfunction
|
||||
|
||||
|
||||
function! jedi#force_py_version_switch()
|
||||
if g:jedi#force_py_version == 2
|
||||
call jedi#force_py_version(3)
|
||||
elseif g:jedi#force_py_version == 3
|
||||
call jedi#force_py_version(2)
|
||||
else
|
||||
throw "Don't know how to switch from ".g:jedi#force_py_version."!"
|
||||
endif
|
||||
endfunction
|
||||
|
||||
|
||||
" Helper function instead of `python vim.eval()`, and `.command()` because
|
||||
" these also return error definitions.
|
||||
function! jedi#_vim_exceptions(str, is_eval)
|
||||
let l:result = {}
|
||||
try
|
||||
if a:is_eval
|
||||
let l:result.result = eval(a:str)
|
||||
else
|
||||
execute a:str
|
||||
let l:result.result = ''
|
||||
endif
|
||||
catch
|
||||
let l:result.exception = v:exception
|
||||
let l:result.throwpoint = v:throwpoint
|
||||
endtry
|
||||
return l:result
|
||||
endfunction
|
||||
|
||||
|
||||
if !jedi#init_python()
|
||||
" Do not define any functions when Python initialization failed.
|
||||
finish
|
||||
endif
|
||||
|
||||
|
||||
" ------------------------------------------------------------------------
|
||||
" functions that call python code
|
||||
" ------------------------------------------------------------------------
|
||||
function! jedi#goto()
|
||||
PythonJedi jedi_vim.goto(mode="goto")
|
||||
endfunction
|
||||
|
||||
function! jedi#goto_assignments()
|
||||
PythonJedi jedi_vim.goto(mode="assignment")
|
||||
endfunction
|
||||
|
||||
function! jedi#goto_definitions()
|
||||
PythonJedi jedi_vim.goto(mode="definition")
|
||||
endfunction
|
||||
|
||||
function! jedi#usages()
|
||||
PythonJedi jedi_vim.goto(mode="related_name")
|
||||
endfunction
|
||||
|
||||
function! jedi#rename(...)
|
||||
PythonJedi jedi_vim.rename()
|
||||
endfunction
|
||||
|
||||
function! jedi#rename_visual(...)
|
||||
PythonJedi jedi_vim.rename_visual()
|
||||
endfunction
|
||||
|
||||
function! jedi#completions(findstart, base)
|
||||
PythonJedi jedi_vim.completions()
|
||||
endfunction
|
||||
|
||||
function! jedi#enable_speed_debugging()
|
||||
PythonJedi jedi_vim.jedi.set_debug_function(jedi_vim.print_to_stdout, speed=True, warnings=False, notices=False)
|
||||
endfunction
|
||||
|
||||
function! jedi#enable_debugging()
|
||||
PythonJedi jedi_vim.jedi.set_debug_function(jedi_vim.print_to_stdout)
|
||||
endfunction
|
||||
|
||||
function! jedi#disable_debugging()
|
||||
PythonJedi jedi_vim.jedi.set_debug_function(None)
|
||||
endfunction
|
||||
|
||||
function! jedi#py_import(args)
|
||||
PythonJedi jedi_vim.py_import()
|
||||
endfun
|
||||
|
||||
function! jedi#py_import_completions(argl, cmdl, pos)
|
||||
PythonJedi jedi_vim.py_import_completions()
|
||||
endfun
|
||||
|
||||
|
||||
" ------------------------------------------------------------------------
|
||||
" show_documentation
|
||||
" ------------------------------------------------------------------------
|
||||
function! jedi#show_documentation()
|
||||
PythonJedi if jedi_vim.show_documentation() is None: vim.command('return')
|
||||
|
||||
let bn = bufnr("__doc__")
|
||||
if bn > 0
|
||||
let wi=index(tabpagebuflist(tabpagenr()), bn)
|
||||
if wi >= 0
|
||||
" If the __doc__ buffer is open in the current tab, jump to it
|
||||
silent execute (wi+1).'wincmd w'
|
||||
else
|
||||
silent execute "sbuffer ".bn
|
||||
endif
|
||||
else
|
||||
split '__doc__'
|
||||
endif
|
||||
|
||||
setlocal modifiable
|
||||
setlocal noswapfile
|
||||
setlocal buftype=nofile
|
||||
silent normal! ggdG
|
||||
silent $put=l:doc
|
||||
silent normal! 1Gdd
|
||||
setlocal nomodifiable
|
||||
setlocal nomodified
|
||||
setlocal filetype=rst
|
||||
|
||||
if l:doc_lines > g:jedi#max_doc_height " max lines for plugin
|
||||
let l:doc_lines = g:jedi#max_doc_height
|
||||
endif
|
||||
execute "resize ".l:doc_lines
|
||||
|
||||
" quit comands
|
||||
nnoremap <buffer> q ZQ
|
||||
execute "nnoremap <buffer> ".g:jedi#documentation_command." ZQ"
|
||||
|
||||
" highlight python code within rst
|
||||
unlet! b:current_syntax
|
||||
syn include @rstPythonScript syntax/python.vim
|
||||
" 4 spaces
|
||||
syn region rstPythonRegion start=/^\v {4}/ end=/\v^( {4}|\n)@!/ contains=@rstPythonScript
|
||||
" >>> python code -> (doctests)
|
||||
syn region rstPythonRegion matchgroup=pythonDoctest start=/^>>>\s*/ end=/\n/ contains=@rstPythonScript
|
||||
let b:current_syntax = "rst"
|
||||
endfunction
|
||||
|
||||
" ------------------------------------------------------------------------
|
||||
" helper functions
|
||||
" ------------------------------------------------------------------------
|
||||
|
||||
function! jedi#add_goto_window(len)
|
||||
set lazyredraw
|
||||
cclose
|
||||
let height = min([a:len, g:jedi#quickfix_window_height])
|
||||
execute 'belowright copen '.height
|
||||
set nolazyredraw
|
||||
if g:jedi#use_tabs_not_buffers == 1
|
||||
noremap <buffer> <CR> :call jedi#goto_window_on_enter()<CR>
|
||||
endif
|
||||
au WinLeave <buffer> q " automatically leave, if an option is chosen
|
||||
redraw!
|
||||
endfunction
|
||||
|
||||
|
||||
function! jedi#goto_window_on_enter()
|
||||
let l:list = getqflist()
|
||||
let l:data = l:list[line('.') - 1]
|
||||
if l:data.bufnr
|
||||
" close goto_window buffer
|
||||
normal ZQ
|
||||
PythonJedi jedi_vim.new_buffer(vim.eval('bufname(l:data.bufnr)'))
|
||||
call cursor(l:data.lnum, l:data.col)
|
||||
else
|
||||
echohl WarningMsg | echo "Builtin module cannot be opened." | echohl None
|
||||
endif
|
||||
endfunction
|
||||
|
||||
|
||||
function! s:syn_stack()
|
||||
if !exists("*synstack")
|
||||
return []
|
||||
endif
|
||||
return map(synstack(line('.'), col('.') - 1), 'synIDattr(v:val, "name")')
|
||||
endfunc
|
||||
|
||||
|
||||
function! jedi#do_popup_on_dot_in_highlight()
|
||||
let highlight_groups = s:syn_stack()
|
||||
for a in highlight_groups
|
||||
if a == 'pythonDoctest'
|
||||
return 1
|
||||
endif
|
||||
endfor
|
||||
|
||||
for a in highlight_groups
|
||||
for b in ['pythonString', 'pythonComment', 'pythonNumber']
|
||||
if a == b
|
||||
return 0
|
||||
endif
|
||||
endfor
|
||||
endfor
|
||||
return 1
|
||||
endfunc
|
||||
|
||||
|
||||
function! jedi#configure_call_signatures()
|
||||
if g:jedi#show_call_signatures == 2 " Command line call signatures
|
||||
autocmd InsertEnter <buffer> let g:jedi#first_col = s:save_first_col()
|
||||
endif
|
||||
autocmd InsertLeave <buffer> PythonJedi jedi_vim.clear_call_signatures()
|
||||
autocmd CursorMovedI <buffer> PythonJedi jedi_vim.show_call_signatures()
|
||||
endfunction
|
||||
|
||||
|
||||
" Determine where the current window is on the screen for displaying call
|
||||
" signatures in the correct column.
|
||||
function! s:save_first_col()
|
||||
if bufname('%') ==# '[Command Line]' || winnr('$') == 1
|
||||
return 0
|
||||
endif
|
||||
|
||||
let startwin = winnr()
|
||||
let winwidth = winwidth(0)
|
||||
if winwidth == &columns
|
||||
return 0
|
||||
elseif winnr('$') == 2
|
||||
return startwin == 1 ? 0 : (winwidth(1) + 1)
|
||||
elseif winnr('$') == 3
|
||||
if startwin == 1
|
||||
return 0
|
||||
endif
|
||||
let ww1 = winwidth(1)
|
||||
let ww2 = winwidth(2)
|
||||
let ww3 = winwidth(3)
|
||||
if ww1 + ww2 + ww3 + 2 == &columns
|
||||
if startwin == 2
|
||||
return ww1 + 1
|
||||
else
|
||||
return ww1 + ww2 + 2
|
||||
endif
|
||||
elseif startwin == 2
|
||||
if ww2 + ww3 + 1 == &columns
|
||||
return 0
|
||||
else
|
||||
return ww1 + 1
|
||||
endif
|
||||
else " startwin == 3
|
||||
if ww2 + ww3 + 1 == &columns
|
||||
return ww2 + 1
|
||||
else
|
||||
return ww1 + 1
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
return 0
|
||||
endfunction
|
||||
|
||||
|
||||
function! jedi#complete_string(is_popup_on_dot)
|
||||
|
||||
if a:is_popup_on_dot && !(g:jedi#popup_on_dot && jedi#do_popup_on_dot_in_highlight())
|
||||
return ''
|
||||
|
||||
endif
|
||||
if pumvisible() && !a:is_popup_on_dot
|
||||
return "\<C-n>"
|
||||
else
|
||||
return "\<C-x>\<C-o>\<C-r>=jedi#complete_opened(".a:is_popup_on_dot.")\<CR>"
|
||||
endif
|
||||
endfunction
|
||||
|
||||
|
||||
function! jedi#complete_opened(is_popup_on_dot)
|
||||
if pumvisible()
|
||||
" Only go down if it is visible, user-enabled and the longest
|
||||
" option is set.
|
||||
if g:jedi#popup_select_first && stridx(&completeopt, 'longest') > -1
|
||||
return "\<Down>"
|
||||
endif
|
||||
if a:is_popup_on_dot
|
||||
" Prevent completion of the first entry with dot completion.
|
||||
return "\<C-p>"
|
||||
endif
|
||||
endif
|
||||
return ""
|
||||
endfunction
|
||||
|
||||
|
||||
"PythonJedi jedi_vim.jedi.set_debug_function(jedi_vim.print_to_stdout, speed=True, warnings=False, notices=False)
|
||||
"PythonJedi jedi_vim.jedi.set_debug_function(jedi_vim.print_to_stdout)
|
||||
|
||||
" vim: set et ts=4:
|
||||
60
sources_non_forked/jedi-vim/conftest.py
Normal file
60
sources_non_forked/jedi-vim/conftest.py
Normal file
|
|
@ -0,0 +1,60 @@
|
|||
import os
|
||||
import subprocess
|
||||
import urllib
|
||||
import zipfile
|
||||
|
||||
import pytest
|
||||
|
||||
VSPEC_URL = 'https://github.com/kana/vim-vspec/archive/1.4.1.zip'
|
||||
CACHE_FOLDER = '.cache'
|
||||
VSPEC_FOLDER = os.path.join(CACHE_FOLDER, 'vim-vspec-1.4.1')
|
||||
VSPEC_RUNNER = os.path.join(VSPEC_FOLDER, 'bin/vspec')
|
||||
TEST_DIR = 'test'
|
||||
|
||||
|
||||
class IntegrationTestFile(object):
|
||||
def __init__(self, path):
|
||||
self.path = path
|
||||
|
||||
def run(self):
|
||||
output = subprocess.check_output(
|
||||
[VSPEC_RUNNER, '.', VSPEC_FOLDER, self.path])
|
||||
for line in output.splitlines():
|
||||
if line.startswith(b'not ok') or line.startswith(b'Error'):
|
||||
pytest.fail("{} failed:\n{}".format(
|
||||
self.path, output.decode('utf-8')), pytrace=False)
|
||||
|
||||
def __repr__(self):
|
||||
return "<%s: %s>" % (type(self), self.path)
|
||||
|
||||
|
||||
def pytest_configure(config):
|
||||
if not os.path.isdir(CACHE_FOLDER):
|
||||
os.mkdir(CACHE_FOLDER)
|
||||
|
||||
if not os.path.exists(VSPEC_FOLDER):
|
||||
name, hdrs = urllib.urlretrieve(VSPEC_URL)
|
||||
z = zipfile.ZipFile(name)
|
||||
for n in z.namelist():
|
||||
dest = os.path.join(CACHE_FOLDER, n)
|
||||
destdir = os.path.dirname(dest)
|
||||
if not os.path.isdir(destdir):
|
||||
os.makedirs(destdir)
|
||||
data = z.read(n)
|
||||
if not os.path.isdir(dest):
|
||||
with open(dest, 'w') as f:
|
||||
f.write(data)
|
||||
z.close()
|
||||
os.chmod(VSPEC_RUNNER, 0o777)
|
||||
|
||||
|
||||
def pytest_generate_tests(metafunc):
|
||||
"""
|
||||
:type metafunc: _pytest.python.Metafunc
|
||||
"""
|
||||
def collect_tests():
|
||||
for f in os.listdir(TEST_DIR):
|
||||
if f.endswith('.vim'):
|
||||
yield IntegrationTestFile(os.path.join(TEST_DIR, f))
|
||||
|
||||
metafunc.parametrize('case', list(collect_tests()))
|
||||
508
sources_non_forked/jedi-vim/doc/jedi-vim.txt
Normal file
508
sources_non_forked/jedi-vim/doc/jedi-vim.txt
Normal file
|
|
@ -0,0 +1,508 @@
|
|||
*jedi-vim.txt* - For Vim version 7.3 - Last change: 2014/07/29
|
||||
__ _______ _______ __ ____ ____ __ .___ ___.~
|
||||
| | | ____|| \ | | \ \ / / | | | \/ |~
|
||||
| | | |__ | .--. || | _____\ \/ / | | | \ / |~
|
||||
.--. | | | __| | | | || | |______\ / | | | |\/| |~
|
||||
| `--' | | |____ | '--' || | \ / | | | | | |~
|
||||
\______/ |_______||_______/ |__| \__/ |__| |__| |__|~
|
||||
|
||||
jedi-vim - awesome Python autocompletion with Vim
|
||||
|
||||
==============================================================================
|
||||
Contents *jedi-vim-contents*
|
||||
|
||||
1. Introduction |jedi-vim-introduction|
|
||||
2. Installation |jedi-vim-installation|
|
||||
2.0. Requirements |jedi-vim-installation-requirements|
|
||||
2.1. Manually |jedi-vim-installation-manually|
|
||||
2.2. Using Pathogen |jedi-vim-installation-pathogen|
|
||||
2.3. Using Vundle |jedi-vim-installation-vundle|
|
||||
2.4. Installing from Repositories |jedi-vim-installation-repos|
|
||||
3. Supported Python features |jedi-vim-support|
|
||||
4. Usage |jedi-vim-usage|
|
||||
5. Mappings |jedi-vim-keybindings|
|
||||
5.1. Start completion |g:jedi#completions_command|
|
||||
5.2. Go to definition |g:jedi#goto_command|
|
||||
5.3. Go to assignment |g:jedi#goto_assignments_command|
|
||||
5.4 Go to definition (deprecated) |g:jedi#goto_definitions_command|
|
||||
5.5. Show documentation |g:jedi#documentation_command|
|
||||
5.6. Rename variables |g:jedi#rename_command|
|
||||
5.7. Show name usages |g:jedi#usages_command|
|
||||
5.8. Open module by name |:Pyimport|
|
||||
6. Configuration |jedi-vim-configuration|
|
||||
6.1. auto_initialization |g:jedi#auto_initialization|
|
||||
6.2. auto_vim_configuration |g:jedi#auto_vim_configuration|
|
||||
6.3. popup_on_dot |g:jedi#popup_on_dot|
|
||||
6.4. popup_select_first |g:jedi#popup_select_first|
|
||||
6.5. auto_close_doc |g:jedi#auto_close_doc|
|
||||
6.6. show_call_signatures |g:jedi#show_call_signatures|
|
||||
6.7. use_tabs_not_buffers |g:jedi#use_tabs_not_buffers|
|
||||
6.8. squelch_py_warning |g:jedi#squelch_py_warning|
|
||||
6.9. completions_enabled |g:jedi#completions_enabled|
|
||||
6.10. use_splits_not_buffers |g:jedi#use_splits_not_buffers|
|
||||
6.11. force_py_version |g:jedi#force_py_version|
|
||||
7. Testing |jedi-vim-testing|
|
||||
8. Contributing |jedi-vim-contributing|
|
||||
9. License |jedi-vim-license|
|
||||
|
||||
==============================================================================
|
||||
1. Introduction *jedi-vim-introduction*
|
||||
|
||||
Jedi-vim is a Vim binding to the awesome Python autocompletion library
|
||||
`jedi`. Among jedi's (and, therefore, jedi-vim's) features are:
|
||||
|
||||
- Completion for a wide array of Python features (see |jedi-vim-support|)
|
||||
- Robust in dealing with syntax errors and wrong indentation
|
||||
- Parses complex module/function/class structures
|
||||
- Infers function arguments from Sphinx/Epydoc strings
|
||||
- Doesn't execute Python code
|
||||
- Supports Virtualenv
|
||||
- Supports Python 2.5+ and 3.2+
|
||||
|
||||
By leveraging this library, jedi-vim adds the following capabilities to Vim:
|
||||
|
||||
- Displaying function/class bodies
|
||||
- "Go to definition" command
|
||||
- Displaying docstrings
|
||||
- Renaming and refactoring
|
||||
- Looking up related names
|
||||
|
||||
==============================================================================
|
||||
2. Installation *jedi-vim-installation*
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
2.0. Requirements *jedi-vim-installation-requirements*
|
||||
|
||||
First of all, jedi-vim requires Vim to be compiled with the `+python` option.
|
||||
|
||||
The jedi library has to be installed for jedi-vim to work properly. You can
|
||||
install it first, by using e.g. your distribution's package manager, or by
|
||||
using pip: >
|
||||
|
||||
pip install jedi
|
||||
|
||||
However, you can also install it as a git submodule if you don't want to use
|
||||
jedi for anything but this plugin. How to do this is detailed below.
|
||||
|
||||
It is best if you have VIM >= 7.3, compiled with the `+conceal` option. With
|
||||
older versions, you will probably not see the parameter recommendation list
|
||||
for functions after typing the open bracket. Some platforms (including OS X
|
||||
releases) do not ship a VIM with `+conceal`. You can check if your VIM has the
|
||||
feature with >
|
||||
|
||||
:ver
|
||||
|
||||
and look for "`+conceal`" (as opposed to "`-conceal`") or >
|
||||
|
||||
:echo has('conceal')
|
||||
|
||||
which will report 0 (not included) or 1 (included). If your VIM lacks this
|
||||
feature and you would like function parameter completion, you will need to
|
||||
build your own VIM, or use a package for your operating system that has this
|
||||
feature (such as MacVim on OS X, which also contains a console binary).
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
2.1. Installing manually *jedi-vim-installation-manually*
|
||||
|
||||
1a. Get the latest repository from Github: >
|
||||
|
||||
git clone http://github.com/davidhalter/jedi-vim path/to/bundles/jedi-vim
|
||||
|
||||
1b. If you want to install jedi as a submodule instead, issue this command: >
|
||||
|
||||
git clone --recursive http://github.com/davidhalter/jedi-vim
|
||||
|
||||
2. Put the plugin files into their respective folders in your vim runtime
|
||||
directory (usually ~/.vim). Be sure to pay attention to the directory
|
||||
structure!
|
||||
3. Update the Vim help tags with >
|
||||
|
||||
:helptags <path/to/vimruntime>/doc
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
2.1. Installing using Pathogen *jedi-vim-installation-pathogen*
|
||||
|
||||
Pathogen simplifies installation considerably.
|
||||
|
||||
1.a Clone the git repository into your bundles directory: >
|
||||
|
||||
git clone http://github.com/davidhalter/jedi-vim path/to/bundles/jedi-vim
|
||||
|
||||
1b. Again, if you want to install jedi as a submodule, use this command
|
||||
instead: >
|
||||
|
||||
git clone --recursive http://github.com/davidhalter/jedi-vim
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
2.3. Installing using Vundle *jedi-vim-installation-vundle*
|
||||
|
||||
1. Vundle automatically downloads subrepositories as git submodules, so you
|
||||
will automatically get the jedi library with the jedi-vim plugin. Add the
|
||||
following to the Bundles section in your .vimrc file: >
|
||||
|
||||
Plugin 'davidhalter/jedi-vim'
|
||||
|
||||
2. Issue the following command in Vim: >
|
||||
|
||||
:PluginInstall
|
||||
|
||||
Help tags are generated automatically, so you should be good to go.
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
2.4. Installing from Repositories *jedi-vim-installation-repos*
|
||||
|
||||
Some Linux distributions have jedi-vim packages in their official
|
||||
repositories. On Arch Linux, install vim-jedi. On Debian (8+) or Ubuntu
|
||||
(14.04+) install vim-python-jedi.
|
||||
|
||||
==============================================================================
|
||||
3. Supported Python features *jedi-vim-support*
|
||||
|
||||
The Jedi library does all the hard work behind the scenes. It supports
|
||||
completion of a large number of Python features, among them:
|
||||
|
||||
- Builtins
|
||||
- Multiple `return`s or `yield`s
|
||||
- Tuple assignments/array indexing/dictionary indexing
|
||||
- `with`-statement/exception handling
|
||||
- `*args` and `**kwargs`
|
||||
- Decorators, lambdas, closures
|
||||
- Generators, iterators
|
||||
- Some descriptors: `property`/`staticmethod`/`classmethod`
|
||||
- Some magic methods: `__call__`, `__iter__`, `__next__`, `__get__`,
|
||||
`__getitem__`, `__init__`
|
||||
- `list.append()`, `set.add()`, `list.extend()`, etc.
|
||||
- (Nested) list comprehensions and ternary expressions
|
||||
- Relative `import`s
|
||||
- `getattr()`/`__getattr__`/`__getattribute__`
|
||||
- Function annotations (py3k feature, are being ignored at the moment, but are
|
||||
parsed)
|
||||
- Class decorators (py3k feature, are being ignored at the moment, but are
|
||||
parsed)
|
||||
- Simple/usual `sys.path` modifications
|
||||
- `isinstance` checks for `if`/`while`/`assert` case, that doesn’t work with
|
||||
Jedi
|
||||
- And more...
|
||||
|
||||
Note: This list is not necessarily up to date. For a complete list of
|
||||
features, please refer to the Jedi documentation at http://jedi.jedidjah.ch.
|
||||
|
||||
==============================================================================
|
||||
4. Usage *jedi-vim-usage*
|
||||
|
||||
With the default settings, autocompletion can be triggered by typing
|
||||
<Ctrl-Space>. The first entry will automatically be selected, so you can press
|
||||
<Return> to insert it into your code or keep typing and narrow down your
|
||||
completion options. The usual <C-X><C-O> and <C-P>/<C-N> keybindings work as
|
||||
well. Autocompletion is also triggered by typing a period in insert mode.
|
||||
Since periods rarely occur in Python code outside of method/import lookups,
|
||||
this is handy to have (but can be disabled).
|
||||
|
||||
When it encounters a new module, jedi might take a few seconds to parse that
|
||||
module's contents. Afterwards, the contents are cached and completion will be
|
||||
almost instantaneous.
|
||||
|
||||
==============================================================================
|
||||
5. Key Bindings *jedi-vim-keybindings*
|
||||
|
||||
All keybindings can be mapped by setting the appropriate global option. For
|
||||
example, to set the keybinding for starting omnicompletion to <C-N> instead of
|
||||
<Ctrl-Space>, add the following setting to your .vimrc file: >
|
||||
|
||||
let g:jedi#completions_command = "<C-N>"
|
||||
|
||||
Note: If you have |g:jedi#auto_initialization| set to 0, you have to create
|
||||
a mapping yourself by calling a function: >
|
||||
|
||||
" Using <C-N> for omnicompletion
|
||||
inoremap <silent> <buffer> <C-N> <c-x><c-o>
|
||||
" Use <localleader>r (by default <\-r>) for renaming
|
||||
nnoremap <silent> <buffer> <localleader>r :call jedi#rename()<cr>
|
||||
" etc.
|
||||
|
||||
Note: You can set commands to '', which means that they are empty and not
|
||||
assigned. It's an easy way to "disable" functionality of jedi-vim.
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
5.1. `g:jedi#completions_command` *g:jedi#completions_command*
|
||||
Function: n/a; see above
|
||||
Default: <Ctrl-Space> Start completion
|
||||
|
||||
Performs autocompletion (or omnicompletion, to be precise).
|
||||
|
||||
Note: If you want to use <Tab> for completion, please install Supertab:
|
||||
https://github.com/ervandew/supertab.
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
5.2. `g:jedi#goto_command` *g:jedi#goto_command*
|
||||
Function: `jedi#goto()`
|
||||
Default: <leader>d Go to definition (or assignment)
|
||||
|
||||
This function first tries |jedi#goto_definitions|, and falls back to
|
||||
|jedi#goto_assignments| for builtin modules. It produces an error if nothing
|
||||
could be found.
|
||||
NOTE: this implementation is subject to change.
|
||||
Ref: https://github.com/davidhalter/jedi/issues/570
|
||||
|
||||
This command tries to find the original definition of the function/class under
|
||||
the cursor. Just like the `jedi#goto_assignments()` function, it does not work
|
||||
if the definition isn't in a Python source file.
|
||||
|
||||
The difference between `jedi#goto_assignments()` and `jedi#goto_definitions()`
|
||||
is that the latter performs recursive lookups. Take, for example, the
|
||||
following module structure: >
|
||||
|
||||
# file1.py:
|
||||
from file2 import foo
|
||||
|
||||
# file2.py:
|
||||
from file3 import bar as foo
|
||||
|
||||
# file3.py
|
||||
def bar():
|
||||
pass
|
||||
|
||||
The `jedi#goto_assignments()` function will take you to the >
|
||||
|
||||
from file2 import foo
|
||||
|
||||
statement in file1.py, while the `jedi#goto_definitions()` function will take
|
||||
you all the way to the >
|
||||
|
||||
def bar():
|
||||
|
||||
line in file3.py.
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
5.3. `g:jedi#goto_assignments_command` *g:jedi#goto_assignments_command*
|
||||
Function: `jedi#goto_assignments()`
|
||||
Default: <leader>g Go to assignment
|
||||
|
||||
This function finds the first definition of the function/class under the
|
||||
cursor. It produces an error if the definition is not in a Python file.
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
5.4. `g:jedi#goto_definitions_command` *g:jedi#goto_definitions_command*
|
||||
Function: `jedi#goto_definitions()`
|
||||
Default: - Go to original definition
|
||||
|
||||
NOTE: Deprecated. Use |g:jedi#goto_command| / |jedi#goto()| instead, which
|
||||
currently uses this internally.
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
5.5. `g:jedi#documentation_command` *g:jedi#documentation_command*
|
||||
Function: `jedi#show_documentation()`
|
||||
Default: <K> Show pydoc documentation
|
||||
|
||||
This shows the pydoc documentation for the item currently under the cursor.
|
||||
The documentation is opened in a horizontally split buffer. The height of this
|
||||
buffer is controlled by `g:jedi#max_doc_height` (set by default to 30).
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
5.6. `g:jedi#rename_command` *g:jedi#rename_command*
|
||||
Function: `jedi#rename()`
|
||||
Default: <leader>r Rename variables
|
||||
|
||||
Jedi-vim deletes the word currently under the cursor and puts Vim in insert
|
||||
mode, where the user is expected to enter the new variable name. Upon leaving
|
||||
insert mode, jedi-vim then renames all occurences of the old variable name
|
||||
with the new one. The number of performed renames is displayed in the command
|
||||
line.
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
5.7. `g:jedi#usages_command` *g:jedi#usages_command*
|
||||
Function: `jedi#usages()`
|
||||
Default: <leader>n Show usages of a name.
|
||||
|
||||
The quickfix window is populated with a list of all names which point to the
|
||||
definition of the name under the cursor.
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
5.8. Open module by name *:Pyimport*
|
||||
Function: `jedi#py_import(args)`
|
||||
Default: :Pyimport e.g. `:Pyimport os` shows os.py in VIM.
|
||||
|
||||
Simulate an import and open that module in VIM.
|
||||
|
||||
==============================================================================
|
||||
6. Configuration *jedi-vim-configuration*
|
||||
|
||||
Note: You currently have to set these options in your .vimrc. Setting them in
|
||||
an ftplugin (e.g. ~/.vim/ftplugin/python/jedi-vim-settings.vim) will not work
|
||||
because jedi-vim is not set up as an filetype plugin, but as a "regular"
|
||||
plugin.
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
6.1. `g:jedi#auto_initialization` *g:jedi#auto_initialization*
|
||||
|
||||
Upon initialization, jedi-vim performs the following steps:
|
||||
|
||||
1. Set the current buffers 'omnifunc' to its own completion function
|
||||
`jedi#completions`
|
||||
2. Create mappings to commands specified in |jedi-vim-keybindings|
|
||||
3. Call `jedi#configure_call_signatures()` if
|
||||
`g:jedi#show_call_signatures` is set
|
||||
|
||||
You can disable the default initialization routine by setting this option to
|
||||
0. Beware that you have to perform the above steps yourself, though.
|
||||
|
||||
Options: 0 or 1
|
||||
Default: 1 (Perform automatic initialization)
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
6.2. `g:jedi#auto_vim_configuration` *g:jedi#auto_vim_configuration*
|
||||
|
||||
Jedi-vim sets 'completeopt' to `menuone,longest,preview` by default, if
|
||||
'completeopt' is not changed from Vim's default.
|
||||
It also remaps <Ctrl-C> to <Esc> in insert mode.
|
||||
|
||||
If you want to keep your own configuration, disable this setting.
|
||||
|
||||
Options: 0 or 1
|
||||
Default: 1 (Set 'completeopt' and mapping as described above)
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
6.3. `g:jedi#popup_on_dot` *g:jedi#popup_on_dot*
|
||||
|
||||
Jedi-vim automatically starts completion upon typing a period in insert mode.
|
||||
|
||||
However, when working with large modules, this can slow down your typing flow
|
||||
since you have to wait for jedi to parse the module and show the completion
|
||||
menu. By disabling this setting, completion is only started when you manually
|
||||
press the completion key.
|
||||
|
||||
Options: 0 or 1
|
||||
Default: 1 (Start completion on typing a period)
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
6.4. `g:jedi#popup_select_first` *g:jedi#popup_select_first*
|
||||
|
||||
Upon starting completion, jedi-vim can automatically select the first entry
|
||||
that pops up (without actually inserting it).
|
||||
|
||||
This leads to a better typing flow: As you type more characters, the entries
|
||||
in the completion menu are narrowed down. If they are narrowed down enough,
|
||||
you can just press <Return> to insert the first match.
|
||||
|
||||
Options: 0 or 1
|
||||
Default: 1 (Automatically select first completion entry)
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
6.5. `g:jedi#auto_close_doc` *g:jedi#auto_close_doc*
|
||||
|
||||
When doing completion, jedi-vim shows the docstring of the currently selected
|
||||
item in a preview window. By default, this window is being closed after
|
||||
insertion of a completion item.
|
||||
|
||||
Set this to 0 to leave the preview window open even after leaving insert mode.
|
||||
This could be useful if you want to browse longer docstrings.
|
||||
|
||||
Options: 0 or 1
|
||||
Default: 1 (Automatically close preview window upon leaving insert mode)
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
6.6. `g:jedi#show_call_signatures` *g:jedi#show_call_signatures*
|
||||
|
||||
Jedi-vim can display a small window detailing the arguments of the currently
|
||||
completed function and highlighting the currently selected argument. This can
|
||||
be disabled by setting this option to 0. Setting this option to 2 shows call
|
||||
signatures in the command line instead of a popup window.
|
||||
|
||||
Options: 0, 1, or 2
|
||||
Default: 1 (Show call signatures window)
|
||||
|
||||
Note: 'showmode' must be disabled for command line call signatures to be
|
||||
visible.
|
||||
|
||||
Note: This setting is ignored if |g:jedi#auto_initialization| is set to 0. In
|
||||
that case, if you want to see call signatures, you have to set it up
|
||||
manually by calling a function in your configuration file: >
|
||||
|
||||
call jedi#configure_call_signatures()
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
6.7. `g:jedi#use_tabs_not_buffers` *g:jedi#use_tabs_not_buffers*
|
||||
|
||||
You can make jedi-vim open a new tab if you use the "go to", "show
|
||||
definition", or "related names" commands. When you leave this at the default
|
||||
(0), they open in the current buffer instead.
|
||||
|
||||
Options: 0 or 1
|
||||
Default: 0 (Command output is put in a new tab)
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
6.8. `g:jedi#squelch_py_warning` *g:jedi#squelch_py_warning*
|
||||
|
||||
When Vim has not been compiled with +python, jedi-vim shows a warning to that
|
||||
effect and aborts loading itself. Set this to 1 to suppress that warning.
|
||||
|
||||
Options: 0 or 1
|
||||
Default: 0 (Warning is shown)
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
6.9. `g:jedi#completions_enabled` *g:jedi#completions_enabled*
|
||||
|
||||
If you don't want Jedi completion, but all the other features, you can disable
|
||||
it in favor of another completion engine (that probably also uses Jedi, like
|
||||
YCM).
|
||||
|
||||
Options: 0 or 1
|
||||
Default: 1
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
6.10. `g:jedi#use_splits_not_buffers` *g:jedi#use_splits_not_buffers*
|
||||
|
||||
If you want to open new split for "go to", you could set this option to the
|
||||
direction which you want to open a split with.
|
||||
|
||||
Options: top, left, right, bottom or winwidth
|
||||
Default: "" (not enabled by default)
|
||||
|
||||
Note: with the 'winwidth' option the window is split vertically or horizontally
|
||||
depending on the width of the window relative to 'textwidth'. This essentially
|
||||
means that if the window is big enough it will be split vertically but if it is
|
||||
small a horizontal split happens.
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
6.11. `g:jedi#force_py_version` *g:jedi#force_py_version*
|
||||
|
||||
If you have installed both python 2 and python 3, you can force which one jedi
|
||||
should use by setting this variable. It forces the internal Vim command, which
|
||||
will be used for every jedi call to the respective python interpreter.
|
||||
The variable can be set in the .vimrc like this to force python 3:
|
||||
|
||||
let g:jedi#force_py_version = 3
|
||||
|
||||
This variable can be switched during runtime using the following function:
|
||||
Function: `jedi#force_py_version_switch()`
|
||||
|
||||
or set directly using this function, which has the same name as the variable:
|
||||
Function: `jedi#force_py_version(py_version)`
|
||||
|
||||
Options: 2 or 3
|
||||
Default: "auto" (will use sys.version_info from "python" in your $PATH)
|
||||
|
||||
==============================================================================
|
||||
7. Testing *jedi-vim-testing*
|
||||
|
||||
jedi-vim is being tested with a combination of vspec
|
||||
https://github.com/kana/vim-vspec and py.test http://pytest.org/.
|
||||
|
||||
The tests are in the test subdirectory, you can run them calling::
|
||||
|
||||
py.test
|
||||
|
||||
The tests are automatically run with `travis
|
||||
<https://travis-ci.org/davidhalter/jedi-vim>`_.
|
||||
|
||||
==============================================================================
|
||||
8. Contributing *jedi-vim-contributing*
|
||||
|
||||
We love Pull Requests! Read the instructions in `CONTRIBUTING.md`.
|
||||
|
||||
==============================================================================
|
||||
9. License *jedi-vim-license*
|
||||
|
||||
Jedi-vim is licensed with the MIT license.
|
||||
|
||||
vim: textwidth=78 tabstop=8 filetype=help:norightleft:
|
||||
44
sources_non_forked/jedi-vim/ftplugin/python/jedi.vim
Normal file
44
sources_non_forked/jedi-vim/ftplugin/python/jedi.vim
Normal file
|
|
@ -0,0 +1,44 @@
|
|||
if !jedi#init_python()
|
||||
finish
|
||||
endif
|
||||
" ------------------------------------------------------------------------
|
||||
" Initialization of jedi-vim
|
||||
" ------------------------------------------------------------------------
|
||||
|
||||
if g:jedi#auto_initialization
|
||||
" goto / get_definition / usages
|
||||
if g:jedi#goto_command != ''
|
||||
execute "nnoremap <buffer> ".g:jedi#goto_command." :call jedi#goto()<CR>"
|
||||
endif
|
||||
if g:jedi#goto_assignments_command != ''
|
||||
execute "nnoremap <buffer> ".g:jedi#goto_assignments_command." :call jedi#goto_assignments()<CR>"
|
||||
endif
|
||||
if g:jedi#goto_definitions_command != ''
|
||||
execute "nnoremap <buffer> ".g:jedi#goto_definitions_command." :call jedi#goto_definitions()<CR>"
|
||||
endif
|
||||
if g:jedi#usages_command != ''
|
||||
execute "nnoremap <buffer> ".g:jedi#usages_command." :call jedi#usages()<CR>"
|
||||
endif
|
||||
" rename
|
||||
if g:jedi#rename_command != ''
|
||||
execute "nnoremap <buffer> ".g:jedi#rename_command." :call jedi#rename()<CR>"
|
||||
execute "vnoremap <buffer> ".g:jedi#rename_command." :call jedi#rename_visual()<CR>"
|
||||
endif
|
||||
" documentation/pydoc
|
||||
if g:jedi#documentation_command != ''
|
||||
execute "nnoremap <silent> <buffer>".g:jedi#documentation_command." :call jedi#show_documentation()<CR>"
|
||||
endif
|
||||
|
||||
if g:jedi#show_call_signatures > 0 && has('conceal')
|
||||
call jedi#configure_call_signatures()
|
||||
endif
|
||||
|
||||
if g:jedi#completions_enabled == 1
|
||||
inoremap <silent> <buffer> . .<C-R>=jedi#complete_string(1)<CR>
|
||||
endif
|
||||
|
||||
if g:jedi#auto_close_doc
|
||||
" close preview if its still open after insert
|
||||
autocmd InsertLeave <buffer> if pumvisible() == 0|pclose|endif
|
||||
endif
|
||||
endif
|
||||
22
sources_non_forked/jedi-vim/initialize.py
Normal file
22
sources_non_forked/jedi-vim/initialize.py
Normal file
|
|
@ -0,0 +1,22 @@
|
|||
''' ------------------------------------------------------------------------
|
||||
Python initialization
|
||||
---------------------------------------------------------------------------
|
||||
here we initialize the jedi stuff '''
|
||||
|
||||
import vim
|
||||
|
||||
# update the system path, to include the jedi path
|
||||
import sys
|
||||
import os
|
||||
|
||||
# vim.command('echom expand("<sfile>:p:h:h")') # broken, <sfile> inside function
|
||||
# sys.path.insert(0, os.path.join(vim.eval('expand("<sfile>:p:h:h")'), 'jedi'))
|
||||
sys.path.insert(0, os.path.join(vim.eval('expand(s:script_path)'), 'jedi'))
|
||||
|
||||
# to display errors correctly
|
||||
import traceback
|
||||
|
||||
# update the sys path to include the jedi_vim script
|
||||
sys.path.insert(0, vim.eval('expand(s:script_path)'))
|
||||
import jedi_vim
|
||||
sys.path.pop(1)
|
||||
1
sources_non_forked/jedi-vim/jedi
Submodule
1
sources_non_forked/jedi-vim/jedi
Submodule
|
|
@ -0,0 +1 @@
|
|||
Subproject commit 66557903ae4c1174eb437a8feeeb718e69d5fa3a
|
||||
643
sources_non_forked/jedi-vim/jedi_vim.py
Normal file
643
sources_non_forked/jedi-vim/jedi_vim.py
Normal file
|
|
@ -0,0 +1,643 @@
|
|||
"""
|
||||
The Python parts of the Jedi library for VIM. It is mostly about communicating
|
||||
with VIM.
|
||||
"""
|
||||
|
||||
import traceback # for exception output
|
||||
import re
|
||||
import os
|
||||
import sys
|
||||
from shlex import split as shsplit
|
||||
try:
|
||||
from itertools import zip_longest
|
||||
except ImportError:
|
||||
from itertools import izip_longest as zip_longest # Python 2
|
||||
|
||||
|
||||
is_py3 = sys.version_info[0] >= 3
|
||||
if is_py3:
|
||||
unicode = str
|
||||
|
||||
|
||||
class PythonToVimStr(unicode):
|
||||
""" Vim has a different string implementation of single quotes """
|
||||
__slots__ = []
|
||||
|
||||
def __new__(cls, obj, encoding='UTF-8'):
|
||||
if is_py3 or isinstance(obj, unicode):
|
||||
return unicode.__new__(cls, obj)
|
||||
else:
|
||||
return unicode.__new__(cls, obj, encoding)
|
||||
|
||||
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 self.message + '; created by: ' + repr(self.executing)
|
||||
|
||||
|
||||
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`.
|
||||
"""
|
||||
e = 'jedi#_vim_exceptions(%s, %s)'
|
||||
result = vim.eval(e % (repr(PythonToVimStr(string, 'UTF-8')), is_eval))
|
||||
if 'exception' in result:
|
||||
raise VimError(result['exception'], result['throwpoint'], string)
|
||||
return result['result']
|
||||
|
||||
|
||||
def vim_command(string):
|
||||
_catch_exception(string, 0)
|
||||
|
||||
|
||||
def vim_eval(string):
|
||||
return _catch_exception(string, 1)
|
||||
|
||||
|
||||
def no_jedi_warning():
|
||||
vim.command('echohl WarningMsg'
|
||||
'| echom "Please install Jedi if you want to use jedi-vim."'
|
||||
'| echohl None')
|
||||
|
||||
|
||||
def echo_highlight(msg):
|
||||
vim_command('echohl WarningMsg | echom "{}" | echohl None'.format(
|
||||
msg.replace('"', '\\"')))
|
||||
|
||||
|
||||
import vim
|
||||
try:
|
||||
import jedi
|
||||
except ImportError:
|
||||
no_jedi_warning()
|
||||
jedi = None
|
||||
else:
|
||||
try:
|
||||
version = jedi.__version__
|
||||
except Exception as e: # e.g. AttributeError
|
||||
echo_highlight("Could not load jedi python module: {}".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.')
|
||||
|
||||
|
||||
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
|
||||
|
||||
|
||||
@catch_and_print_exceptions
|
||||
def get_script(source=None, column=None):
|
||||
jedi.settings.additional_dynamic_modules = \
|
||||
[b.name for b in vim.buffers if b.name is not None and b.name.endswith('.py')]
|
||||
if source is None:
|
||||
source = '\n'.join(vim.current.buffer)
|
||||
row = vim.current.window.cursor[0]
|
||||
if column is None:
|
||||
column = vim.current.window.cursor[1]
|
||||
buf_path = vim.current.buffer.name
|
||||
encoding = vim_eval('&encoding') or 'latin1'
|
||||
return jedi.Script(source, row, column, buf_path, encoding)
|
||||
|
||||
|
||||
@_check_jedi_availability(show_error=False)
|
||||
@catch_and_print_exceptions
|
||||
def completions():
|
||||
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 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('[\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, column=column)
|
||||
completions = script.completions()
|
||||
signatures = script.call_signatures()
|
||||
|
||||
out = []
|
||||
for c in completions:
|
||||
d = dict(word=PythonToVimStr(c.name[:len(base)] + c.complete),
|
||||
abbr=PythonToVimStr(c.name),
|
||||
# stuff directly behind the completion
|
||||
menu=PythonToVimStr(c.description),
|
||||
info=PythonToVimStr(c.docstring()), # docstr
|
||||
icase=1, # case insensitive
|
||||
dup=1 # allow duplicates (maybe later remove this)
|
||||
)
|
||||
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)
|
||||
|
||||
|
||||
@_check_jedi_availability(show_error=True)
|
||||
@catch_and_print_exceptions
|
||||
def goto(mode="goto", no_output=False):
|
||||
"""
|
||||
:param str mode: "related_name", "definition", "assignment", "auto"
|
||||
:return: list of definitions/assignments
|
||||
:rtype: list
|
||||
"""
|
||||
script = get_script()
|
||||
try:
|
||||
if mode == "goto":
|
||||
definitions = [x for x in script.goto_definitions()
|
||||
if not x.in_builtin_module()]
|
||||
if not definitions:
|
||||
definitions = script.goto_assignments()
|
||||
elif mode == "related_name":
|
||||
definitions = script.usages()
|
||||
elif mode == "definition":
|
||||
definitions = script.goto_definitions()
|
||||
elif mode == "assignment":
|
||||
definitions = script.goto_assignments()
|
||||
except jedi.NotFoundError:
|
||||
echo_highlight("Cannot follow nothing. Put your cursor on a valid name.")
|
||||
definitions = []
|
||||
else:
|
||||
if no_output:
|
||||
return definitions
|
||||
if not definitions:
|
||||
echo_highlight("Couldn't find any definitions for this.")
|
||||
elif len(definitions) == 1 and mode != "related_name":
|
||||
# just add some mark to add the current position to the jumplist.
|
||||
# this is ugly, because it overrides the mark for '`', so if anyone
|
||||
# has a better idea, let me know.
|
||||
vim_command('normal! m`')
|
||||
|
||||
d = list(definitions)[0]
|
||||
if d.in_builtin_module():
|
||||
if d.is_keyword:
|
||||
echo_highlight("Cannot get the definition of Python keywords.")
|
||||
else:
|
||||
echo_highlight("Builtin modules cannot be displayed (%s)."
|
||||
% d.desc_with_module)
|
||||
else:
|
||||
if d.module_path != vim.current.buffer.name:
|
||||
result = new_buffer(d.module_path)
|
||||
if not result:
|
||||
return []
|
||||
vim.current.window.cursor = d.line, d.column
|
||||
else:
|
||||
# multiple solutions
|
||||
lst = []
|
||||
for d in definitions:
|
||||
if d.in_builtin_module():
|
||||
lst.append(dict(text=PythonToVimStr('Builtin ' + d.description)))
|
||||
else:
|
||||
lst.append(dict(filename=PythonToVimStr(d.module_path),
|
||||
lnum=d.line, col=d.column + 1,
|
||||
text=PythonToVimStr(d.description)))
|
||||
vim_eval('setqflist(%s)' % repr(lst))
|
||||
vim_eval('jedi#add_goto_window(' + str(len(lst)) + ')')
|
||||
return definitions
|
||||
|
||||
|
||||
@_check_jedi_availability(show_error=True)
|
||||
@catch_and_print_exceptions
|
||||
def show_documentation():
|
||||
script = get_script()
|
||||
try:
|
||||
definitions = script.goto_definitions()
|
||||
except jedi.NotFoundError:
|
||||
definitions = []
|
||||
except Exception:
|
||||
# print to stdout, will be in :messages
|
||||
definitions = []
|
||||
print("Exception, this shouldn't happen.")
|
||||
print(traceback.format_exc())
|
||||
|
||||
if not definitions:
|
||||
echo_highlight('No documentation found for that.')
|
||||
vim.command('return')
|
||||
else:
|
||||
docs = ['Docstring for %s\n%s\n%s' % (d.desc_with_module, '=' * 40, d.docstring())
|
||||
if d.docstring() else '|No Docstring for %s|' % d for d in definitions]
|
||||
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 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', 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 vim_eval("has('conceal') && g:jedi#show_call_signatures") == '0':
|
||||
return
|
||||
|
||||
if signatures == ():
|
||||
signatures = get_script().call_signatures()
|
||||
clear_call_signatures()
|
||||
|
||||
if not signatures:
|
||||
return
|
||||
|
||||
if vim_eval("g:jedi#show_call_signatures") == '2':
|
||||
return cmdline_call_signatures(signatures)
|
||||
|
||||
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)
|
||||
|
||||
params = [p.description.replace('\n', '') 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
|
||||
|
||||
# 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', '') for p in s.params]
|
||||
|
||||
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])
|
||||
text = ', '.join(params).replace('"', '\\"').replace(r'\n', r'\\n')
|
||||
|
||||
# Allow 12 characters for ruler/showcmd - setting noruler/noshowcmd
|
||||
# here causes incorrect undo history
|
||||
max_msg_len = int(vim_eval('&columns')) - 12
|
||||
max_num_spaces = (max_msg_len - len(signatures[0].call_name)
|
||||
- len(text) - 2) # 2 accounts for parentheses
|
||||
if max_num_spaces < 0:
|
||||
return # No room for the message
|
||||
_, column = signatures[0].bracket_start
|
||||
num_spaces = min(int(vim_eval('g:jedi#first_col +'
|
||||
'wincol() - col(".")')) +
|
||||
column - len(signatures[0].call_name),
|
||||
max_num_spaces)
|
||||
spaces = ' ' * num_spaces
|
||||
|
||||
try:
|
||||
index = [s.index for s in signatures if isinstance(s.index, int)][0]
|
||||
escaped_param = params[index].replace(r'\n', r'\\n')
|
||||
left = text.index(escaped_param)
|
||||
right = left + len(escaped_param)
|
||||
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].call_name, text[:left],
|
||||
text[left:right], text[right:]))
|
||||
except (TypeError, IndexError):
|
||||
vim_command(' echon "%s" | '
|
||||
'echohl Function | echon "%s" | '
|
||||
'echohl None | echon "(" | '
|
||||
'echohl jediFunction | echon "%s" | '
|
||||
'echohl None | echon ")"'
|
||||
% (spaces, signatures[0].call_name, text))
|
||||
|
||||
|
||||
@_check_jedi_availability(show_error=True)
|
||||
@catch_and_print_exceptions
|
||||
def rename():
|
||||
if not int(vim.eval('a:0')):
|
||||
vim_command('augroup jedi_rename')
|
||||
vim_command('autocmd InsertLeave <buffer> call jedi#rename(1)')
|
||||
vim_command('augroup END')
|
||||
|
||||
vim_command("let s:jedi_replace_orig = expand('<cword>')")
|
||||
vim_command('normal! diw')
|
||||
vim_command("let s:jedi_changedtick = b:changedtick")
|
||||
vim_command('startinsert')
|
||||
|
||||
else:
|
||||
# Remove autocommand.
|
||||
vim_command('autocmd! jedi_rename InsertLeave')
|
||||
|
||||
# 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
|
||||
|
||||
cursor = vim.current.window.cursor
|
||||
|
||||
# Undo new word, but only if something was changed, which is not the
|
||||
# case when ending insert mode right away.
|
||||
if vim_eval('b:changedtick != s:jedi_changedtick') == '1':
|
||||
vim_command('normal! u') # Undo new word.
|
||||
vim_command('normal! u') # Undo diw.
|
||||
|
||||
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 = goto(mode="related_name", no_output=True)
|
||||
# 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: (x.module_path, x.start_pos))
|
||||
buffers = set()
|
||||
for r in temp_rename:
|
||||
if r.in_builtin_module():
|
||||
continue
|
||||
|
||||
if os.path.abspath(vim.current.buffer.name) != r.module_path:
|
||||
result = new_buffer(r.module_path)
|
||||
if not result:
|
||||
echo_highlight("Jedi-vim: failed to create buffer window for {}!".format(r.module_path))
|
||||
continue
|
||||
|
||||
buffers.add(vim.current.buffer.name)
|
||||
|
||||
# Save view.
|
||||
saved_view = vim_eval('string(winsaveview())')
|
||||
|
||||
# Replace original word.
|
||||
vim.current.window.cursor = r.start_pos
|
||||
vim_command('normal! c{:d}l{}'.format(len(orig), replace))
|
||||
|
||||
# Restore view.
|
||||
vim_command('call winrestview(%s)' % saved_view)
|
||||
|
||||
# Restore previous tab and window.
|
||||
vim_command('tabnext {:d}'.format(saved_tab))
|
||||
vim_command('{:d}wincmd w'.format(saved_win))
|
||||
|
||||
if len(buffers) > 1:
|
||||
echo_highlight('Jedi did {:d} renames in {:d} buffers!'.format(
|
||||
len(temp_rename), len(buffers)))
|
||||
else:
|
||||
echo_highlight('Jedi did {:d} renames!'.format(len(temp_rename)))
|
||||
|
||||
|
||||
@_check_jedi_availability(show_error=True)
|
||||
@catch_and_print_exceptions
|
||||
def py_import():
|
||||
# args are the same as for the :edit command
|
||||
args = shsplit(vim.eval('a:args'))
|
||||
import_path = args.pop()
|
||||
text = 'import %s' % import_path
|
||||
scr = jedi.Script(text, 1, len(text), '')
|
||||
try:
|
||||
completion = scr.goto_assignments()[0]
|
||||
except IndexError:
|
||||
echo_highlight('Cannot find %s in sys.path!' % import_path)
|
||||
else:
|
||||
if completion.in_builtin_module():
|
||||
echo_highlight('%s is a builtin module.' % import_path)
|
||||
else:
|
||||
cmd_args = ' '.join([a.replace(' ', '\\ ') for a in args])
|
||||
new_buffer(completion.module_path, cmd_args)
|
||||
|
||||
|
||||
@catch_and_print_exceptions
|
||||
def py_import_completions():
|
||||
argl = vim.eval('a:argl')
|
||||
try:
|
||||
import jedi
|
||||
except ImportError:
|
||||
print('Pyimport completion requires jedi module: https://github.com/davidhalter/jedi')
|
||||
comps = []
|
||||
else:
|
||||
text = 'import %s' % argl
|
||||
script = jedi.Script(text, 1, len(text), '')
|
||||
comps = ['%s%s' % (argl, c.complete) for c in script.completions()]
|
||||
vim.command("return '%s'" % '\n'.join(comps))
|
||||
|
||||
|
||||
@catch_and_print_exceptions
|
||||
def new_buffer(path, options=''):
|
||||
# options are what you can to edit the edit options
|
||||
if vim_eval('g:jedi#use_tabs_not_buffers') == '1':
|
||||
_tabnew(path, options)
|
||||
elif not vim_eval('g:jedi#use_splits_not_buffers') == '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('g:jedi#use_splits_not_buffers value is not correct, valid options are: %s' % ','.join(split_options.keys()))
|
||||
else:
|
||||
vim_command(split_options[user_split_option] + " %s" % path)
|
||||
else:
|
||||
if vim_eval("!&hidden && &modified") == '1':
|
||||
if vim_eval("bufname('%')") is None:
|
||||
echo_highlight('Cannot open a new buffer, use `:set hidden` or save your buffer')
|
||||
return False
|
||||
else:
|
||||
vim_command('w')
|
||||
vim_command('edit %s %s' % (options, escape_file_path(path)))
|
||||
# sometimes syntax is being disabled and the filetype not set.
|
||||
if vim_eval('!exists("g:syntax_on")') == '1':
|
||||
vim_command('syntax enable')
|
||||
if 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.
|
||||
"""
|
||||
path = os.path.abspath(path)
|
||||
if 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 buf_path == 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)
|
||||
33
sources_non_forked/jedi-vim/plugin/jedi.vim
Normal file
33
sources_non_forked/jedi-vim/plugin/jedi.vim
Normal file
|
|
@ -0,0 +1,33 @@
|
|||
"jedi-vim - Omni Completion for python in vim
|
||||
" Maintainer: David Halter <davidhalter88@gmail.com>
|
||||
"
|
||||
" This part of the software is just the vim interface. The really big deal is
|
||||
" the Jedi Python library.
|
||||
|
||||
if !exists("g:jedi#auto_vim_configuration") || g:jedi#auto_vim_configuration
|
||||
" jedi-vim doesn't work in compatible mode (vim script syntax problems)
|
||||
if &compatible
|
||||
set nocompatible
|
||||
endif
|
||||
|
||||
" jedi-vim really needs, otherwise jedi-vim cannot start.
|
||||
filetype plugin on
|
||||
|
||||
" Change completeopt, but only if it has Vim's default value.
|
||||
let s:save_completeopt=&completeopt
|
||||
set completeopt&
|
||||
let s:default_completeopt=&completeopt
|
||||
let &completeopt=s:save_completeopt
|
||||
if s:default_completeopt == &completeopt
|
||||
set completeopt=menuone,longest,preview
|
||||
endif
|
||||
|
||||
if len(mapcheck('<C-c>', 'i')) == 0
|
||||
inoremap <C-c> <ESC>
|
||||
endif
|
||||
endif
|
||||
|
||||
" Pyimport command
|
||||
command! -nargs=1 -complete=custom,jedi#py_import_completions Pyimport :call jedi#py_import(<q-args>)
|
||||
|
||||
" vim: set et ts=4:
|
||||
3
sources_non_forked/jedi-vim/pytest.ini
Normal file
3
sources_non_forked/jedi-vim/pytest.ini
Normal file
|
|
@ -0,0 +1,3 @@
|
|||
[pytest]
|
||||
# Ignore all files
|
||||
norecursedirs = *
|
||||
52
sources_non_forked/jedi-vim/test/completions.vim
Normal file
52
sources_non_forked/jedi-vim/test/completions.vim
Normal file
|
|
@ -0,0 +1,52 @@
|
|||
let g:jedi#completions_command = 'X'
|
||||
source plugin/jedi.vim
|
||||
|
||||
describe 'completions'
|
||||
before
|
||||
new
|
||||
set filetype=python
|
||||
end
|
||||
|
||||
after
|
||||
bd!
|
||||
end
|
||||
|
||||
it 'import'
|
||||
" X is the completion command
|
||||
normal oimporX
|
||||
Expect getline('.') == 'import'
|
||||
normal a subproX
|
||||
Expect getline('.') == 'import subprocess'
|
||||
end
|
||||
|
||||
it 'exception'
|
||||
normal oIndentationErrX
|
||||
Expect getline('.') == 'IndentationError'
|
||||
normal a().filenaX
|
||||
Expect getline('.') == 'IndentationError().filename'
|
||||
end
|
||||
|
||||
it 'dot_open'
|
||||
normal oraisX ImpXErrX()
|
||||
Expect getline('.') == 'raise ImportError()'
|
||||
end
|
||||
|
||||
it 'cycling through entries'
|
||||
" testing select_first doesn't seem to work in ex mode
|
||||
execute "normal oraise impX\<C-n>\<C-n>\<C-n>"
|
||||
Expect getline('.') == 'raise ImportWarning'
|
||||
let g:jedi#popup_select_first = 0
|
||||
execute "normal oraise impX\<C-n>\<C-n>\<C-n>"
|
||||
Expect getline('.') == 'raise ImportWarning'
|
||||
let g:jedi#popup_select_first = 1
|
||||
|
||||
" -longest completes the first one
|
||||
set completeopt -=longest
|
||||
execute "normal oraise baseX"
|
||||
Expect getline('.') == 'raise BaseException'
|
||||
set completeopt +=longest
|
||||
|
||||
end
|
||||
end
|
||||
|
||||
" vim: et:ts=4:sw=4
|
||||
21
sources_non_forked/jedi-vim/test/completions_disabled.vim
Normal file
21
sources_non_forked/jedi-vim/test/completions_disabled.vim
Normal file
|
|
@ -0,0 +1,21 @@
|
|||
let g:jedi#completions_command = 'X'
|
||||
let g:jedi#completions_enabled = 0
|
||||
source plugin/jedi.vim
|
||||
|
||||
describe 'completions_disabled'
|
||||
before
|
||||
new
|
||||
set filetype=python
|
||||
end
|
||||
|
||||
after
|
||||
bd!
|
||||
end
|
||||
|
||||
it 'typing'
|
||||
normal oraise ImportErrX
|
||||
Expect getline('.') == 'raise ImportErrX'
|
||||
end
|
||||
end
|
||||
|
||||
" vim: et:ts=4:sw=4
|
||||
31
sources_non_forked/jedi-vim/test/documentation.vim
Normal file
31
sources_non_forked/jedi-vim/test/documentation.vim
Normal file
|
|
@ -0,0 +1,31 @@
|
|||
source plugin/jedi.vim
|
||||
|
||||
describe 'documentation docstrings'
|
||||
before
|
||||
set filetype=python
|
||||
end
|
||||
|
||||
after
|
||||
bd!
|
||||
bd!
|
||||
end
|
||||
|
||||
it 'simple'
|
||||
put = 'ImportError'
|
||||
normal GK
|
||||
Expect bufname('%') == "'__doc__'"
|
||||
Expect &filetype == 'rst'
|
||||
let content = join(getline(1,'$'), "\n")
|
||||
Expect stridx(content, "Import can't find module") > 0
|
||||
normal K
|
||||
Expect bufname('%') == ''
|
||||
end
|
||||
|
||||
it 'no documentation'
|
||||
put = 'x = 2'
|
||||
normal o<ESC>GK
|
||||
Expect bufname('%') == ''
|
||||
end
|
||||
end
|
||||
|
||||
" vim: et:ts=4:sw=4
|
||||
180
sources_non_forked/jedi-vim/test/goto.vim
Normal file
180
sources_non_forked/jedi-vim/test/goto.vim
Normal file
|
|
@ -0,0 +1,180 @@
|
|||
let mapleader = '\'
|
||||
source plugin/jedi.vim
|
||||
source test/utils.vim
|
||||
|
||||
describe 'goto_simple'
|
||||
before
|
||||
new " open a new split
|
||||
set filetype=python
|
||||
put =[
|
||||
\ 'def a(): pass',
|
||||
\ 'b = a',
|
||||
\ 'c = b',
|
||||
\ ]
|
||||
normal! ggdd
|
||||
normal! G$
|
||||
Expect line('.') == 3
|
||||
end
|
||||
|
||||
after
|
||||
bd!
|
||||
end
|
||||
|
||||
it 'goto_definitions'
|
||||
silent normal \d
|
||||
Expect line('.') == 1
|
||||
"Expect col('.') == 5 " not working yet.
|
||||
end
|
||||
|
||||
it 'goto_assignments'
|
||||
silent normal \g
|
||||
Expect line('.') == 2
|
||||
Expect col('.') == 1
|
||||
|
||||
" cursor before `=` means that it stays there.
|
||||
silent normal \g
|
||||
Expect line('.') == 2
|
||||
Expect col('.') == 1
|
||||
|
||||
" going to the last line changes it.
|
||||
normal! $
|
||||
silent normal \g
|
||||
Expect line('.') == 1
|
||||
Expect col('.') == 5
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
describe 'goto_with_tabs'
|
||||
before
|
||||
set filetype=python
|
||||
let g:jedi#use_tabs_not_buffers = 1
|
||||
end
|
||||
|
||||
after
|
||||
bd!
|
||||
bd!
|
||||
end
|
||||
|
||||
it 'follow_import'
|
||||
put = ['import subprocess', 'subprocess']
|
||||
silent normal G\g
|
||||
Expect getline('.') == 'import subprocess'
|
||||
Expect line('.') == 2
|
||||
Expect col('.') == 8
|
||||
|
||||
silent normal G\d
|
||||
Expect CurrentBufferIsModule('subprocess') == 1
|
||||
Expect line('.') == 1
|
||||
Expect col('.') == 1
|
||||
Expect tabpagenr('$') == 2
|
||||
Expect winnr('$') == 1
|
||||
tabprevious
|
||||
Expect bufname('%') == ''
|
||||
end
|
||||
|
||||
it 'multi_definitions'
|
||||
" This used to behave differently. Now we don't have any real multi
|
||||
" definitions.
|
||||
|
||||
" put = ['import tokenize']
|
||||
" silent normal G$\d
|
||||
" Expect CurrentBufferIsModule('tokenize') == 1
|
||||
" Expect CurrentBufferIsModule('token') == 0
|
||||
" execute "normal \<CR>"
|
||||
" Expect tabpagenr('$') == 2
|
||||
" Expect winnr('$') == 1
|
||||
" Expect CurrentBufferIsModule('token') == 1
|
||||
|
||||
" bd
|
||||
" silent normal G$\d
|
||||
" execute "normal j\<CR>"
|
||||
" Expect tabpagenr('$') == 2
|
||||
" Expect winnr('$') == 1
|
||||
" Expect CurrentBufferIsModule('tokenize') == 1
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
describe 'goto_with_buffers'
|
||||
before
|
||||
set filetype=python
|
||||
let g:jedi#use_tabs_not_buffers = 0
|
||||
end
|
||||
|
||||
after
|
||||
bd!
|
||||
bd!
|
||||
set nohidden
|
||||
end
|
||||
|
||||
it 'no_new_tabs'
|
||||
put = ['import os']
|
||||
normal G$
|
||||
call jedi#goto_assignments()
|
||||
python jedi_vim.goto()
|
||||
Expect CurrentBufferIsModule('os') == 0
|
||||
" Without hidden, it's not possible to open a new buffer, when the old
|
||||
" one is not saved.
|
||||
set hidden
|
||||
call jedi#goto_assignments()
|
||||
Expect CurrentBufferIsModule('os') == 1
|
||||
Expect winnr('$') == 1
|
||||
Expect tabpagenr('$') == 1
|
||||
Expect line('.') == 1
|
||||
Expect col('.') == 1
|
||||
end
|
||||
|
||||
it 'multi_definitions'
|
||||
" set hidden
|
||||
" put = ['import tokenize']
|
||||
" silent normal G$\d
|
||||
" Expect CurrentBufferIsModule('tokenize') == 0
|
||||
" Expect CurrentBufferIsModule('token') == 0
|
||||
" execute "normal \<CR>"
|
||||
" Expect tabpagenr('$') == 1
|
||||
" Expect winnr('$') == 1
|
||||
" Expect CurrentBufferIsModule('token') == 1
|
||||
|
||||
" bd
|
||||
" silent normal G$\d
|
||||
" execute "normal j\<CR>"
|
||||
" Expect tabpagenr('$') == 1
|
||||
" Expect winnr('$') == 1
|
||||
" Expect CurrentBufferIsModule('tokenize') == 1
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
|
||||
describe 'goto_with_splits'
|
||||
before
|
||||
set filetype=python
|
||||
let g:jedi#use_splits_not_buffers = 'left'
|
||||
end
|
||||
|
||||
after
|
||||
bd!
|
||||
bd!
|
||||
end
|
||||
|
||||
it 'follow_import'
|
||||
put = ['import subprocess', 'subprocess']
|
||||
silent normal G\g
|
||||
Expect getline('.') == 'import subprocess'
|
||||
Expect line('.') == 2
|
||||
Expect col('.') == 8
|
||||
|
||||
silent normal G\d
|
||||
Expect CurrentBufferIsModule('subprocess') == 1
|
||||
Expect line('.') == 1
|
||||
Expect col('.') == 1
|
||||
Expect winnr('$') == 2
|
||||
wincmd l
|
||||
Expect bufname('%') == ''
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
|
||||
" vim: et:ts=4:sw=4
|
||||
32
sources_non_forked/jedi-vim/test/pyimport.vim
Normal file
32
sources_non_forked/jedi-vim/test/pyimport.vim
Normal file
|
|
@ -0,0 +1,32 @@
|
|||
source plugin/jedi.vim
|
||||
source test/utils.vim
|
||||
|
||||
describe 'pyimport'
|
||||
before
|
||||
let g:jedi#use_tabs_not_buffers = 1
|
||||
end
|
||||
|
||||
after
|
||||
bd!
|
||||
bd!
|
||||
end
|
||||
|
||||
it 'open_tab'
|
||||
Pyimport os
|
||||
Expect CurrentBufferIsModule('os') == 1
|
||||
Pyimport subprocess
|
||||
Expect CurrentBufferIsModule('subprocess') == 1
|
||||
" the empty tab is sometimes also a tab
|
||||
Expect tabpagenr('$') >= 2
|
||||
end
|
||||
|
||||
it 'completion'
|
||||
" don't know how to test this directly
|
||||
"execute "Pyimport subproc\<Tab>"
|
||||
"Expect CurrentBufferIsModule('subprocess') == 1
|
||||
|
||||
Expect jedi#py_import_completions('subproc', 0, 0) == 'subprocess'
|
||||
Expect jedi#py_import_completions('subprocess', 0, 0) == 'subprocess'
|
||||
Expect jedi#py_import_completions('zip', 0, 0) == "zipfile\nzipimport"
|
||||
end
|
||||
end
|
||||
66
sources_non_forked/jedi-vim/test/signatures.vim
Normal file
66
sources_non_forked/jedi-vim/test/signatures.vim
Normal file
|
|
@ -0,0 +1,66 @@
|
|||
source plugin/jedi.vim
|
||||
|
||||
describe 'signatures'
|
||||
before
|
||||
set filetype=python
|
||||
end
|
||||
|
||||
after
|
||||
bd!
|
||||
bd!
|
||||
end
|
||||
|
||||
it 'simple'
|
||||
normal oabs(
|
||||
" equals doautocmd CursorMovedI
|
||||
Python jedi_vim.show_call_signatures()
|
||||
|
||||
Expect getline(1) == '=`=jedi=0, =`= (*_*number*_*) =`=jedi=`='
|
||||
|
||||
doautocmd InsertLeave
|
||||
Expect getline(1) == ''
|
||||
end
|
||||
|
||||
it 'no signature'
|
||||
normal ostr
|
||||
Python jedi_vim.show_call_signatures()
|
||||
Expect getline(1, '$') == ['', 'str ']
|
||||
end
|
||||
|
||||
it 'signatures disabled'
|
||||
let g:jedi#show_call_signatures = 0
|
||||
|
||||
normal ostr(
|
||||
Python jedi_vim.show_call_signatures()
|
||||
Expect getline(1, '$') == ['', 'str( ']
|
||||
|
||||
let g:jedi#show_call_signatures = 1
|
||||
end
|
||||
|
||||
it 'command line simple'
|
||||
let g:jedi#show_call_signatures = 2
|
||||
call jedi#configure_call_signatures()
|
||||
|
||||
normal oabs(
|
||||
redir => msg
|
||||
Python jedi_vim.show_call_signatures()
|
||||
redir END
|
||||
Expect msg == "\nabs(number)"
|
||||
|
||||
redir => msg
|
||||
doautocmd InsertLeave
|
||||
redir END
|
||||
Expect msg == "\n\n"
|
||||
end
|
||||
|
||||
it 'command line no signature'
|
||||
let g:jedi#show_call_signatures = 2
|
||||
call jedi#configure_call_signatures()
|
||||
|
||||
normal ostr
|
||||
redir => msg
|
||||
Python jedi_vim.show_call_signatures()
|
||||
redir END
|
||||
Expect msg == "\n"
|
||||
end
|
||||
end
|
||||
11
sources_non_forked/jedi-vim/test/utils.vim
Normal file
11
sources_non_forked/jedi-vim/test/utils.vim
Normal file
|
|
@ -0,0 +1,11 @@
|
|||
function! CurrentBufferIsModule(module_name)
|
||||
return EndsWith(bufname('%'), a:module_name.'.py')
|
||||
endfunction
|
||||
|
||||
|
||||
function EndsWith(string, end)
|
||||
let l:should = len(a:string) - strlen(a:end)
|
||||
return l:should == stridx(a:string, a:end, should)
|
||||
endfunction
|
||||
|
||||
" vim: et:ts=4:sw=4
|
||||
2
sources_non_forked/jedi-vim/test_integration.py
Normal file
2
sources_non_forked/jedi-vim/test_integration.py
Normal file
|
|
@ -0,0 +1,2 @@
|
|||
def test_integration(case, monkeypatch, pytestconfig):
|
||||
case.run()
|
||||
Loading…
Reference in a new issue