[IMP] README.rst - Add a description for Vundle installation. (#781)

* [IMP] README.rst - Add a description for Vundle installation.

* [FIX] README.rst - Fix typo.

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,44 @@
+### Issue
+
+<!--
+Please describe the issue here.
+
+If you are not using jedi-vim from Git (but e.g. from a distribution's package,
+please try it with jedi-vim's Git master, too).
+-->
+
+### Steps to reproduce
+
+<!--
+Include if relevant.
+
+Please provide steps to reproduce it here, preferably based on a minimal Vim
+configuration.
+
+You can use the following template (save it as `minimal.vimrc` in the directory
+where jedi-vim is installed, `cd` into that directory, and run Vim with
+`vim -u minimal.vimrc`):
+
+```
+set nocompatible
+
+let script_dir = fnamemodify(expand('<sfile>'), ':h')
+let &runtimepath .= ','.script_dir.','.script_dir.'/after'
+
+" Put your config changes here.
+" let g:jedi#show_call_signatures=1
+
+syntax on
+filetype plugin indent on
+```
+
+Please provide the `minimal.vimrc` you have used here, too.
+-->
+
+### Output of “:verbose JediDebugInfo”
+
+<!--
+Please execute `:redir @+> | silent verb JediDebugInfo | redir END` in a
+Python buffer to copy debug information into your clipboard.
+Then paste it here.
+-->

.gitmodules

@@ -1,3 +1,6 @@
 [submodule "jedi"]
-	path = jedi
+	path = pythonx/jedi
 	url = https://github.com/davidhalter/jedi.git
+[submodule "pythonx/parso"]
+	path = pythonx/parso
+	url = https://github.com/davidhalter/parso.git

.travis.yml

@@ -1,6 +1,15 @@
+sudo: false
 language: python
+python: 3.6
+env:
+  matrix:
+    - ENV=test
+    - ENV=check
 install:
-    - pip install --quiet --use-mirrors pytest
+  - |
+    if [ "$ENV" = "test" ]; then
+      python3.6 -m pip install pytest
+    fi
 script:
   - vim --version
-    - py.test
+  - make "$ENV"

AUTHORS.txt

@@ -40,6 +40,16 @@ 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)
+Daniel Hahler (@blueyed)
+Dave Honneffer (@pearofducks)
+Bagrat Aznauryan (@n9code)
+Tomoyuki Kashiro (@kashiro)
+Tommy Allen (@tweekmonster)
+Mingliang (@Aulddays)
 
 @something are github user names.

CONTRIBUTING.md

@@ -1,12 +1,12 @@
-Pull Requests are great (on the **dev** branch)!
+# 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 to the dev branch**.
+ 4. Push to your fork and submit a pull request.
 
-My **master** branch is a 100% stable (should be). I only push to it after I am
-certain that things are working out. Many people are using Jedi directly from
-the github master branch. 
+Please use PEP8 as a Python code style. For VIM, just try to style your
+code similar to the jedi-vim code that is already there.
 
-Please use Pep8 to style your code.
+# Bug reports
+Please include the output of `:version` and `:JediDebugInfo`.

Makefile

@@ -0,0 +1,16 @@
+test:
+	py.test
+
+build:
+	mkdir $@
+build/vint: | build
+	virtualenv $@
+	$@/bin/pip install vim-vint
+check: LINT_FILES:=after autoload ftplugin plugin
+check: build/vint
+	build/vint/bin/vint $(LINT_FILES)
+
+clean:
+	rm -rf .cache build
+
+.PHONY: test check clean

README.rst

@@ -2,11 +2,11 @@
 jedi-vim - awesome Python autocompletion with VIM
 #################################################
 
-.. image:: https://travis-ci.org/davidhalter/jedi-vim.png?branch=master
+.. image:: https://travis-ci.org/davidhalter/jedi-vim.svg?branch=master
    :target: https://travis-ci.org/davidhalter/jedi-vim
    :alt: Travis-CI build status
 
-jedi-vim is a is a VIM binding to the autocompletion library
+jedi-vim is a VIM binding to the autocompletion library
 `Jedi <http://github.com/davidhalter/jedi>`_.
 
 Here are some pictures:
@@ -32,9 +32,13 @@ Documentation
 =============
 
 Documentation is available in your vim: ``:help jedi-vim``. You can also look
-it up `on github <http://github.com/davidhalter/jedi-vim>`_.
+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>`_.
+You can read the Jedi library documentation `here <http://jedi.readthedocs.io/en/latest/>`_.
+
+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/questions/tagged/jedi-vim>`_ and tag your question with ``jedi-vim``.
 
 
 Contributing
@@ -64,25 +68,66 @@ Apart from that, jedi-vim supports the following commands
 Installation
 ============
 
+Requirements
+------------
+You need a VIM version that was compiled with Python 2.6 or later
+(``+python`` or ``+python3``), which is typical for most distributions on
+Linux.  You can check this from within VIM using
+``:python3 import sys; print(sys.version)`` (use ``:python`` for Python 2).
+
+Manual 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.
+`Vundle <https://github.com/gmarik/vundle>`_ to install jedi-vim.
 
 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.
+either install it via ``pip install jedi`` or with
+``git submodule update --init`` in your jedi-vim repository.
 
-On Arch Linux, you can also install jedi-vim from AUR: `vim-jedi
-<https://aur.archlinux.org/packages/vim-jedi/>`__.
+Example installation command using Pathogen:
+
+.. code-block:: sh
+
+    git clone --recursive https://github.com/davidhalter/jedi-vim.git ~/.vim/bundle/jedi-vim
+
+Example installation using Vundle:
+
+Add the following line in your `~/.vimrc`
+    
+.. code-block:: vim
+
+    Plugin 'davidhalter/jedi-vim'
+
+
+Installation with your distribution
+-----------------------------------
+
+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.
+On Fedora Linux, it is available as
+`vim-jedi <https://apps.fedoraproject.org/packages/vim-jedi>`__.
+
+Please note that this version might be quite old compared to using jedi-vim
+from Git.
+
+Caveats
+-------
 
 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. For older 
-version of VIM, the parameter recommendation list maybe not appeared when you type
-open bracket after the function name.
+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
@@ -96,19 +141,18 @@ you disable the auto-initialization in your ``.vimrc``:
     let g:jedi#auto_initialization = 0
 
 There are also some VIM options (like ``completeopt`` and key defaults) which
-are automatically initialized, but you can change all of them:
+are automatically initialized, but you can skip this:
 
 .. code-block:: vim
 
     let g:jedi#auto_vim_configuration = 0
 
 
-If you are a person who likes to use VIM-buffers not tabs, you might want to
-put that in your ``.vimrc``:
+You can make jedi-vim use tabs when going to a definition etc:
 
 .. code-block:: vim
 
-    let g:jedi#use_tabs_not_buffers = 0
+    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``:
 
@@ -116,7 +160,7 @@ If you are a person who likes to use VIM-splits, you might want to put this in y
 
     let g:jedi#use_splits_not_buffers = "left"
 
-This options could be "left", "right", "top" or "bottom". It will decide the direction where the split open.
+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:
@@ -132,18 +176,30 @@ and usually saves one keypress.
 
     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 = "<leader>d"
+    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"
-    let g:jedi#show_call_signatures = "1"
 
 
 Finally, if you don't want completion, but all the other features, use:
@@ -173,16 +229,30 @@ Don't even think about changing the Jedi command to ``<Tab>``,
 use `supertab <https://github.com/ervandew/supertab>`_!
 
 
-The completion is waaay too slow!
----------------------------------
+The completion is 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.
+1. Completion of complex libraries (like Numpy) should only be slow the first
+   time you complete them. 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>`__.
+2. If it is still slow after the initial completion and you have installed the
+   python-mode Vim plugin, try disabling its rope mode:
 
+   .. code-block:: vim
+
+       let g:pymode_rope = 0
+
+   See issue `#163 <https://github.com/davidhalter/jedi-vim/issues/163>`__.
+
+3. You can also use `deoplete-jedi <https://github.com/zchee/deoplete-jedi>`__
+   for completions, which uses Jedi, but does completions asynchronously
+   (requires Neovim).
+   It makes sense to use both jedi-vim and deoplete-jedi, but you should disable
+   jedi-vim's completions then:
+
+   .. code-block:: vim
+   
+       let g:jedi#completions_enabled = 0
 
 Testing
 =======

after/ftplugin/python/jedi.vim

@@ -1,16 +1,3 @@
-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>
-            inoremap <expr> <Nul> jedi#complete_string(0)
-        endif
-        if g:jedi#completions_command != ""
-            execute "inoremap <expr> <buffer> ".g:jedi#completions_command." jedi#complete_string(0)"
-        endif
-    endif
+if jedi#init_python() && g:jedi#auto_initialization && g:jedi#completions_enabled
+    call jedi#setup_completion()
 endif

after/syntax/python.vim

@@ -1,15 +1,22 @@
-if g:jedi#show_call_signatures == 1 && has('conceal')
-    " conceal is normal for vim >= 7.3
+if !jedi#init_python()
+    finish
+endif
 
-    let e = g:jedi#call_signature_escape
-    let l1 = e.'jedi=[^'.e.']*'.e.'[^'.e.']*'.e.'jedi'.e
-    let l2 = e.'jedi=\?[^'.e.']*'.e
-    exe 'syn match jediIgnore "'.l2.'" contained conceal'
+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 jediFatSymbol "\*_\*" contained conceal
+    syn match jediFat "\*_\*.\{-}\*_\*" contained contains=jediFatSymbol
     syn match jediSpace "\v[ ]+( )@=" contained
-    exe 'syn match jediFunction "'.l1.'" keepend extend contains=jediIgnore,jediFat,jediSpace'
+    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
@@ -21,20 +28,5 @@ if g:jedi#show_call_signatures == 1 && has('conceal')
     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
-    end
- 
-    " override defaults (add jediFunction to contains)
-    syn match pythonComment "#.*$" contains=pythonTodo,@Spell,jediFunction
-    syn region pythonString
-        \ start=+[uU]\=\z(['"]\)+ end="\z1" skip="\\\\\|\\\z1"
-        \ contains=pythonEscape,@Spell,jediFunction
-    syn region pythonString
-        \ start=+[uU]\=\z('''\|"""\)+ end="\z1" keepend
-        \ contains=pythonEscape,pythonSpaceError,pythonDoctest,@Spell,jediFunction
-    syn region pythonRawString
-        \ start=+[uU]\=[rR]\z(['"]\)+ end="\z1" skip="\\\\\|\\\z1"
-        \ contains=@Spell,jediFunction
-    syn region pythonRawString
-        \ start=+[uU]\=[rR]\z('''\|"""\)+ end="\z1" keepend
-        \ contains=pythonSpaceError,pythonDoctest,@Spell,jediFunction
+    endif
 endif

autoload/health/jedi.vim

@@ -0,0 +1,4 @@
+function! health#jedi#check() abort
+  call health#report_start('jedi')
+  silent call jedi#debug_info()
+endfunction

autoload/jedi.vim

@@ -1,159 +1,277 @@
+scriptencoding utf-8
+
 " ------------------------------------------------------------------------
-" functions that call python code
+" Settings initialization
 " ------------------------------------------------------------------------
-function! jedi#goto_assignments()
-    Python jedi_vim.goto()
-endfunction
+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',
+\ }
 
-function! jedi#goto_definitions()
-    Python jedi_vim.goto(is_definition=True)
-endfunction
+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'",
+    \ 'completions_enabled': 1,
+    \ 'popup_on_dot': 'g:jedi#completions_enabled',
+    \ 'documentation_command': "'K'",
+    \ 'show_call_signatures': 1,
+    \ 'show_call_signatures_delay': 500,
+    \ 'call_signature_escape': "'?!?'",
+    \ 'auto_close_doc': 1,
+    \ 'max_doc_height': 30,
+    \ 'popup_select_first': 1,
+    \ 'quickfix_window_height': 10,
+    \ 'force_py_version': "'auto'",
+    \ 'smart_auto_mappings': 1,
+    \ 'use_tag_stack': 1
+\ }
 
-function! jedi#usages()
-    Python jedi_vim.goto(is_related_name=True)
-endfunction
+for [s:key, s:val] in items(s:deprecations)
+    if exists('g:jedi#'.s:key)
+        echom "'g:jedi#".s:key."' is deprecated. Please use 'g:jedi#".s:val."' instead. Sorry for the inconvenience."
+        exe 'let g:jedi#'.s:val.' = g:jedi#'.s:key
+    endif
+endfor
 
-function! jedi#rename(...)
-    Python jedi_vim.rename()
-endfunction
-
-function! jedi#completions(findstart, base)
-    Python jedi_vim.completions()
-endfunction
-
-function! jedi#enable_speed_debugging()
-    Python jedi_vim.jedi.set_debug_function(jedi_vim.print_to_stdout, speed=True, warnings=False, notices=False)
-endfunction
-
-function! jedi#enable_debugging()
-    Python jedi_vim.jedi.set_debug_function(jedi_vim.print_to_stdout)
-endfunction
-
-function! jedi#disable_debugging()
-    Python jedi_vim.jedi.set_debug_function(None)
-endfunction
-
-function! jedi#py_import(args)
-    Python jedi_vim.py_import()
-endfun
-
-function! jedi#py_import_completions(argl, cmdl, pos)
-    Python jedi_vim.py_import_completions()
-endfun
+for [s:key, s:val] in items(s:default_settings)
+    if !exists('g:jedi#'.s:key)
+        exe 'let g:jedi#'.s:key.' = '.s:val
+    endif
+endfor
 
 
 " ------------------------------------------------------------------------
-" show_documentation
+" Python initialization
 " ------------------------------------------------------------------------
-function! jedi#show_documentation()
-    Python jedi_vim.show_documentation()
+let s:script_path = fnameescape(expand('<sfile>:p:h:h'))
 
-    if bufnr("__doc__") > 0
-        " If the __doc__ buffer is open in the current window, jump to it
-        silent execute "sbuffer ".bufnr("__doc__")
+function! s:init_python() abort
+    if g:jedi#force_py_version !=# 'auto'
+        " Always use the user supplied version.
+        try
+            return jedi#setup_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 '.shellescape('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#setup_py_version(s:def_py)
+        endif
+
+        " Add a warning in case the auto-detected version is not available,
+        " usually because of a missing neovim module in a VIRTUAL_ENV.
+        if has('nvim')
+            echohl WarningMsg
+            echom 'jedi-vim: the detected Python version ('.s:def_py.')'
+                        \ 'is not functional.'
+                        \ 'Is the "neovim" module installed?'
+                        \ 'While jedi-vim will work, it might not use the'
+                        \ 'expected Python path.'
+            echohl None
+        endif
+    endif
+
+    if has('python')
+        call jedi#setup_py_version(2)
+    elseif has('python3')
+        call jedi#setup_py_version(3)
     else
-        split '__doc__'
+        throw 'jedi-vim requires Vim with support for Python 2 or 3.'
     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 > 30  " max lines for plugin
-        let l:doc_lines = 30
-    endif
-    execute "resize ".l:doc_lines
-
-    " quit comands
-    nnoremap <buffer> q ZQ
-    nnoremap <buffer> K 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()
-    set lazyredraw
-    cclose
-    execute 'belowright copen '.g:jedi#quickfix_window_height
-    set nolazyredraw
-    if g:jedi#use_tabs_not_buffers == 1
-        map <buffer> <CR> :call jedi#goto_window_on_enter()<CR>
-    endif
-    au WinLeave <buffer> q  " automatically leave, if an option is chosen
-    redraw!
+    return 1
 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
-        Python jedi_vim.new_buffer(vim.eval('bufname(l:data.bufnr)'))
-        call cursor(l:data.lnum, l:data.col)
+function! jedi#reinit_python() abort
+    unlet! s:_init_python
+    call jedi#init_python()
+endfunction
+
+
+let s:_init_python = -1
+function! jedi#init_python() abort
+    if s:_init_python == -1
+        try
+            let s:_init_python = s:init_python()
+        catch
+            let s:_init_python = 0
+            if !exists('g:jedi#squelch_py_warning')
+                echoerr 'Error: jedi-vim failed to initialize Python: '
+                            \ .v:exception.' (in '.v:throwpoint.')'
+            endif
+        endtry
+    endif
+    return s:_init_python
+endfunction
+
+
+let s:python_version = 'null'
+function! jedi#setup_py_version(py_version) abort
+    if a:py_version == 2
+        let cmd_exec = 'python'
+        let s:python_version = 2
+    elseif a:py_version == 3
+        let cmd_exec = 'python3'
+        let s:python_version = 3
     else
-        echohl WarningMsg | echo "Builtin module cannot be opened." | echohl None
+        throw 'jedi#setup_py_version: invalid py_version: '.a:py_version
     endif
-endfunction
 
+    execute 'command! -nargs=1 PythonJedi '.cmd_exec.' <args>'
 
-function! s:syn_stack()
-    if !exists("*synstack")
-        return []
+    let s:init_outcome = 0
+    let init_lines = [
+          \ 'import vim',
+          \ 'try:',
+          \ '    import jedi_vim',
+          \ 'except Exception as exc:',
+          \ '    vim.command(''let s:init_outcome = "could not import jedi_vim: {0}: {1}"''.format(exc.__class__.__name__, exc))',
+          \ 'else:',
+          \ '    vim.command(''let s:init_outcome = 1'')']
+    try
+        exe 'PythonJedi exec('''.escape(join(init_lines, '\n'), "'").''')'
+    catch
+        throw printf('jedi#setup_py_version: failed to run Python for initialization: %s.', v:exception)
+    endtry
+    if s:init_outcome is 0
+        throw 'jedi#setup_py_version: failed to run Python for initialization.'
+    elseif s:init_outcome isnot 1
+        throw printf('jedi#setup_py_version: %s.', s:init_outcome)
     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#popup_on_dot_string()
 endfunction
 
 
-function! jedi#configure_call_signatures()
-    autocmd InsertLeave <buffer> Python jedi_vim.clear_call_signatures()
-    autocmd CursorMovedI <buffer> Python jedi_vim.show_call_signatures()
+function! jedi#debug_info() abort
+    if s:python_version ==# 'null'
+        try
+            call s:init_python()
+        catch
+            echohl WarningMsg | echom v:exception | echohl None
+            return
+        endtry
+    endif
+    if &verbose
+      if &filetype !=# 'python'
+        echohl WarningMsg | echo 'You should run this in a buffer with filetype "python".' | echohl None
+      endif
+    endif
+    echo '#### Jedi-vim debug information'
+    echo 'Using Python version:' s:python_version
+    let pyeval = s:python_version == 3 ? 'py3eval' : 'pyeval'
+    let s:pythonjedi_called = 0
+    PythonJedi import vim; vim.command('let s:pythonjedi_called = 1')
+    if !s:pythonjedi_called
+      echohl WarningMsg
+      echom 'PythonJedi failed to run, likely a Python config issue.'
+      if exists(':CheckHealth') == 2
+        echom 'Try :CheckHealth for more information.'
+      endif
+      echohl None
+    else
+      PythonJedi from jedi_vim_debug import display_debug_info
+      PythonJedi display_debug_info()
+    endif
+    echo ' - jedi-vim git version: '
+    echon substitute(system('git -C '.s:script_path.' describe --tags --always --dirty'), '\v\n$', '', '')
+    echo ' - jedi git submodule status: '
+    echon substitute(system('git -C '.s:script_path.' submodule status'), '\v\n$', '', '')
+    echo "\n"
+    echo '##### Settings'
+    echo '```'
+    let jedi_settings = items(filter(copy(g:), "v:key =~# '\\v^jedi#'"))
+    let has_nondefault_settings = 0
+    for [k, V] in jedi_settings
+      exe 'let default = '.get(s:default_settings,
+            \ substitute(k, '\v^jedi#', '', ''), "'-'")
+      " vint: -ProhibitUsingUndeclaredVariable
+      if default !=# V
+        echo printf('g:%s = %s (default: %s)', k, string(V), string(default))
+        unlet! V  " Fix variable type mismatch with Vim 7.3.
+        let has_nondefault_settings = 1
+      endif
+      " vint: +ProhibitUsingUndeclaredVariable
+    endfor
+    if has_nondefault_settings
+      echo "\n"
+    endif
+    verb set omnifunc? completeopt?
+    echo '```'
+
+    if &verbose
+      echo "\n"
+      echo '#### :version'
+      echo '```'
+      version
+      echo '```'
+      echo "\n"
+      echo '#### :messages'
+      echo '```'
+      messages
+      echo '```'
+      echo "\n"
+      echo '<details><summary>:scriptnames</summary>'
+      echo "\n"
+      echo '```'
+      scriptnames
+      echo '```'
+      echo '</details>'
+    endif
 endfunction
 
+function! jedi#force_py_version(py_version) abort
+    let g:jedi#force_py_version = a:py_version
+    return jedi#setup_py_version(a:py_version)
+endfunction
+
+
+function! jedi#force_py_version_switch() abort
+    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)
+function! jedi#_vim_exceptions(str, is_eval) abort
     let l:result = {}
     try
         if a:is_eval
@@ -169,130 +287,352 @@ function! jedi#_vim_exceptions(str, is_eval)
     return l:result
 endfunction
 
+call jedi#init_python()  " Might throw an error.
 
-function! jedi#complete_string(is_popup_on_dot)
+" ------------------------------------------------------------------------
+" functions that call python code
+" ------------------------------------------------------------------------
+function! jedi#goto() abort
+    PythonJedi jedi_vim.goto(mode="goto")
+endfunction
 
-    if a:is_popup_on_dot && !(g:jedi#popup_on_dot && jedi#do_popup_on_dot_in_highlight())
-        return ''
+function! jedi#goto_assignments() abort
+    PythonJedi jedi_vim.goto(mode="assignment")
+endfunction
 
-    end
-    if pumvisible() && !a:is_popup_on_dot
-        return "\<C-n>"
+function! jedi#goto_definitions() abort
+    PythonJedi jedi_vim.goto(mode="definition")
+endfunction
+
+function! jedi#usages() abort
+    PythonJedi jedi_vim.goto(mode="related_name")
+endfunction
+
+function! jedi#rename(...) abort
+    PythonJedi jedi_vim.rename()
+endfunction
+
+function! jedi#rename_visual(...) abort
+    PythonJedi jedi_vim.rename_visual()
+endfunction
+
+function! jedi#completions(findstart, base) abort
+    PythonJedi jedi_vim.completions()
+endfunction
+
+function! jedi#enable_speed_debugging() abort
+    PythonJedi jedi_vim.jedi.set_debug_function(jedi_vim.print_to_stdout, speed=True, warnings=False, notices=False)
+endfunction
+
+function! jedi#enable_debugging() abort
+    PythonJedi jedi_vim.jedi.set_debug_function(jedi_vim.print_to_stdout)
+endfunction
+
+function! jedi#disable_debugging() abort
+    PythonJedi jedi_vim.jedi.set_debug_function(None)
+endfunction
+
+function! jedi#py_import(args) abort
+    PythonJedi jedi_vim.py_import()
+endfun
+
+function! jedi#py_import_completions(argl, cmdl, pos) abort
+    PythonJedi jedi_vim.py_import_completions()
+endfun
+
+function! jedi#clear_cache(bang) abort
+    PythonJedi jedi_vim.jedi.cache.clear_time_caches(True)
+    if a:bang
+        PythonJedi jedi_vim.jedi.parser.utils.ParserPickling.clear_cache()
+    endif
+endfunction
+
+
+" ------------------------------------------------------------------------
+" show_documentation
+" ------------------------------------------------------------------------
+function! jedi#show_documentation() abort
+    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
-        return "\<C-x>\<C-o>\<C-r>=jedi#complete_opened()\<CR>"
-    end
+            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
+    setlocal foldlevel=200 " do not fold in __doc__
+
+    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'
+endfunction
+
+" ------------------------------------------------------------------------
+" helper functions
+" ------------------------------------------------------------------------
+
+function! jedi#add_goto_window(len) abort
+    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
+    augroup jedi_goto_window
+      au!
+      au WinLeave <buffer> q  " automatically leave, if an option is chosen
+    augroup END
+    redraw!
 endfunction
 
 
-function! jedi#complete_opened()
-    if pumvisible() && g:jedi#popup_select_first && stridx(&completeopt, 'longest') > -1
-        " only go down if it is visible, user-enabled and the longest option is set
+function! jedi#goto_window_on_enter() abort
+    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() abort
+    if !exists('*synstack')
+        return []
+    endif
+    return map(synstack(line('.'), col('.') - 1), "synIDattr(v:val, 'name')")
+endfunc
+
+
+function! jedi#do_popup_on_dot_in_highlight() abort
+    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
+
+
+let s:show_call_signatures_last = [0, 0, '']
+function! jedi#show_call_signatures() abort
+    if s:_init_python == 0
+        return 1
+    endif
+    let [line, col] = [line('.'), col('.')]
+    let curline = getline(line)
+    let reload_signatures = 1
+
+    " Caching.  On the same line only.
+    if line == s:show_call_signatures_last[0]
+        " Check if the number of commas and parenthesis before or after the
+        " cursor has not changed since the last call, which means that the
+        " argument position was not changed and we can skip repainting.
+        let prevcol = s:show_call_signatures_last[1]
+        let prevline = s:show_call_signatures_last[2]
+        if substitute(curline[:col-2], '[^,()]', '', 'g')
+                    \ == substitute(prevline[:prevcol-2], '[^,()]', '', 'g')
+                    \ && substitute(curline[(col-2):], '[^,()]', '', 'g')
+                    \ == substitute(prevline[(prevcol-2):], '[^,()]', '', 'g')
+            let reload_signatures = 0
+        endif
+    endif
+    let s:show_call_signatures_last = [line, col, curline]
+
+    if reload_signatures
+        PythonJedi jedi_vim.show_call_signatures()
+    endif
+endfunction
+
+
+function! jedi#clear_call_signatures() abort
+    if s:_init_python == 0
+        return 1
+    endif
+
+    let s:show_call_signatures_last = [0, 0, '']
+    PythonJedi jedi_vim.clear_call_signatures()
+endfunction
+
+
+function! jedi#configure_call_signatures() abort
+    augroup jedi_call_signatures
+    autocmd! * <buffer>
+    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 InsertEnter <buffer> let s:show_call_signatures_last = [0, 0, '']
+    autocmd InsertLeave <buffer> call jedi#clear_call_signatures()
+    if g:jedi#show_call_signatures_delay > 0
+        autocmd InsertEnter <buffer> let b:_jedi_orig_updatetime = &updatetime
+                    \ | let &updatetime = g:jedi#show_call_signatures_delay
+        autocmd InsertLeave <buffer> if exists('b:_jedi_orig_updatetime')
+                    \ |   let &updatetime = b:_jedi_orig_updatetime
+                    \ |   unlet b:_jedi_orig_updatetime
+                    \ | endif
+        autocmd CursorHoldI <buffer> call jedi#show_call_signatures()
+    else
+        autocmd CursorMovedI <buffer> call jedi#show_call_signatures()
+    endif
+    augroup END
+endfunction
+
+
+" Determine where the current window is on the screen for displaying call
+" signatures in the correct column.
+function! s:save_first_col() abort
+    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(autocomplete) abort
+    if a:autocomplete
+        if !(g:jedi#popup_on_dot && jedi#do_popup_on_dot_in_highlight())
+            return ''
+        endif
+
+        let s:saved_completeopt = &completeopt
+        set completeopt-=longest
+        set completeopt+=menuone
+        set completeopt-=menu
+        if &completeopt !~# 'noinsert\|noselect'
+            " Patch 775 introduced noinsert and noselect, previously these
+            " options didn't exist. Setting them in earlier versions results in
+            " errors (E474).
+            if has('patch-7.4-775')
+                if g:jedi#popup_select_first
+                    set completeopt+=noinsert
+                else
+                    set completeopt+=noselect
+                endif
+            else
+                " To pass the tests we use this, it seems to get the closest to
+                " the other options. I'm really not sure if this properly
+                " works, but VIM 7.4-775 is already pretty old, so it might not
+                " be a problem anymore in a few years.
+                set completeopt+=longest
+            endif
+        endif
+    elseif pumvisible()
+        return "\<C-n>"
+    endif
+    return "\<C-x>\<C-o>\<C-r>=jedi#complete_opened(".a:autocomplete.")\<CR>"
+endfunction
+
+
+function! jedi#complete_opened(autocomplete) abort
+    if a:autocomplete
+        let &completeopt = s:saved_completeopt
+        unlet s:saved_completeopt
+    elseif pumvisible() && g:jedi#popup_select_first && stridx(&completeopt, 'longest') > -1
         return "\<Down>"
-    end
-    return ""
+    endif
+    return ''
 endfunction
 
 
-function! jedi#force_py_version(py_version)
-    let g:jedi#force_py_version = a:py_version
-    if g:jedi#force_py_version == 2
-        command! -nargs=1 Python python <args>
-        execute 'pyfile '.s:script_path.'/initialize.py'
-    elseif g:jedi#force_py_version == 3
-        command! -nargs=1 Python python3 <args>
-        execute 'py3file '.s:script_path.'/initialize.py'
+function! jedi#smart_auto_mappings() abort
+    " Auto put import statement after from module.name<space> and complete
+    if search('\m^\s*from\s\+[A-Za-z0-9._]\{1,50}\%#\s*$', 'bcn', line('.'))
+        " Enter character and start completion.
+        return "\<space>import \<C-r>=jedi#complete_string(1)\<CR>"
     endif
+    return "\<space>"
 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)
+function! jedi#setup_completion() abort
+    " 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 len(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
 endfunction
 
-
-" ------------------------------------------------------------------------
-" deprecations
-" ------------------------------------------------------------------------
-let s:deprecations = {
-    \ 'get_definition_command':     'goto_definitions_command',
-    \ 'goto_command':               'goto_assignments_command',
-    \ 'pydoc':                      'documentation_command',
-    \ 'related_names_command':      'usages_command',
-    \ 'autocompletion_command':     'completions_command',
-    \ 'show_function_definition':   'show_call_signatures',
-\ }
-
-" ------------------------------------------------------------------------
-" defaults for jedi-vim
-" ------------------------------------------------------------------------
-let s:settings = {
-    \ 'use_tabs_not_buffers': 1,
-    \ 'use_splits_not_buffers': 1,
-    \ 'auto_initialization': 1,
-    \ 'auto_vim_configuration': 1,
-    \ 'goto_assignments_command': "'<leader>g'",
-    \ 'completions_command': "'<C-Space>'",
-    \ 'goto_definitions_command': "'<leader>d'",
-    \ '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,
-    \ 'popup_select_first': 1,
-    \ 'quickfix_window_height': 10,
-    \ 'completions_enabled': 1,
-    \ 'force_py_version': 2
-\ }
-
-
-function! s:init()
-  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
-      end
-  endfor
-
-  for [key, val] in items(s:settings)
-      if !exists('g:jedi#'.key)
-          exe 'let g:jedi#'.key.' = '.val
-      endif
-  endfor
-endfunction
-
-
-call s:init()
-
-" ------------------------------------------------------------------------
-" Python initialization
-" ------------------------------------------------------------------------
-
-let s:script_path = fnameescape(expand('<sfile>:p:h:h'))
-
-if has('python') && has('python3')
-    call jedi#force_py_version(g:jedi#force_py_version)
-elseif has('python')
-    command! -nargs=1 Python python <args>
-    execute 'pyfile '.s:script_path.'/initialize.py'
-elseif has('python3')
-    command! -nargs=1 Python python3 <args>
-    execute 'py3file '.s:script_path.'/initialize.py'
-else
-    if !exists("g:jedi#squelch_py_warning")
-        echomsg "Error: jedi-vim requires vim compiled with +python"
-    endif
-    finish
-end
-
-
-"Python jedi_vim.jedi.set_debug_function(jedi_vim.print_to_stdout, speed=True, warnings=False, notices=False)
-"Python jedi_vim.jedi.set_debug_function(jedi_vim.print_to_stdout)
+"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:

conftest.py

@@ -1,10 +1,13 @@
 import os
-import urllib
-import zipfile
 import subprocess
+import urllib.request
+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-master')
+VSPEC_FOLDER = os.path.join(CACHE_FOLDER, 'vim-vspec-1.4.1')
 VSPEC_RUNNER = os.path.join(VSPEC_FOLDER, 'bin/vspec')
 TEST_DIR = 'test'
 
@@ -14,11 +17,26 @@ class IntegrationTestFile(object):
         self.path = path
 
     def run(self):
-        output = subprocess.check_output([VSPEC_RUNNER, '.', VSPEC_FOLDER, self.path])
+        output = subprocess.check_output(
+            [VSPEC_RUNNER, '.', VSPEC_FOLDER, self.path])
+        had_ok = False
         for line in output.splitlines():
-            if line.startswith('not ok') or line.startswith('Error'):
-                print(output)
-                assert False
+            if (line.startswith(b'not ok') or
+                    line.startswith(b'Error') or
+                    line.startswith(b'Bail out!')):
+                pytest.fail("{0} failed:\n{1}".format(
+                    self.path, output.decode('utf-8')), pytrace=False)
+            if not had_ok and line.startswith(b'ok'):
+                had_ok = True
+        if not had_ok:
+            pytest.fail("{0} failed: no 'ok' found:\n{1}".format(
+                self.path, output.decode('utf-8')), pytrace=False)
+
+    @property
+    def name(self):
+        name = os.path.basename(self.path)
+        name, _, _ = name.rpartition('.')
+        return name
 
     def __repr__(self):
         return "<%s: %s>" % (type(self), self.path)
@@ -29,8 +47,7 @@ def pytest_configure(config):
         os.mkdir(CACHE_FOLDER)
 
     if not os.path.exists(VSPEC_FOLDER):
-        url = 'https://github.com/kana/vim-vspec/archive/master.zip'
-        name, hdrs = urllib.urlretrieve(url)
+        name, hdrs = urllib.request.urlretrieve(VSPEC_URL)
         z = zipfile.ZipFile(name)
         for n in z.namelist():
             dest = os.path.join(CACHE_FOLDER, n)
@@ -39,10 +56,10 @@ def pytest_configure(config):
                 os.makedirs(destdir)
             data = z.read(n)
             if not os.path.isdir(dest):
-                with open(dest, 'w') as f:
+                with open(dest, 'wb') as f:
                     f.write(data)
         z.close()
-        os.chmod(VSPEC_RUNNER, 0777)
+        os.chmod(VSPEC_RUNNER, 0o777)
 
 
 def pytest_generate_tests(metafunc):
@@ -51,7 +68,8 @@ def pytest_generate_tests(metafunc):
     """
     def collect_tests():
         for f in os.listdir(TEST_DIR):
-            if f.endswith('.vim'):
+            if f.endswith('.vim') and f != 'utils.vim':
                 yield IntegrationTestFile(os.path.join(TEST_DIR, f))
 
-    metafunc.parametrize('case', list(collect_tests()))
+    tests = list(collect_tests())
+    metafunc.parametrize('case', tests, ids=[test.name for test in tests])

doc/jedi-vim.txt

@@ -1,4 +1,4 @@
-*jedi-vim.txt* - For Vim version 7.3 - Last change: 2013/3/1
+*jedi-vim.txt* - For Vim version 7.3 - Last change: 2014/07/29
        __   _______  _______   __       ____    ____  __  .___  ___.~
       |  | |   ____||       \ |  |      \   \  /   / |  | |   \/   |~
       |  | |  |__   |  .--.  ||  |  _____\   \/   /  |  | |  \  /  |~
@@ -17,16 +17,18 @@ Contents				*jedi-vim-contents*
     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 assignment		|g:jedi#goto_assignments_command|
-    5.3. Get original definition	|g:jedi#goto_definitions_command|
-    5.4. Show documentation		|g:jedi#documentation_command|
-    5.5. Rename variables		|g:jedi#rename_command|
-    5.6. Show name usages		|g:jedi#usages_command|
-    5.7. Open module by name 		|:Pyimport|
+    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|
@@ -34,11 +36,14 @@ Contents				*jedi-vim-contents*
     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_enable		|g:jedi#completions_enable|
-    6.10. use_splits_not_buffers	|g:jedi#use_splits_not_buffers|
-    6.11. force_py_version              |g:jedi#force_py_version|
+    6.7. show_call_signatures_delay     |g:jedi#show_call_signatures_delay|
+    6.8. use_tabs_not_buffers           |g:jedi#use_tabs_not_buffers|
+    6.9. squelch_py_warning             |g:jedi#squelch_py_warning|
+    6.10. completions_enabled           |g:jedi#completions_enabled|
+    6.11. use_splits_not_buffers        |g:jedi#use_splits_not_buffers|
+    6.12. force_py_version              |g:jedi#force_py_version|
+    6.13. smart_auto_mappings           |g:jedi#smart_auto_mappings|
+    6.14. use_tag_stack                 |g:jedi#use_tag_stack|
 7. Testing                              |jedi-vim-testing|
 8. Contributing                         |jedi-vim-contributing|
 9. License                              |jedi-vim-license|
@@ -46,7 +51,7 @@ Contents				*jedi-vim-contents*
 ==============================================================================
 1. Introduction                         *jedi-vim-introduction*
 
-Jedi-vim is a is a Vim binding to the awesome Python autocompletion library
+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|)
@@ -82,9 +87,22 @@ using pip: >
 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 the best if you have VIM >= 7.3. For the older version, you probably 
-cannot see the parameter recommendation list of function after typing open 
-bracket.
+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*
@@ -105,7 +123,7 @@ bracket.
     :helptags <path/to/vimruntime>/doc
 
 ------------------------------------------------------------------------------
-2.1. Installing using Pathogen		*jedi-vim-installation-pathogen*
+2.2. Installing using Pathogen          *jedi-vim-installation-pathogen*
 
 Pathogen simplifies installation considerably.
 
@@ -125,14 +143,21 @@ Pathogen simplifies installation considerably.
    will automatically get the jedi library with the jedi-vim plugin. Add the
    following to the Bundles section in your .vimrc file: >
 
-    Bundle 'git://github.com/davidhalter/jedi-vim'
+    Plugin 'davidhalter/jedi-vim'
 
 2. Issue the following command in Vim: >
 
-    :BundleInstall
+    :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*
 
@@ -212,17 +237,15 @@ Note: If you want to use <Tab> for completion, please install Supertab:
 https://github.com/ervandew/supertab.
 
 ------------------------------------------------------------------------------
-5.2. `g:jedi#goto_assignments_command`	*g:jedi#goto_assignments_command*
-Function: `jedi#goto_assignments()`
-Default: <leader>g			Go to definition
+5.2. `g:jedi#goto_command`              *g:jedi#goto_command*
+Function: `jedi#goto()`
+Default: <leader>d                      Go to definition (or 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.3. `g:jedi#goto_definitions_command`	*g:jedi#goto_definitions_command*
-Function: `jedi#goto_definitions()`
-Default: <leader>d			Go to original definition
+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
@@ -254,15 +277,32 @@ you all the way to the >
 line in file3.py.
 
 ------------------------------------------------------------------------------
-5.4. `g:jedi#documentation_command`	*g:jedi#documentation_command*
+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 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.5. `g:jedi#rename_command`		*g:jedi#rename_command*
+5.6. `g:jedi#rename_command`            *g:jedi#rename_command*
 Function: `jedi#rename()`
 Default: <leader>r                      Rename variables
 
@@ -273,7 +313,7 @@ with the new one. The number of performed renames is displayed in the command
 line.
 
 ------------------------------------------------------------------------------
-5.6. `g:jedi#usages_command`		*g:jedi#usages_command*
+5.7. `g:jedi#usages_command`            *g:jedi#usages_command*
 Function: `jedi#usages()`
 Default: <leader>n                      Show usages of a name.
 
@@ -281,7 +321,7 @@ The quickfix window is populated with a list of all names which point to the
 definition of the name under the cursor.
 
 ------------------------------------------------------------------------------
-5.7. Open module by name		*:Pyimport*
+5.8. Open module by name                *:Pyimport*
 Function: `jedi#py_import(args)`
 Default: :Pyimport                      e.g. `:Pyimport os` shows os.py in VIM.
 
@@ -301,7 +341,7 @@ plugin.
 Upon initialization, jedi-vim performs the following steps:
 
 1. Set the current buffers 'omnifunc' to its own completion function
-   `jedi#complete`
+   `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
@@ -315,9 +355,11 @@ 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. It also
-remaps <Ctrl-C> to <Esc> in insert mode. If you want to keep your own
-configuration, disable this setting.
+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)
@@ -331,6 +373,7 @@ 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.
+You need to also have `g:jedi#completions_enabled` enabled for this.
 
 Options: 0 or 1
 Default: 1 (Start completion on typing a period)
@@ -355,7 +398,7 @@ 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 1 to leave the preview window open even after leaving insert mode.
+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
@@ -366,11 +409,15 @@ Default: 1 (Automatically close preview window upon leaving insert mode)
 
 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.
+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 or 1
+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: >
@@ -378,17 +425,27 @@ 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*
+6.7. `g:jedi#show_call_signatures_delay`  *g:jedi#show_call_signatures_delay*
 
-By default, jedi-vim opens a new tab if you use the "go to", "show
-definition", or "related names" commands. When you set this option to 0, they
-open in the current buffer instead.
+The delay to be used with |g:jedi#show_call_signatures|.  If it is greater
+than 0 it will use Vim's |CursorHoldI| event instead of |CursorMovedI|.
+It will temporarily set Vim's |'updatetime'| option during insert mode.
 
-Options: 0 or 1
-Default: 1 (Command output is put in a new tab)
+Options: delay in milliseconds
+Default: 500
 
 ------------------------------------------------------------------------------
-6.8. `g:jedi#squelch_py_warning`	*g:jedi#squelch_py_warning*
+6.8. `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.9. `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.
@@ -397,7 +454,7 @@ Options: 0 or 1
 Default: 0 (Warning is shown)
 
 ------------------------------------------------------------------------------
-6.9. `g:jedi#completions_enable`	*g:jedi#completions_enable*
+6.10. `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
@@ -407,16 +464,21 @@ Options: 0 or 1
 Default: 1
 
 ------------------------------------------------------------------------------
-6.10. `g:jedi#use_splits_not_buffers`	*g:jedi#use_splits_not_buffers*
+6.11. `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 or bottom
+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*
+6.12. `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
@@ -432,7 +494,30 @@ 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: 2
+Default: "auto" (will use sys.version_info from "python" in your $PATH)
+------------------------------------------------------------------------------
+6.13. `g:jedi#smart_auto_mappings`                  *g:jedi#smart_auto_mappings*
+
+When you start typing `from module.name<space>` jedi-vim automatically
+adds the "import" statement and displays the autocomplete popup.
+
+This option can be disabled in the .vimrc:
+
+`let g:jedi#smart_auto_mappings = 0`
+
+Options: 0 or 1
+Default: 1 (enabled by default)
+
+------------------------------------------------------------------------------
+6.14. `g:jedi#use_tag_stack`                    *g:jedi#use_tag_stack*
+
+Write results of |jedi#goto| to a temporary file and use the |:tjump| command
+to enable full |tagstack| functionality. Use of the tag stack allows
+returning to the usage of a function with CTRL-T after exploring the
+definition with arbitrary changes to the |jumplist|.
+
+Options: 0 or 1
+Default: 1 (enabled by default)
 
 ==============================================================================
 7. Testing                              *jedi-vim-testing*
@@ -457,4 +542,4 @@ We love Pull Requests! Read the instructions in `CONTRIBUTING.md`.
 
 Jedi-vim is licensed with the MIT license.
 
- vim: textwidth=78 tabstop=8 filetype=help:norightleft:
+ vim: textwidth=78 et filetype=help:norightleft:

ftplugin/python/jedi.vim

@@ -1,4 +1,4 @@
-if !has('python') && !has('python3')
+if !jedi#init_python()
     finish
 endif
 " ------------------------------------------------------------------------
@@ -7,25 +7,29 @@ endif
 
 if g:jedi#auto_initialization
     " goto / get_definition / usages
-    if g:jedi#goto_assignments_command != ''
-        execute "nnoremap <buffer> ".g:jedi#goto_assignments_command." :call jedi#goto_assignments()<CR>"
+    if len(g:jedi#goto_command)
+        execute 'nnoremap <buffer> '.g:jedi#goto_command.' :call jedi#goto()<CR>'
     endif
-    if g:jedi#goto_definitions_command != ''
-        execute "nnoremap <buffer> ".g:jedi#goto_definitions_command." :call jedi#goto_definitions()<CR>"
+    if len(g:jedi#goto_assignments_command)
+        execute 'nnoremap <buffer> '.g:jedi#goto_assignments_command.' :call jedi#goto_assignments()<CR>'
     endif
-    if g:jedi#usages_command != ''
-        execute "nnoremap <buffer> ".g:jedi#usages_command." :call jedi#usages()<CR>"
+    if len(g:jedi#goto_definitions_command)
+        execute 'nnoremap <buffer> '.g:jedi#goto_definitions_command.' :call jedi#goto_definitions()<CR>'
+    endif
+    if len(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>"
+    if len(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>"
+    if len(g:jedi#documentation_command)
+        execute 'nnoremap <silent> <buffer>'.g:jedi#documentation_command.' :call jedi#show_documentation()<CR>'
     endif
 
-    if g:jedi#show_call_signatures == 1 && has('conceal')
+    if g:jedi#show_call_signatures > 0 && has('conceal')
         call jedi#configure_call_signatures()
     endif
 
@@ -33,15 +37,14 @@ if g:jedi#auto_initialization
         inoremap <silent> <buffer> . .<C-R>=jedi#complete_string(1)<CR>
     endif
 
+    if g:jedi#smart_auto_mappings == 1
+        inoremap <silent> <buffer> <space> <C-R>=jedi#smart_auto_mappings()<CR>
+    end
+
     if g:jedi#auto_close_doc
         " close preview if its still open after insert
-        autocmd InsertLeave <buffer> if pumvisible() == 0|pclose|endif
-    end
-end
-
-if g:jedi#auto_vim_configuration
-    setlocal completeopt=menuone,longest,preview
-    if len(mapcheck('<C-c>', 'i')) == 0
-        inoremap <C-c> <ESC>
-    end
-end
+        augroup jedi_preview
+            autocmd! InsertLeave <buffer> if pumvisible() == 0|pclose|endif
+        augroup END
+    endif
+endif

initialize.py

@@ -1,26 +0,0 @@
-''' ------------------------------------------------------------------------
-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('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('s:script_path'))
-try:
-    import jedi_vim
-except ImportError:
-    vim.command('echoerr "Please install Jedi if you want to use jedi_vim."')
-sys.path.pop(1)
-

jedi_vim.py

@@ -1,473 +0,0 @@
-"""
-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
-from shlex import split as shsplit
-
-import vim
-import jedi
-import jedi.keywords
-from jedi._compatibility import unicode, is_py3k
-
-
-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
-
-
-class VimError(Exception):
-    def __init__(self, message, throwpoint, executing):
-        super(type(self), self).__init__(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_eval(string):
-    return _catch_exception(string, 1)
-
-
-def vim_command(string):
-    _catch_exception(string, 0)
-
-
-def echo_highlight(msg):
-    vim_command('echohl WarningMsg | echom "%s" | echohl None' % msg)
-
-
-class PythonToVimStr(unicode):
-    """ Vim has a different string implementation of single quotes """
-    __slots__ = []
-    def __new__(cls, obj, encoding='UTF-8'):
-        if is_py3k 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'\"')
-
-
-@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)
-
-
-@catch_and_print_exceptions
-def completions():
-    row, column = vim.current.window.cursor
-    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.doc),  # 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)
-
-
-@catch_and_print_exceptions
-def goto(is_definition=False, is_related_name=False, no_output=False):
-    definitions = []
-    script = get_script()
-    try:
-        if is_related_name:
-            definitions = script.usages()
-        elif is_definition:
-            definitions = script.goto_definitions()
-        else:
-            definitions = script.goto_assignments()
-    except jedi.NotFoundError:
-        echo_highlight( "Cannot follow nothing. Put your cursor on a valid name.")
-    else:
-        if no_output:
-            return definitions
-        if not definitions:
-            echo_highlight("Couldn't find any definitions for this.")
-        elif len(definitions) == 1 and not is_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.module_path)
-            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
-                vim_command('normal! zt')  # cursor at top of screen
-        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()')
-    return definitions
-
-
-@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.doc) if d.doc
-                    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')))
-
-
-@catch_and_print_exceptions
-def clear_call_signatures():
-    cursor = vim.current.window.cursor
-    e = vim_eval('g:jedi#call_signature_escape')
-    regex = r'%sjedi=([0-9]+), ([^%s]*)%s.*%sjedi%s'.replace('%s', e)
-    for i, line in enumerate(vim.current.buffer):
-        match = re.search(r'%s' % regex, line)
-        if match is not None:
-            vim_regex = r'\v' + regex.replace('=', r'\=') + '.{%s}' % \
-                                                        int(match.group(1))
-            vim_command(r'try | %s,%ss/%s/\2/g | catch | endtry' \
-                                                % (i + 1, i + 1, vim_regex))
-            vim_eval('histdel("search", -1)')
-            vim_command('let @/ = histget("search", -1)')
-    vim.current.window.cursor = cursor
-
-
-@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
-
-    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.get_code().replace('\n', '') for p in signature.params]
-        try:
-            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 rename():
-    if not int(vim.eval('a:0')):
-        _rename_cursor = vim.current.window.cursor
-
-        vim_command('normal A ')  # otherwise startinsert doesn't work well
-        vim.current.window.cursor = _rename_cursor
-
-        vim_command('augroup jedi_rename')
-        vim_command('autocmd InsertLeave <buffer> call jedi#rename(1)')
-        vim_command('augroup END')
-
-        vim_command('normal! diw')
-        vim_command(':startinsert')
-    else:
-        window_path = vim.current.buffer.name
-        # reset autocommand
-        vim_command('autocmd! jedi_rename InsertLeave')
-
-        replace = vim_eval("expand('<cword>')")
-        vim_command('normal! u')  # undo new word
-        cursor = vim.current.window.cursor
-        vim_command('normal! u')  # undo the space at the end
-        vim.current.window.cursor = cursor
-
-        if replace is None:
-            echo_highlight('No rename possible, if no name is given.')
-        else:
-            temp_rename = goto(is_related_name=True, 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))
-            for r in temp_rename:
-                if r.in_builtin_module():
-                    continue
-
-                if vim.current.buffer.name != r.module_path:
-                    result = new_buffer(r.module_path)
-                    if not result:
-                        return
-
-                vim.current.window.cursor = r.start_pos
-                vim_command('normal! cw%s' % replace)
-
-            result = new_buffer(window_path)
-            if not result:
-                return
-            vim.current.window.cursor = cursor
-            echo_highlight('Jedi did %s renames!' % len(temp_rename))
-
-
-@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'
-        }
-        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))
-                    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)
-
-if not hasattr(jedi, '__version__') or jedi.__version__ < (0, 7, 0):
-    echo_highlight('Please update your Jedi version, it is to old.')
-

plugin/jedi.vim

@@ -4,16 +4,51 @@
 " This part of the software is just the vim interface. The really big deal is
 " the Jedi Python library.
 
-
-" jedi-vim doesn't work in compatible mode (vim script syntax problems)
-if &compatible
+if get(g:, 'jedi#auto_vim_configuration', 1)
+    " jedi-vim doesn't work in compatible mode (vim script syntax problems)
+    if &compatible
+        " vint: -ProhibitSetNoCompatible
         set nocompatible
-endif
+        " vint: +ProhibitSetNoCompatible
+    endif
 
-" jedi-vim really needs, otherwise jedi-vim cannot start.
-filetype plugin on
+    " jedi-vim really needs, otherwise jedi-vim cannot start.
+    filetype plugin on
+
+    " Change completeopt, but only if it was not set already.
+    " This gets done on VimEnter, since otherwise Vim fails to restore the
+    " screen.  Neovim is not affected, this is likely caused by using
+    " :redir/execute() before the (alternate) terminal is configured.
+    function! s:setup_completeopt()
+        if exists('*execute')
+            let completeopt = execute('silent verb set completeopt?')
+        else
+            redir => completeopt
+                silent verb set completeopt?
+            redir END
+        endif
+        if len(split(completeopt, '\n')) == 1
+            set completeopt=menuone,longest,preview
+        endif
+    endfunction
+    if has('nvim')
+        call s:setup_completeopt()
+    else
+        augroup jedi_startup
+            au!
+            autocmd VimEnter * call s:setup_completeopt()
+        augroup END
+    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>)
 
+command! -nargs=0 -bar JediDebugInfo call jedi#debug_info()
+command! -nargs=0 -bang JediClearCache call jedi#clear_cache(<bang>0)
+
 " vim: set et ts=4:

pythonx/jedi_vim.py

@@ -0,0 +1,734 @@
+# -*- coding: utf-8 -*-
+"""
+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
+from contextlib import contextmanager
+try:
+    from itertools import zip_longest
+except ImportError:
+    from itertools import izip_longest as zip_longest  # Python 2
+
+import vim
+
+is_py3 = sys.version_info[0] >= 3
+if is_py3:
+    ELLIPSIS = "…"
+    unicode = str
+else:
+    ELLIPSIS = u"…"
+
+
+class PythonToVimStr(unicode):
+    """ Vim has a different string implementation of single quotes """
+    __slots__ = []
+
+    def __new__(cls, obj, encoding='UTF-8'):
+        if not (is_py3 or isinstance(obj, unicode)):
+            obj = unicode.__new__(cls, obj, encoding)
+
+        # Vim cannot deal with zero bytes:
+        obj = obj.replace('\0', '\\0')
+        return unicode.__new__(cls, obj)
+
+    def __repr__(self):
+        # this is totally stupid and makes no sense but vim/python unicode
+        # support is pretty bad. don't ask how I came up with this... It just
+        # works...
+        # It seems to be related to that bug: http://bugs.python.org/issue5876
+        if unicode is str:
+            s = self
+        else:
+            s = self.encode('UTF-8')
+        return '"%s"' % s.replace('\\', '\\\\').replace('"', r'\"')
+
+
+class VimError(Exception):
+    def __init__(self, message, throwpoint, executing):
+        super(type(self), self).__init__(message)
+        self.message = message
+        self.throwpoint = throwpoint
+        self.executing = executing
+
+    def __str__(self):
+        return 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`.
+    """
+    result = vim.eval('jedi#_vim_exceptions({0}, {1})'.format(
+        repr(PythonToVimStr(string, 'UTF-8')), int(is_eval)))
+    if 'exception' in result:
+        raise VimError(result['exception'], result['throwpoint'], string)
+    return result['result']
+
+
+def vim_command(string):
+    _catch_exception(string, False)
+
+
+def vim_eval(string):
+    return _catch_exception(string, True)
+
+
+def no_jedi_warning(error=None):
+    vim.command('echohl WarningMsg')
+    vim.command('echom "Please install Jedi if you want to use jedi-vim."')
+    if error:
+        vim.command('echom "The error was: {0}"'.format(error))
+    vim.command('echohl None')
+
+
+def echo_highlight(msg):
+    vim_command('echohl WarningMsg | echom "jedi-vim: {0}" | echohl None'.format(
+        str(msg).replace('"', '\\"')))
+
+
+jedi_path = os.path.join(os.path.dirname(__file__), 'jedi')
+sys.path.insert(0, jedi_path)
+parso_path = os.path.join(os.path.dirname(__file__), 'parso')
+sys.path.insert(0, parso_path)
+
+try:
+    import jedi
+except ImportError as e:
+    no_jedi_warning(str(e))
+    jedi = None
+    jedi_import_error = str(e)
+else:
+    try:
+        version = jedi.__version__
+    except Exception as e:  # e.g. AttributeError
+        echo_highlight(
+            "Error when loading the jedi python module ({0}). "
+            "Please ensure that Jedi is installed correctly (see Installation "
+            "in the README.".format(e))
+        jedi = None
+    else:
+        if isinstance(version, str):
+            # the normal use case, now.
+            from jedi import utils
+            version = utils.version_info()
+        if version < (0, 7):
+            echo_highlight('Please update your Jedi version, it is too old.')
+finally:
+    sys.path.remove(jedi_path)
+    sys.path.remove(parso_path)
+
+
+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 int(vim_eval("g:jedi#show_call_signatures")) == 1:
+        clear_call_signatures()
+    if vim.eval('a:findstart') == '1':
+        count = 0
+        for char in reversed(vim.current.line[:column]):
+            if not re.match('[\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_with_symbols),
+                         # 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)
+
+
+@contextmanager
+def tempfile(content):
+    # Using this instead of the tempfile module because Windows won't read
+    # from a file not yet written to disk
+    with open(vim_eval('tempname()'), 'w') as f:
+        f.write(content)
+    try:
+        yield f
+    finally:
+        os.unlink(f.name)
+
+@_check_jedi_availability(show_error=True)
+@catch_and_print_exceptions
+def goto(mode="goto", no_output=False):
+    """
+    :param str mode: "related_name", "definition", "assignment", "auto"
+    :return: list of definitions/assignments
+    :rtype: list
+    """
+    script = get_script()
+    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()
+
+
+    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":
+        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:
+            using_tagstack = int(vim_eval('g:jedi#use_tag_stack')) == 1
+            if (d.module_path or '') != vim.current.buffer.name:
+                result = new_buffer(d.module_path,
+                                    using_tagstack=using_tagstack)
+                if not result:
+                    return []
+            if d.module_path and os.path.exists(d.module_path) and using_tagstack:
+                tagname = d.name
+                with tempfile('{0}\t{1}\t{2}'.format(tagname, d.module_path,
+                        'call cursor({0}, {1})'.format(d.line, d.column + 1))) as f:
+                    old_tags = vim.eval('&tags')
+                    old_wildignore = vim.eval('&wildignore')
+                    try:
+                        # Clear wildignore to ensure tag file isn't ignored
+                        vim.command('set wildignore=')
+                        vim.command('let &tags = %s' %
+                                    repr(PythonToVimStr(f.name)))
+                        vim.command('tjump %s' % tagname)
+                    finally:
+                        vim.command('let &tags = %s' %
+                                    repr(PythonToVimStr(old_tags)))
+                        vim.command('let &wildignore = %s' %
+                                    repr(PythonToVimStr(old_wildignore)))
+            vim.current.window.cursor = 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)))
+            elif d.module_path is None:
+                # Typically a namespace, in the future maybe other things as
+                # well.
+                lst.append(dict(text=PythonToVimStr(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 int(vim_eval("g:jedi#show_call_signatures")) == 2:
+        vim_command('echo ""')
+        return
+    cursor = vim.current.window.cursor
+    e = vim_eval('g:jedi#call_signature_escape')
+    # We need two turns here to search and replace certain lines:
+    # 1. Search for a line with a call signature and save the appended
+    #    characters
+    # 2. Actually replace the line and redo the status quo.
+    py_regex = r'%sjedi=([0-9]+), (.*?)%s.*?%sjedi%s'.replace(
+        '%s', re.escape(e))
+    for i, line in enumerate(vim.current.buffer):
+        match = re.search(py_regex, line)
+        if match is not None:
+            # Some signs were added to minimize syntax changes due to call
+            # signatures. We have to remove them again. The number of them is
+            # specified in `match.group(1)`.
+            after = line[match.end() + int(match.group(1)):]
+            line = line[:match.start()] + match.group(2) + after
+            vim.current.buffer[i] = line
+    vim.current.window.cursor = cursor
+
+
+@_check_jedi_availability(show_error=False)
+@catch_and_print_exceptions
+def show_call_signatures(signatures=()):
+    if int(vim_eval("has('conceal') && g:jedi#show_call_signatures")) == 0:
+        return
+
+    if signatures == ():
+        signatures = get_script().call_signatures()
+    clear_call_signatures()
+
+    if not signatures:
+        return
+
+    if int(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)
+
+        # Descriptions are usually looking like `param name`, remove the param.
+        params = [p.description.replace('\n', '').replace('param ', '', 1) for p in signature.params]
+        try:
+            # *_*PLACEHOLDER*_* makes something fat. See after/syntax file.
+            params[signature.index] = '*_*%s*_*' % params[signature.index]
+        except (IndexError, TypeError):
+            pass
+
+        # This stuff is reaaaaally a hack! I cannot stress enough, that
+        # this is a stupid solution. But there is really no other yet.
+        # There is no possibility in VIM to draw on the screen, but there
+        # will be one (see :help todo Patch to access screen under Python.
+        # (Marko Mahni, 2010 Jul 18))
+        text = " (%s) " % ', '.join(params)
+        text = ' ' * (insert_column - len(line)) + text
+        end_column = insert_column + len(text) - 2  # -2 due to bold symbols
+
+        # Need to decode it with utf8, because vim returns always a python 2
+        # string even if it is unicode.
+        e = vim_eval('g:jedi#call_signature_escape')
+        if hasattr(e, 'decode'):
+            e = e.decode('UTF-8')
+        # replace line before with cursor
+        regex = "xjedi=%sx%sxjedix".replace('x', e)
+
+        prefix, replace = line[:insert_column], line[insert_column:end_column]
+
+        # Check the replace stuff for strings, to append them
+        # (don't want to break the syntax)
+        regex_quotes = r'''\\*["']+'''
+        # `add` are all the quotation marks.
+        # join them with a space to avoid producing '''
+        add = ' '.join(re.findall(regex_quotes, replace))
+        # search backwards
+        if add and replace[0] in ['"', "'"]:
+            a = re.search(regex_quotes + '$', prefix)
+            add = ('' if a is None else a.group(0)) + add
+
+        tup = '%s, %s' % (len(add), replace)
+        repl = prefix + (regex % (tup, text)) + add + line[end_column:]
+
+        vim_eval('setline(%s, %s)' % (line_to_replace, repr(PythonToVimStr(repl))))
+
+
+@catch_and_print_exceptions
+def cmdline_call_signatures(signatures):
+    def get_params(s):
+        return [p.description.replace('\n', '').replace('param ', '', 1) for p in s.params]
+
+    def escape(string):
+        return string.replace('"', '\\"').replace(r'\n', r'\\n')
+
+    def join():
+        return ', '.join(filter(None, (left, center, right)))
+
+    def too_long():
+        return len(join()) > max_msg_len
+
+    if len(signatures) > 1:
+        params = zip_longest(*map(get_params, signatures), fillvalue='_')
+        params = ['(' + ', '.join(p) + ')' for p in params]
+    else:
+        params = get_params(signatures[0])
+
+    index = next(iter(s.index for s in signatures if s.index is not None), None)
+
+    # Allow 12 characters for showcmd plus 18 for ruler - setting
+    # noruler/noshowcmd here causes incorrect undo history
+    max_msg_len = int(vim_eval('&columns')) - 12
+    if int(vim_eval('&ruler')):
+        max_msg_len -= 18
+    max_msg_len -= len(signatures[0].name) + 2  # call name + parentheses
+
+    if max_msg_len < (1 if params else 0):
+        return
+    elif index is None:
+        text = escape(', '.join(params))
+        if params and len(text) > max_msg_len:
+            text = ELLIPSIS
+    elif max_msg_len < len(ELLIPSIS):
+        return
+    else:
+        left = escape(', '.join(params[:index]))
+        center = escape(params[index])
+        right = escape(', '.join(params[index + 1:]))
+        while too_long():
+            if left and left != ELLIPSIS:
+                left = ELLIPSIS
+                continue
+            if right and right != ELLIPSIS:
+                right = ELLIPSIS
+                continue
+            if (left or right) and center != ELLIPSIS:
+                left = right = None
+                center = ELLIPSIS
+                continue
+            if too_long():
+                # Should never reach here
+                return
+
+    max_num_spaces = max_msg_len
+    if index is not None:
+        max_num_spaces -= len(join())
+    _, column = signatures[0].bracket_start
+    spaces = min(int(vim_eval('g:jedi#first_col +'
+                              'wincol() - col(".")')) +
+                 column - len(signatures[0].name),
+                 max_num_spaces) * ' '
+
+    if index is not None:
+        vim_command('                      echon "%s" | '
+                    'echohl Function     | echon "%s" | '
+                    'echohl None         | echon "("  | '
+                    'echohl jediFunction | echon "%s" | '
+                    'echohl jediFat      | echon "%s" | '
+                    'echohl jediFunction | echon "%s" | '
+                    'echohl None         | echon ")"'
+                    % (spaces, signatures[0].name,
+                       left + ', ' if left else '',
+                       center, ', ' + right if right else ''))
+    else:
+        vim_command('                      echon "%s" | '
+                    'echohl Function     | echon "%s" | '
+                    'echohl None         | echon "(%s)"'
+                    % (spaces, signatures[0].name, text))
+
+
+@_check_jedi_availability(show_error=True)
+@catch_and_print_exceptions
+def rename():
+    if not int(vim.eval('a:0')):
+        # Need to save the cursor position before insert mode
+        cursor = vim.current.window.cursor
+        changenr = vim.eval('changenr()')  # track undo tree
+        vim_command('augroup jedi_rename')
+        vim_command('autocmd InsertLeave <buffer> call jedi#rename'
+                    '({}, {}, {})'.format(cursor[0], cursor[1], changenr))
+        vim_command('augroup END')
+
+        vim_command("let s:jedi_replace_orig = expand('<cword>')")
+        vim_command('normal! diw')
+        vim_command('startinsert')
+
+    else:
+        # Remove autocommand.
+        vim_command('autocmd! jedi_rename InsertLeave')
+
+        args = vim.eval('a:000')
+        cursor = tuple(int(x) for x in args[:2])
+        changenr = args[2]
+
+        # Get replacement, if there is something on the cursor.
+        # This won't be the case when the user ends insert mode right away,
+        # and `<cword>` would pick up the nearest word instead.
+        if vim_eval('getline(".")[getpos(".")[2]-1]') != ' ':
+            replace = vim_eval("expand('<cword>')")
+        else:
+            replace = None
+
+        vim_command('undo {}'.format(changenr))
+
+        vim.current.window.cursor = cursor
+
+        if replace:
+            return do_rename(replace)
+
+
+def rename_visual():
+    replace = vim.eval('input("Rename to: ")')
+    orig = vim.eval('getline(".")[(getpos("\'<")[2]-1):getpos("\'>")[2]]')
+    do_rename(replace, orig)
+
+
+def do_rename(replace, orig=None):
+    if not len(replace):
+        echo_highlight('No rename possible without name.')
+        return
+
+    if orig is None:
+        orig = vim_eval('s:jedi_replace_orig')
+
+    # Save original window / tab.
+    saved_tab = int(vim_eval('tabpagenr()'))
+    saved_win = int(vim_eval('winnr()'))
+
+    temp_rename = 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.line, x.column))
+    buffers = set()
+    for r in temp_rename:
+        if r.in_builtin_module():
+            continue
+
+        if os.path.abspath(vim.current.buffer.name) != r.module_path:
+            assert r.module_path is not None
+            result = new_buffer(r.module_path)
+            if not result:
+                echo_highlight("Jedi-vim: failed to create buffer window for {0}!".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.line, r.column)
+        vim_command('normal! c{0:d}l{1}'.format(len(orig), replace))
+
+        # Restore view.
+        vim_command('call winrestview(%s)' % saved_view)
+
+    # Restore previous tab and window.
+    vim_command('tabnext {0:d}'.format(saved_tab))
+    vim_command('{0:d}wincmd w'.format(saved_win))
+
+    if len(buffers) > 1:
+        echo_highlight('Jedi did {0:d} renames in {1:d} buffers!'.format(
+            len(temp_rename), len(buffers)))
+    else:
+        echo_highlight('Jedi did {0:d} renames!'.format(len(temp_rename)))
+
+
+@_check_jedi_availability(show_error=True)
+@catch_and_print_exceptions
+def py_import():
+    # args 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='', using_tagstack=False):
+    # options are what you can to edit the edit options
+    if int(vim_eval('g:jedi#use_tabs_not_buffers')) == 1:
+        _tabnew(path, options)
+    elif not vim_eval('g:jedi#use_splits_not_buffers') in [1, '1']:
+        user_split_option = vim_eval('g:jedi#use_splits_not_buffers')
+        split_options = {
+            'top': 'topleft split',
+            'left': 'topleft vsplit',
+            'right': 'botright vsplit',
+            'bottom': 'botright split',
+            'winwidth': 'vs'
+        }
+        if (user_split_option == 'winwidth' and
+                vim.current.window.width <= 2 * int(vim_eval(
+                    "&textwidth ? &textwidth : 80"))):
+            split_options['winwidth'] = 'sp'
+        if user_split_option not in split_options:
+            print('Unsupported value for g:jedi#use_splits_not_buffers: {0}. '
+                  'Valid options are: {1}.'.format(
+                      user_split_option, ', '.join(split_options.keys())))
+        else:
+            vim_command(split_options[user_split_option] + " %s" % escape_file_path(path))
+    else:
+        if int(vim_eval("!&hidden && &modified")) == 1:
+            if not vim_eval("bufname('%')"):
+                echo_highlight('Cannot open a new buffer, use `:set hidden` or save your buffer')
+                return False
+            else:
+                vim_command('w')
+        if using_tagstack:
+            return True
+        vim_command('edit %s %s' % (options, escape_file_path(path)))
+    # sometimes syntax is being disabled and the filetype not set.
+    if int(vim_eval('!exists("g:syntax_on")')) == 1:
+        vim_command('syntax enable')
+    if int(vim_eval("&filetype != 'python'")) == 1:
+        vim_command('set filetype=python')
+    return True
+
+
+@catch_and_print_exceptions
+def _tabnew(path, options=''):
+    """
+    Open a file in a new tab or switch to an existing one.
+
+    :param options: `:tabnew` options, read vim help.
+    """
+    path = os.path.abspath(path)
+    if int(vim_eval('has("gui")')) == 1:
+        vim_command('tab drop %s %s' % (options, escape_file_path(path)))
+        return
+
+    for tab_nr in range(int(vim_eval("tabpagenr('$')"))):
+        for buf_nr in vim_eval("tabpagebuflist(%i + 1)" % tab_nr):
+            buf_nr = int(buf_nr) - 1
+            try:
+                buf_path = vim.buffers[buf_nr].name
+            except (LookupError, ValueError):
+                # Just do good old asking for forgiveness.
+                # don't know why this happens :-)
+                pass
+            else:
+                if 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)

pythonx/jedi_vim_debug.py

@@ -0,0 +1,44 @@
+"""Used in jedi-vim's jedi#debug_info()"""
+
+
+def display_debug_info():
+    import vim
+
+    def echo(msg):
+        vim.command('echo {0}'.format(msg))
+
+    echo("printf(' - sys.version: `%s`', {0!r})".format(
+        ', '.join([x.strip()
+                   for x in __import__('sys').version.split('\n')])))
+    echo("printf(' - site module: `%s`', {0!r})".format(
+        __import__('site').__file__))
+
+    try:
+        import jedi_vim
+    except Exception as e:
+        echo("printf('ERROR: jedi_vim is not available: %s: %s', "
+             "{0!r}, {1!r})".format(e.__class__.__name__, str(e)))
+        return
+
+    try:
+        if jedi_vim.jedi is None:
+            echo("'ERROR: could not import the \"jedi\" Python module.'")
+            echo("printf('       The error was: %s', {0!r})".format(
+                getattr(jedi_vim, "jedi_import_error", "UNKNOWN")))
+        else:
+            echo("printf('Jedi path: `%s`', {0!r})".format(
+                jedi_vim.jedi.__file__))
+            echo("printf(' - version: %s', {0!r})".format(
+                jedi_vim.jedi.__version__))
+            echo("' - sys_path:'")
+
+            script_evaluator = jedi_vim.jedi.Script('')._evaluator
+            try:
+                sys_path = script_evaluator.project.sys_path
+            except AttributeError:
+                sys_path = script_evaluator.sys_path
+            for p in sys_path:
+                echo("printf('    - `%s`', {0!r})".format(p))
+    except Exception as e:
+        echo("printf('There was an error accessing jedi_vim.jedi: %s', "
+             "{0!r})".format(e))

test/completions.vim

@@ -8,9 +8,22 @@ describe 'completions'
     end
 
     after
+        " default
+        let g:jedi#popup_select_first = 1
         bd!
     end
 
+    it 'smart import'
+        exec "normal ifrom os "
+        Expect getline('.') == 'from os import '
+    end
+
+    it 'no smart import after space'
+        exec "normal! ifrom os "
+        exec "normal  a "
+        Expect getline('.') == 'from os  '
+    end
+
     it 'import'
         " X is the completion command
         normal oimporX
@@ -26,26 +39,32 @@ describe 'completions'
         Expect getline('.') == 'IndentationError().filename'
     end
 
-    it 'dot_open'
-        normal oraisX ImpXErrX()
-        Expect getline('.') == 'raise ImportError()'
+    it 'multi complete'
+        normal oImpXErrX()
+        Expect getline('.') == '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'
+    it 'cycling through entries popup_select_first=0'
         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
+        execute "normal oraise impX\<C-n>"
+        " It looks like this is currently not working properly.
+        "Expect getline('.') == 'raise ImportError'
+    end
 
+    it 'cycling through entries popup_select_first=1'
+        execute "normal oraise impX\<C-n>"
+        Expect getline('.') == 'raise ImportWarning'
+    end
+
+    it 'longest'
         " -longest completes the first one
         set completeopt -=longest
         execute "normal oraise baseX"
         Expect getline('.') == 'raise BaseException'
         set completeopt +=longest
+    end
 
+    it 'dot_open'
     end
 end
 

test/documentation.vim

@@ -13,7 +13,7 @@ describe 'documentation docstrings'
     it 'simple'
         put = 'ImportError'
         normal GK
-        Expect bufname('%') == "'__doc__'"
+        Expect bufname('%') == "__doc__"
         Expect &filetype == 'rst'
         let content = join(getline(1,'$'), "\n")
         Expect stridx(content, "Import can't find module") > 0
@@ -23,7 +23,7 @@ describe 'documentation docstrings'
 
     it 'no documentation'
         put = 'x = 2'
-        normal G0K
+        normal o<ESC>GK
         Expect bufname('%') == ''
     end
 end

test/goto.vim

@@ -2,7 +2,7 @@ let mapleader = '\'
 source plugin/jedi.vim
 source test/utils.vim
 
-describe 'goto_simple'
+describe 'goto simple'
     before
         new  " open a new split
         set filetype=python
@@ -20,13 +20,13 @@ describe 'goto_simple'
         bd!
     end
 
-    it 'goto_definitions'
-        silent normal \d
+    it 'goto definitions'
+        normal \d
         Expect line('.') == 1
-        "Expect col('.') == 5  " not working yet.
+        Expect col('.') == 5
     end
 
-    it 'goto_assignments'
+    it 'goto assignments'
         silent normal \g
         Expect line('.') == 2
         Expect col('.') == 1
@@ -45,9 +45,10 @@ describe 'goto_simple'
 end
 
 
-describe 'goto_with_tabs'
+describe 'goto with tabs'
     before
         set filetype=python
+        let g:jedi#use_tabs_not_buffers = 1
     end
 
     after
@@ -55,7 +56,7 @@ describe 'goto_with_tabs'
         bd!
     end
 
-    it 'follow_import'
+    it 'follow import'
         put = ['import subprocess', 'subprocess']
         silent normal G\g
         Expect getline('.') == 'import subprocess'
@@ -63,7 +64,7 @@ describe 'goto_with_tabs'
         Expect col('.') == 8
 
         silent normal G\d
-        Expect g:current_buffer_is_module('subprocess') == 1
+        Expect CurrentBufferIsModule('subprocess') == 1
         Expect line('.') == 1
         Expect col('.') == 1
         Expect tabpagenr('$') == 2
@@ -72,27 +73,30 @@ describe 'goto_with_tabs'
         Expect bufname('%') == ''
     end
 
-    it 'multi_definitions'
-        put = ['import tokenize']
-        silent normal G$\d
-        Expect g:current_buffer_is_module('tokenize') == 0
-        Expect g:current_buffer_is_module('token') == 0
-        execute "normal \<CR>"
-        Expect tabpagenr('$') == 2
-        Expect winnr('$') == 1
-        Expect g:current_buffer_is_module('token') == 1
+    it 'multi definitions'
+        " This used to behave differently. Now we don't have any real multi
+        " definitions.
 
-        bd
-        silent normal G$\d
-        execute "normal j\<CR>"
-        Expect tabpagenr('$') == 2
-        Expect winnr('$') == 1
-        Expect g:current_buffer_is_module('tokenize') == 1
+        " 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'
+describe 'goto with buffers'
     before
         set filetype=python
         let g:jedi#use_tabs_not_buffers = 0
@@ -104,46 +108,46 @@ describe 'goto_with_buffers'
         set nohidden
     end
 
-    it 'no_new_tabs'
+    it 'no new tabs'
         put = ['import os']
         normal G$
         call jedi#goto_assignments()
-        python jedi_vim.goto()
-        Expect g:current_buffer_is_module('os') == 0
+        PythonJedi 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 g:current_buffer_is_module('os') == 1
+        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 g:current_buffer_is_module('tokenize') == 0
-        Expect g:current_buffer_is_module('token') == 0
-        execute "normal \<CR>"
-        Expect tabpagenr('$') == 1
-        Expect winnr('$') == 1
-        Expect g:current_buffer_is_module('token') == 1
+    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 g:current_buffer_is_module('tokenize') == 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'
+describe 'goto with splits'
     before
         set filetype=python
         let g:jedi#use_splits_not_buffers = 'left'
@@ -154,7 +158,7 @@ describe 'goto_with_splits'
         bd!
     end
 
-    it 'follow_import'
+    it 'follow import'
         put = ['import subprocess', 'subprocess']
         silent normal G\g
         Expect getline('.') == 'import subprocess'
@@ -162,7 +166,7 @@ describe 'goto_with_splits'
         Expect col('.') == 8
 
         silent normal G\d
-        Expect g:current_buffer_is_module('subprocess') == 1
+        Expect CurrentBufferIsModule('subprocess') == 1
         Expect line('.') == 1
         Expect col('.') == 1
         Expect winnr('$') == 2
@@ -173,4 +177,41 @@ describe 'goto_with_splits'
 end
 
 
+describe 'goto wildignore'
+    before
+        set filetype=python
+        set wildignore=*,with\ spaces,*.pyc
+        set hidden
+        let g:jedi#use_tag_stack = 1
+        let g:jedi#use_tabs_not_buffers = 0
+        " Need to use splits for code coverage in new_buffer()
+        let g:jedi#use_splits_not_buffers = 1
+
+        put = ['from subprocess import Popen', 'Popen']
+        Expect CurrentBufferIsModule('subprocess') == 0
+        silent normal G
+    end
+
+    after
+        bd!
+        bd!
+        set wildignore&vim
+    end
+
+    it 'restores wildignore'
+        let before = &wildignore
+        call jedi#goto()
+        Expect getline('.') =~ 'Popen'
+        Expect &wildignore == before
+    end
+
+    it 'not using tagstack'
+        let g:jedi#use_tag_stack = 0
+        call jedi#goto()
+        Expect CurrentBufferIsModule('subprocess') == 1
+        Expect getline('.') =~ 'Popen'
+    end
+end
+
+
 " vim: et:ts=4:sw=4

test/pyimport.vim

@@ -2,6 +2,10 @@ source plugin/jedi.vim
 source test/utils.vim
 
 describe 'pyimport'
+    before
+        let g:jedi#use_tabs_not_buffers = 1
+    end
+
     after
         bd!
         bd!
@@ -9,9 +13,9 @@ describe 'pyimport'
 
     it 'open_tab'
         Pyimport os 
-        Expect g:current_buffer_is_module('os') == 1
+        Expect CurrentBufferIsModule('os') == 1
         Pyimport subprocess 
-        Expect g:current_buffer_is_module('subprocess') == 1
+        Expect CurrentBufferIsModule('subprocess') == 1
         " the empty tab is sometimes also a tab
         Expect tabpagenr('$') >= 2
     end
@@ -19,10 +23,14 @@ describe 'pyimport'
     it 'completion'
         " don't know how to test this directly
         "execute "Pyimport subproc\<Tab>"
-        "Expect g:current_buffer_is_module('subprocess') == 1
+        "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"
+        let g:comp = jedi#py_import_completions('zip', 0, 0)
+        " Sometimes zipapp is in there sometimes not, depends on Python
+        " version.
+        let g:comp = substitute(g:comp, '^zipapp\n', '', '')
+        Expect g:comp == "zipfile\nzipimport"
     end
 end

test/signatures.vim

@@ -11,14 +11,41 @@ describe 'signatures'
     end
 
     it 'simple'
-        normal ostr( 
+        normal odef xyz(number): return
+        normal o
+        normal oxyz( 
+        normal G$
         " equals doautocmd CursorMovedI
         Python jedi_vim.show_call_signatures()
 
-        Expect getline(1) == '≡jedi=0, ≡   (*obj*) ≡jedi≡'
+        Expect getline(3) == '?!?jedi=0, ?!?   (*_*number*_*) ?!?jedi?!?'
 
         doautocmd InsertLeave
-        Expect getline(1) == ''
+        Expect getline(3) == ''
+    end
+
+    it 'multiple buffers'
+        set hidden
+        new
+        setfiletype python
+        redir => autocmds
+        autocmd jedi_call_signatures * <buffer>
+        redir END
+        Expect autocmds =~# 'jedi_call_signatures'
+        buffer #
+        redir => autocmds
+        autocmd jedi_call_signatures * <buffer>
+        redir END
+        Expect autocmds =~# 'jedi_call_signatures'
+        bd!
+    end
+
+    it 'simple after CursorHoldI with only parenthesis'
+        noautocmd normal o
+        doautocmd CursorHoldI
+        noautocmd normal istr( 
+        doautocmd CursorHoldI
+        Expect getline(1) == '?!?jedi=0, ?!?   (*_*object*_*) ?!?jedi?!?'
     end
 
     it 'no signature'
@@ -28,12 +55,79 @@ describe 'signatures'
     end
 
     it 'signatures disabled'
-        let g:jedi#show_signatures = 0
+        let g:jedi#show_call_signatures = 0
 
         normal ostr( 
         Python jedi_vim.show_call_signatures()
         Expect getline(1, '$') == ['', 'str( ']
 
-        let g:jedi#show_signatures = 1
+        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 ostr( 
+        redir => msg
+        Python jedi_vim.show_call_signatures()
+        redir END
+        Expect msg == "\nstr(object)"
+
+        redir => msg
+        doautocmd InsertLeave 
+        redir END
+        Expect msg == "\n"
+
+        normal Sdef foo(a, b): pass
+        normal ofoo(a, b, c, 
+        redir => msg
+        Python jedi_vim.show_call_signatures()
+        redir END
+        Expect msg == "\nfoo(a, b)"
+    end
+
+    it 'command line truncation'
+        let g:jedi#show_call_signatures = 2
+        call jedi#configure_call_signatures()
+
+        function! Signature()
+            redir => msg
+            Python jedi_vim.show_call_signatures()
+            redir END
+            return msg
+        endfunction
+
+        let funcname = repeat('a', &columns - 30)
+        put = 'def '.funcname.'(arg1, arg2, arg3, a, b, c):'
+        put = '    pass'
+        execute "normal o".funcname."( "
+        Expect Signature() == "\n".funcname."(arg1, …)"
+
+        normal sarg1, 
+        Expect Signature() == "\n".funcname."(…, arg2, …)"
+
+        normal sarg2, arg3, 
+        Expect Signature() == "\n".funcname."(…, a, b, c)"
+
+        normal sa, b, 
+        Expect Signature() == "\n".funcname."(…, c)"
+
+        g/^/d
+        put = 'def '.funcname.'('.repeat('b', 20).', arg2):'
+        put = '    pass'
+        execute "normal o".funcname."( "
+        Expect Signature() == "\n".funcname."(…)"
+    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

test/utils.vim

@@ -1,9 +1,9 @@
-function! g:current_buffer_is_module(module_name)
-    return g:ends_with(bufname('%'), a:module_name.'.py')
+function! CurrentBufferIsModule(module_name)
+    return EndsWith(bufname('%'), a:module_name.'.py')
 endfunction
 
 
-function g:ends_with(string, end)
+function EndsWith(string, end)
     let l:should = len(a:string) - strlen(a:end)
     return l:should == stridx(a:string, a:end, should)
 endfunction