86 Commits

Author SHA1 Message Date
Daniel Hahler
b9f8317595 Update submodule pythonx/jedi 454447d4...60415033
* pythonx/jedi 454447d4...60415033 (54):
      > Prepare the v0.14.1 release
      > Use fixture names everywhere
      > Cleanup a test file
      > Use parametrize instead of TestCase
      > Remove a TestCase class usage
      > Use pytest.mark.parametrize for something instad of a class
      > Use the names fixture even more
      > Use the names fixture more
      > A small rename
      > Refactor names tests
      > A small refactoring
      > Make sure __wrapped__ works properly when using an Interpreter, fixes #1353
      > Small refactoring
      > Make API param names appear without leading double underscores, fixes #1357 again
      > Fix some call signature tests
      > Make expected index work in Python 3
      > Test both closing brackets and non-closing brackets for CallSignature.index
      > Fix a case with errors
      > Move some code around
      > Fix some kwargs cases
      > Fix some *args issues
      > Deal better with some error nodes
      > Delete unused code
      > Fix some error node handling for call signatures
      > Fix CallSignature index for a looot of cases, fixes #1364,#1363
      > Use recursion rather than other stuff
      > Even more refactorings
      > small name refactoring
      > Refactor some call details
      > Disable a test for Python 2
      > Fix pow() signature, fixes #1357
      > Merge branch 'master' of github.com:davidhalter/jedi
      > Fix signature to_string
      > Fix an issue with keyword params, fixes #1356
      > Simplify some test code for param defaults, see #1356
      > Merge branch 'function_signature_in_interpreter' of https://github.com/linupi/jedi
      > Improve a bit of dataclasses support, so at least the attributes can be seen
      > Make sure in tests that pep 0526 variables are also able to be used when using self, see #933
      > Get typing.NewType working (#1344)
      > Cannot use pytest 5 yet
      > Fix filters for classes and functions
      > Fix some small things to get more tests passing
      > A better repr for Definition
      > Merge branch 'master' of github.com:davidhalter/jedi
      > Fix ClassVar filter for instances
      > Keyword completions are no longer possible directly after a number, fixes #1085
      > Fix super call goto for multiple inheritance, fixes #1311
      > goto should always goto definitions, fixes #1304
      > Fix star imports checks, fixes #1235
      > Actually import IsADirectoryError
      > Add 3.8 to supported versions
      > Fix project search if a directory is called manage.py, fixes #1314
      > Return annotations for compiled objects now help to infer
      > Update parso requirement
2019-07-13 20:21:56 +02:00
Daniel Hahler
d3f40d13ec Update submodule pythonx/parso 59df3fa...c0ace63
* pythonx/parso 59df3fa...c0ace63 (9):
      > For Python 2.7 and 3.4 pytest 5 doesn't work anymore
      > Prepare the 0.5.1 release
      > Fix name tokenizing for Python 2
      > Fix positioning for names that are interleaved with error tokens
      > Merge branch 'master' of github.com:davidhalter/parso
      > Fixed name tokenizing issues for tamil characters, fixes davidhalter/jedi#1368
      > Document that the cache uses pickle files
      > Fix changelog dates, fixes #77
      > Try to use collections.abc.Mapping instead of collections.Mapping
2019-07-13 20:21:56 +02:00
Dave Halter
016fb7c78e Merge pull request #915 from davidhalter/typeshed
With typeshed coming to Jedi, builtin modules should be displayed
2019-06-23 01:13:14 +02:00
Dave Halter
e736eea934 Use staticmethod for call signature tests instead of str
str has different signatures for Python 2 and 3 and is therefore annoying to test.
2019-06-21 00:28:18 +02:00
Dave Halter
6c6b4dcf92 Make sure that formatting happens on unicode 2019-06-20 23:56:46 +02:00
Dave Halter
73289427ba Modules should be accessible if column is not None 2019-06-20 23:46:34 +02:00
Dave Halter
1a053d2a23 Fix some call signature tests 2019-06-20 23:37:43 +02:00
Dave Halter
636ad08d32 Get rid of documentation about pip install jedi
pip install jedi doesn't work with properly with virtualenvs, if jedi-vim is
used.
2019-06-20 23:15:16 +02:00
Dave Halter
d32962f3b2 Upgrade Jedi to 0.14.0 and parso to 0.5.0 2019-06-20 22:38:57 +02:00
Dave Halter
717446dd71 For whatever reason tabs were used as indentation 2019-06-17 20:52:31 +02:00
Dave Halter
9c9a513aaf Add a goto_stubs command 2019-06-16 09:39:50 +02:00
Daniel Hahler
69aa410afa Fix :JediClearCache!
Parso's cache can be cleaned from Jedi now.
2019-04-28 21:19:39 +02:00
Daniel Hahler
914754a04e Disable smart_auto_mappings by default
Ref: https://github.com/davidhalter/jedi-vim/issues/568
2019-04-06 01:02:23 +02:00
Dave Halter
f26b2a8802 Change supported Python version in docs 2019-03-22 12:40:28 +01:00
Daniel Hahler
d879d2f216 jedi#show_documentation: check len of g:jedi#documentation_command 2019-03-22 12:35:43 +01:00
Dave Halter
23c14f6826 With typeshed coming to Jedi, builtin modules should be displayed
(If there's a module_path (which most will have)).

This change is still backwards compatible and can be used with older Jedi
versions (<0.14.0).
2019-03-09 13:35:56 +01:00
Dave Halter
1f7e661d9d Upgrade parso 2019-02-24 18:59:53 +01:00
Dave Halter
c6fe4fee76 Upgrade Jedi to latest 2019-02-24 18:59:29 +01:00
Dave Halter
ea5e87a703 Remove jedi.NotFoundError, because that was removed quite a while ago, see #899 2019-02-17 18:04:15 +01:00
Henré Botha
d02a72e792 Update Python version in README (#911)
As per the author's comment here, Python 2.6 is no longer supported. https://github.com/davidhalter/jedi-vim/issues/866#issuecomment-409852888
2019-02-12 14:30:02 +01:00
Daniel Hahler
42d24387ac Update parso to 0.3.3 (#909)
Update submodule pythonx/parso a2b153e...f1ee761

    * pythonx/parso a2b153e...f1ee761 (6):
      > Release of 0.3.3
      > Rename a test
      > Remove some unused code
      > Fix working with async functions in the diff parser, fixes #56
      > Fix bytes/fstring mixing when using iter_errors, fixes #57.
      > Improve a docstring, fixes #55.
2019-02-06 13:09:45 +01:00
Stevan Milic
ba5915bf26 Fix rename with folds: replace line in buffer directly (#906)
Fixes #789
2019-02-05 20:28:46 +01:00
Daniel Hahler
c5c13d69d6 ci: Travis: Ubuntu Xenial, and pynvim (#908) 2019-02-05 20:03:33 +01:00
Daniel Hahler
f36749776d Update parso to v0.3.2
Update submodule pythonx/parso 930ec08...a2b153e

    * pythonx/parso 930ec08...a2b153e (91):
      > Upgrade the Changelog
      > Escape a backslash properly
      > Bump the parso version to 0.3.2
      > f-string parts are also PythonLeaf instances
      > Fix get_start_pos_of_prefix
      > Remove dead code
      > Refactor f-string support
      > Fix: End detection for strings was mostly wrong, fixes #51
      > Fix f-string escapes, fixes #48
      > Tokenizer: Simplify end of string regexes
      > Add a comment from the Python3.7 code base
      > Fix diff parser: The previous fix was a bit off
      > Change fuzzer: Add ways to not always use correct parse input
      > Fix diff parser: issue with opening brackets
      > Async doesn't work in 3.4
      > Skip some tests for Python2.6 and Python3.3
      > Fix diff parser: DEDENT as error leaves should also be ignored and reparsed
      > Fix diff parser: error dedents in between nodes should be ignored for now when copying
      > Fix diff parser: Don't copy error nodes/leaves in the beginning, leads to strange issues in some cases
      > Diff fuzzer: Create a check to see if the errors make sense.
      > Fix diff parser: Don't copy DEDENT tokens at the beginning
      > Fix diff parser: Skip last leaves for last line offset leaves
      > Fix indentation error tokens
      > Fix diff parser: Avoid side effects for prefix
      > Fix tokenizer: backslashes sometimes led to newline token generation
      > Make lines easier copyable in the fuzzer
      > Fix tokenizer: Carriage returns after backslashes were not properly handled
      > Fix in diff parser: prefix calculation was wrong when copying nodes
      > Replace --print-diff with --print-code
      > Fix diff parser generation for empty files
      > Docopt should not be needed for tests
      > Fix tokenizer: Form feeds and multiline docstrings didn't work together
      > Fix diff parser: Need to calculate the prefix for the diff tokenizer better
      > Remove copied nodes stuff, to simplify some things
      > Fix newline endings and a few parser/copy counts
      > Feature: The diff parser fuzzer is now able to use random Python fragments
      > Fix: The Python 3.8 grammar did not include f-string support
      > Fix tokenizer: Closing parentheses in the wrong place should not lead to strange behavior
      > Fix end positions with error dedents
      > Fix diff parser tests for Python 2
      > Randomize the fuzzer a bit more with inserting characters
      > Simplify the regexes
      > Fix a regex clause that was totally wrong
      > Fix another tokenizer issue
      > Apply \r changes in syntax trees
      > Actually make \r usable
      > Fix split lines for Python code
      > Add \r as a valid linebreak for splitlines
      > Move split_lines tests around
      > Start generating really random strings with the fuzzer
      > Fix tokenizer: Dedents before error tokens are properly done, now.
      > Fix diff parser: Also check async with
      > Make the diff parser use a lot of different files by default
      > Fix diff parser: Forgot that with statments are also flows
      > Fix valid graph asserting for some dedents that are errors
      > Fix diff parser: If funcs are not copied, errors shouldn't either
      > Better documentation for the fuzz diff parser script
      > Rename a test
      > More verbose output for the diff fuzzer
      > Fix diff parser: error dedent issues
      > Fix diff parser: Avoid indentation issues
      > Use the right diff order in debug output
      > Fix diff parser: The prefix was wrong in some copy cases
      > Make fuzz parser compatible with Python 2
      > Make it possible to print all diffs in fuzzer
      > Introduce a redo flag 'only_last' to narrow down issues
      > Add docopt to testing dependencies
      > Rewrite the fuzz diff parser to cache errors (so we can re-run those)
      > Fix diff parser: Decorators were sometimes parsed without their functions
      > Fix tokenizer: Dedents should only happen after newlines
      > Usability for diff parser fuzzing
      > Fix for diff parser: Rewrite prefix logic and don't mutate prematurely
      > Fix diff parser: positioning of functions if decorators were removed
      > Ignore ERROR_DEDENT in graph validation
      > Add a small diff parser fuzzer
      > Fix diff parser: get_last_line was sometimes wrong
      > Fix error reporting order for diff issues
      > Clean up the test diff parser file
      > Avoid nasty side effects in creation of Node
      > Make parso errors even more informative
      > Fix diff parser get_last_line calculation
      > Fix graph asserting for error indents
      > Better checks for checking valid graphs
      > Create better ways for debugging the diff parser
      > Fix diff-parser: Copying parts of if else should not lead to the whole thing being copied
      > Reenable diff parser parser counting in all tests
      > Fix: Make the NodesStack to a NodesTree
      > Fix for diff parser : Make sure that start_pos are growing always The problem was that functions/classes were sometimes not well positioned. Now all diff tests are ensuring that leaves always grow.
      > Add a check to see if leaves have the right start positions
      > Add parso version to an exception
      > MNT: add grammar for python 3.8
2019-01-25 01:21:33 +01:00
Brian Mego
7f4f2db260 Fixes incorrect documentation 2018-12-03 23:51:19 +01:00
Daniel Hahler
2f65c636f8 ftplugin: do not duplicate jedi_usages autocommands (#883)
Fixes https://github.com/davidhalter/jedi-vim/issues/882.
2018-11-08 08:43:28 +01:00
Daniel Hahler
b6dfc5fd49 Update submodule pythonx/parso e6bc924...930ec08
* pythonx/parso e6bc924...930ec08 (7):
      > Use SVG badges
      > tox.ini: simplify deps
      > tox: add pypy to envlist for tox-travis
      > setup.py: add "testing" extras_require
      > Add Python 3.7 stable to test matrix and update classifiers
      > Update usage.rst
      > Don't use invalid escape sequences in regex, see https://github.com/davidhalter/jedi-vim/issues/843
2018-10-14 17:55:56 +02:00
Daniel Hahler
2a43448f3b Update submodule pythonx/jedi a79a1fb...bd1010b
* pythonx/jedi a79a1fb...bd1010b (91):
      > Create a new 0.13.1 release
      > Fixed completions of global vars and tensorflow slowness, fixes #1228, #1116
      > The changelog date was wrong
      > Release notes for 0.13.0
      > Fix tensorflow issues with a few hacks (temporary), fixes #1195
      > If the VIRTUAL_ENV variable changes, need to reload the default environment, fixes #1201, #1200
      > Return SameEnvironment as a default, fixes #1226, #1196
      > Document that using the REPL autocompletion is only available on Linux/Mac, fixes #1184
      > Fix an issue with f-strings, fixes #1224
      > Ignore some errors that are happening when the Python process ends and its subprocesses are cleaned up
      > also remove crashes with pep 448 unpacking of lists and sets
      > Fixed crash (and now recognises correctly) {**d, "b": "b"}["b"]
      > Recognize {**d} as a dict instead of set
      > Add extras_require=testing
      > _get_virtual_env_from_var: use safe=False
      > tests: venv_path: use session scope
      > jedi/api/environment.py: minor flake8 fix
      > jedi.api.environment._SUPPORTED_PYTHONS: add 3.7
      > Removing a test from doctests, becaues it shouldn't be one
      > Refactor argument clinic usage
      > With the recent changes one performance optimization got lost
      > FunctionExecutionContext should use the parent if possible
      > Use anonymous instance arguments in a different way
      > Move some anonymous instance function execution stuff
      > Get rid of InstanceFunctionExecution, because it's really not needed
      > Use the InstanceArguments for super as well
      > Use InstanceArguments directly and not via InstanceFunctionExecution
      > Remove old garbage code
      > Don't use arguments that are not needed
      > Also move the remaining get_params to get_executed_params
      > get_params -> get_executed_params where possible
      > Subprocess error reporting improvements
      > Fix a recursion issue about compiled objects
      > Use a CompiledInstanceNameFilter that wraps the class name as well
      > Prefer Python 3 import over 2
      > Now it's actually possible to specify a pytest environment for the same Python version
      > Note that Python 3.3 support was dropped in Changelog
      > Drop support for EOL Python 3.3 (#1019)
      > Rewrite the pyc test
      > Fix an issue with stderr debugging of subprocesses
      > stderr of the child processes should be printed in debug output
      > Use close_fds for posix.
      > Remove some redundant code
      > Use names of classes to infer names of instances
      > Don't have execute and execute_evaluated on name
      > Fix an issue where __ prefixed variables where not hidden when accessed from a class
      > Bound methods are now working correctly in all Python versions. Therefore a test was wrong.
      > Remove a print in tests
      > BoundMethods now have access to the function that they are using
      > Remove another usage of is_class where it's not needed
      > FunctionContext should be created from a unified interface
      > Don't create a FunctionExecutionContext if it's not used.
      > Use TreeContext in a good way
      > Fix broken link in documentation
      > The implicit namespace package test from 4b276bae87a3170672f7ddb3e00f5851fe24d562 can only be used for Python 3.4+
      > The import resolution for namespace packages was wrong
      > Add a way to use the interpreter environment for tests
      > MergedExecutedParams -> DynamicExecutedParams
      > Fix a recursion error, fixes #1173
      > Remove two recursion tests again that will belong into a commit at a point where it is not failing anymore
      > Don't merge params if it's just one param
      > Add a repr for AnonymousArguments
      > Fix a doctest
      > Some minor flake8 fixes
      > Script.__repr__: include environment
      > Add params to CallSignature.__repr__
      > Environments are now always created on request
      > Improve Environment
      > Add max line length 100 to the config for flake8
      > tests: use monkeypatch.setenv
      > Don't test Python 3.3 on appveyor anymore, it's getting really hard to get all the right dependencies for it, because 3.3 is deprecated everywhere.
      > Mention that it's ok to have a line length of 100 characters in our files.
      > Don't use invalid escape sequences in regex, see https://github.com/davidhalter/jedi-vim/issues/843
      > subprocess: listen: exit normally with EOFError
      > Script: improve ValueError for column
      > The sys path might be lazy or not in a venv
      > The encoding parameter should be used again (includes test), fixes #1167
      > Remove source_encoding from documentation (see #1167)
      > Actually use the fast_parser setting again
      > Use an import name list as long as possible
      > Different _load_module API
      > Directly load modules if possible, with this it's not necessary anymore to use dotted_from_fs_path, also fixes #1013.
      > Don't mutate the sys.path. This is pretty nasty bug that fixes #1148
      > Don't follow builtin imports anymore by default when follow_imports is on (goto)
      > Add a changelog entry for the include_builtins change
      > additional_module_paths in usages never actually worked
      > Add include_builtins to usages, fixes #1131.
      > Finally make it possible to use auto_import_modules for packages
      > Test auto_import_modules in a very basic way
      > Fix a bug about fstring completion
      > Comprehensions are also possible arguments. Fixes 1146
2018-10-14 17:55:56 +02:00
Daniel Hahler
c6f05cd82c .coveragerc: concurrency = greenlet (#874)
Fixes https://github.com/neovim/python-client/issues/354
2018-08-16 16:37:00 +02:00
Daniel Hahler
132d8506ab tests: move/rename/cleanup vspec based tests (#860)
The main motivation is to being able to use normal/other pytest based
tests.

Therefore this moves everything from conftest into test_integration
itself.
2018-08-01 23:57:37 +02:00
Daniel Hahler
399c57ff72 Fix displaying of error information with shortmess+=F
When being initialized via ftplugin `set shortmess+=F` (default in
Neovim by now) causes the additional information (the full traceback) to
be silenced.

This patch uses `:unsilent` to always display it.

Ref: https://github.com/neovim/neovim/issues/8675
2018-08-01 22:50:23 +02:00
Daniel Hahler
1126ffde9b Makefile: make pip-install quiet 2018-08-01 22:50:23 +02:00
Daniel Hahler
88502891ba Report coverage (#863) 2018-07-30 22:45:06 +02:00
Dave Halter
b33392c8c8 Merge pull request #864 from blueyed/nvim (neovim testing)
Testing is now alow possible with Neovim
2018-07-30 18:09:45 +02:00
Daniel Hahler
ffec4d7fc5 Test with Neovim 2018-07-30 14:24:53 +02:00
Daniel Hahler
43a9a9b191 Fix test/signatures.vim: ensure there is no indent (nvim) 2018-07-30 14:24:53 +02:00
Daniel Hahler
e05f34646e Fix test/signatures.vim: take into account &ruler (nvim) 2018-07-30 14:24:53 +02:00
Daniel Hahler
713e78dd39 tests: harden/fix completions with regard to longest/nvim mostly 2018-07-30 14:24:53 +02:00
Daniel Hahler
e49638ffc8 Upgrade vim-vspec to 1.8.1 (#862)
This fixes some tests to make it work with the newer version.
2018-07-30 11:16:51 +02:00
Daniel Hahler
4c430ed536 Improve JediDebugInfo for envs (#858)
Improve JediDebugInfo for envs

This is taken out of https://github.com/davidhalter/jedi-vim/pull/836.
2018-07-28 01:46:12 +02:00
Daniel Hahler
40fc5ab27f test/signatures.vim: remove trailing spaces 2018-07-25 02:21:54 +02:00
Daniel Hahler
9a4a4f4074 Skip duplicate call signatures
I am seeing `p` twice for os.path.dirname, which seems to come from
Lib/posixpath.py and Lib/ntpath.py, as can be seen with `os.path.join`,
where I still see two with this patch:

```
            (path, *paths)
import os   (a, *p)
os.path.join()
```
2018-07-16 13:50:49 +02:00
Daniel Hahler
c6716c6392 Makefile: use a single venv 2018-07-15 21:22:29 +02:00
Daniel Hahler
5123dbbbc7 Fix flake8 issue 2018-07-15 20:57:27 +02:00
Daniel Hahler
ee0f759a2e qa: add flake8 to check make target 2018-07-15 20:57:27 +02:00
Daniel Hahler
66b6a20041 Factor out annotate_description
This uses d.type, but special-cases functions and statements.
2018-07-15 19:26:11 +02:00
Daniel Hahler
8e077adb2f show_goto_multi_results: use relpath
This helps Vim to display the path for unlisted buffers relative to cwd
in the quickfix list.
2018-07-15 19:26:11 +02:00
Dave Halter
e7cb9a186e Also add remove_usages on InsertEnter 2018-07-15 19:26:11 +02:00
Dave Halter
b5774a9554 Add an augroup for usages 2018-07-15 19:26:11 +02:00
Dave Halter
f0d80048f1 Remove usages after text has changed in normal mode 2018-07-15 19:26:11 +02:00
Dave Halter
9e2244c44e Use standout/reverse instead of yellow for jediUsages
It uses cterm=reverse, which is supported by current Neovim, and at
least for xterm and rxvt-unicode reverse and standout are the same.

See `infocmp`:

> smso=\E[7m / rev=\E[7m
2018-07-15 19:26:11 +02:00
Dave Halter
cc087ef463 Somehow show_goto_multi_results was called without arguments
This was obviously wrong and fixed by inserting the obvious param
2018-07-15 19:26:11 +02:00
Dave Halter
efaef9cee3 Rename was in the wrong spot when using it at the end of a line. 2018-07-15 19:26:11 +02:00
Dave Halter
58561d45f1 Fix renaming and also highlight the renamed classes. 2018-07-15 19:26:11 +02:00
Dave Halter
84b8eeb954 Highlight usages
Use matchaddpos to highlight usages in the current file.
2018-07-15 19:26:11 +02:00
Dave Halter
2bb7677b43 Make it clearer which versions make check requires 2018-07-14 15:39:02 +02:00
Dave Halter
81ada14f0b Upgrade jedi to 0.12.1, forgot to upgrade it when upgrading parso
a79a1fb Merge branch 'parso'
58141f1 Don't use requirements for now, and use the git version instead in tox
e0e2be3 Add a better comment about why people need to upgrade parso
1e7662c Prepare release of 0.12.1
68974ae Don't use internal parso APIs if possible
c208d37 Remove code that is no longer used, because parso was refactored.
3847406 Make jedi work with the next parso release
95f835a Force unicode when listing module names
282c6a2 Use highest possible pickle protocol
ea71ded Include stderr with "subprocess has crashed" exception (#1124)
106b11f Set stdout and stdin to binary mode on Python 2 and Windows
f9e90e8 Use system default buffering on Python 2
197aa22 Use cPickle on Python 2 if available
e96ebbe Add tests for DefaultDict support.
55941e5 Add support for DefaultDict on jedi_typing.py.
ff4a773 Parse correct AST attribute for version
70c2fce Replace distutils.spawn.find_executable with shutil.which
5dab97a Add an error message, see also #1139.
e2cd228 Dict comprehension items call should now work, fixes #1129
c1014e0 Fix flow analysis test
62a3f99 Fix a wrong branch check, fixes #1128
6ebe3f8 Drop 3.3 tests from travis
50812b5 A simple yield should not cause an error, fixes #1117
d10eff5 Travis: report coverage also to codecov.io
6748faa Fix _get_numpy_doc_string_cls: use cache
fc14aad Fix namespace autocompletion error
3c909a9 Travis: remove TOXENV=cov from allowed failures
b94b45c Environment._get_version: add msgs with exceptions
a95274d None/False/True are atom non-terminals in the syntax tree, fixes #1103
8d48e74 When searching submodules, use all of __path__, fixes #1105
9149956 Specially crafted docstrings sometimes lead to errors, fixes #1103
ba96c21 Follow up from the last async issue, fixes more related things about #1092.
8494164 Fix an async funcdef issue, fixes 1092.
4075c38 In some very rare cases it was possible to get an interpreter crash
because of this bug. Fixes #1087
0bcd170 Start using our own monkeypatch function for some things
ceb5509 Include function return type annotation in docstring if it is present
88243d2 Don't catch IndexError where we don't have to
5f37d08 Extend create_environment to accept an executable path
aa6857d check_fs: handle FileNotFoundError
2018-07-14 12:31:11 +02:00
Daniel Hahler
7cade1fb62 Update submodule pythonx/parso 6f385bd...e6bc924
* pythonx/parso 6f385bd...e6bc924 (44):
      > Use a setuptools that still supports py33
      > 3.1 release notes
      > Use one simple functions to check for funcdefs in diff parser
      > Make sure to treat async funcdefs the same way as normal funcdefs
      > Fix an issue in the diff parser
      > Asterisks in function definitions may be at the end of a func without a comma, fixes #44
      > Remove some TODOs that were fixed
      > Error recovery should not match the whole line in case of an invalid token, fixes #40
      > docs: enable searchbox
      > Merge branch 'pgen'
      > Merge branch 'master' of github.com:davidhalter/parso
      > Add docstring
      > Add some comments
      > Use a set instead of dict if it's not necessary
      > Simplify some code
      > Some refactorings for simplicity
      > Use NFAArc as a class
      > Some more renames
      > Another rename
      > Rename
      > Move the grammar parsing to a separate module
      > More renames
      > Rename
      > Separate generating dfas from parsing
      > Cleanup some names
      > Remove some code that is not used anymore
      > Some cleanups and documentation
      > Move out some more functions out of classes
      > Some more refactorings for clarification
      > Factor out start_symbol into a better position
      > Refactor out dfas
      > Document pgen grammars a bit better
      > addarc -> add_arc
      > Refactor some things in pgen
      > Move some initializations
      > Change license again. The year shouldn't matter
      > Make first private
      > Change copyright years
      > Remove some code from the grammar
      > Separate the grammar generation from the grammar parsing
      > In pgen now everything is named grammar and not c
      > Better recovery for online classes and functions
      > Fix one-line error recovery for all things that are using a suite
      > Add a debug function for first tokens
2018-07-10 14:46:01 +02:00
Daniel Hahler
1773837a11 syntax: use "hi def" everywhere
This allows for keeping user configuration.
2018-07-10 12:49:48 +02:00
Daniel Hahler
67fd8c6572 s:init_python: fix check for Python 2
Fixes https://github.com/davidhalter/jedi-vim/issues/841.
2018-07-08 04:31:58 +02:00
Daniel Hahler
d3d9a91ae6 init: improve handling of import errors (#840)
* jedi_vim.jedi_import_error: add location

This is useful for debugging.  It contains e.g. the path to parso, if
importing failed from there.

Example:

> Error: jedi-vim failed to initialize Python: jedi#setup_python_imports: could not import jedi: cannot import name 'PythonTokenTypes' (in /…/jedi-vim/pythonx/jedi/jedi/api/completion.py:1). (in function jedi#init_python[3]..<SNR>44_init_python[27]..jedi#setup_python_imports, line 37)

* init: handle jedi_vim.jedi_import_error in Vim plugin

Using `set shortmess+=F` would suppress the `:echom` used in
`jedi_vim.no_jedi_warning` [1].

This patch makes `jedi#setup_python_imports` handle the error instead.

1: https://github.com/neovim/neovim/issues/8675

* Revisit error handling with loading jedi_vim

* jedi#debug_info: display parso submodule separately

* Fix jedi#reinit_python

* fixup! Revisit error handling with loading jedi_vim

* display_debug_info: handle exceptions with environment.get_sys_path

* fixup! Revisit error handling with loading jedi_vim

[ci skip]
2018-07-04 22:12:07 +02:00
Daniel Hahler
0361d6c633 s:init_python: handle g:jedi#force_py_version again (#834)
It was removed previously, since it now refers to the environment being
used.

This brings it back for now.

There could be a separate var for it later, and/or it needs changes
later (or rather the environment needs a new variable name, since it
should refer to the executable really) - but this is good for now I think.

Fixes https://github.com/davidhalter/jedi-vim/issues/833
2018-07-04 17:55:25 +02:00
Dave Halter
a54729ef63 Use the official Jedi goto API instead of multiple calls
Fixes #802.
2018-07-04 00:03:11 +02:00
tobaloidee
5f98bfb62e Add logo (#837)
This has been force-pushed.

See https://github.com/davidhalter/jedi-vim/pull/837 for other variants,
and the reason for force-pushing.
2018-06-26 18:07:14 +02:00
Daniel Hahler
745dc8a559 jedi#setup_python_imports: better SyntaxError handling
Uses `repr` for SyntaxErrors.

Related: https://github.com/neovim/python-client/pull/221
2018-06-23 11:28:41 +02:00
Vivian
84a5299c8f Fix spelling error 2018-05-29 19:33:30 +02:00
Daniel Hahler
d4006ab1bf Fix s:init_python
Just check for `has('python3')` / `has('python')`.

Fixes 72a2643f7c (r28922063).
2018-05-21 23:37:14 +02:00
Daniel Hahler
ed8153ef2b Update submodule pythonx/parso 579146b...6f385bd
* pythonx/parso 579146b...6f385bd (7):
      > Not testing Python 3.3 anymore on travis. It seems to be broken
      > Add a changelog for 0.2.1
      > Push the version
      > The diff parser was slighly off with prefixes, fixes #1121
      > A better repr for the endmarker
      > Merge branch 'master' of github.com:davidhalter/parso
      > Fix a prefix issue with error leafs.
2018-05-21 23:35:42 +02:00
Daniel Hahler
f07ff6a535 Fix flake8 W605: invalid escape sequence '\{w,d}' 2018-05-10 22:40:58 +02:00
Dave Halter
6781eb17da Small documentation change 2018-05-09 16:04:47 +02:00
Dave Halter
5ad782d920 Remove a strange sentence 2018-05-09 16:04:47 +02:00
Daniel Hahler
d75aaa470e Improve jedi_vim.get_environment
- cache current environment
- s/jedi.get_python_environment/jedi.get_system_environment: the former
  does not exist (renamed in https://github.com/davidhalter/jedi/commit/336087f)
- improve error display
2018-05-09 16:04:47 +02:00
Daniel Hahler
56eb0f6d63 Improve display_debug_info 2018-05-09 16:04:47 +02:00
Dave Halter
835e329883 Some improvements for the virtualenv patch 2018-05-09 16:04:47 +02:00
Dave Halter
49fa267e59 The jedi API changed a bit 2018-05-09 16:04:47 +02:00
Dave Halter
fa1aaa10cf Fix the jedi-vim debug tool, fixes #795 2018-05-09 16:04:47 +02:00
Dave Halter
e54a17ec71 Document force_py_version better 2018-05-09 16:04:47 +02:00
Dave Halter
48a9ea085d Force the Python environment correctly 2018-05-09 16:04:47 +02:00
Dave Halter
72a2643f7c Use the environment for completions. 2018-05-09 16:04:47 +02:00
Dave Halter
57cbf1421f Somehow the virtual env prefix is set in VIM.
This basically corrupts VIM's Python, because it might be having a differnet prefix (Python 3.6) than sys path. I don't know who came up with this - probably it's just how Python loads venvs - but it's definitely not good. Fortunately we can just reset it and be happy.
2018-05-09 16:04:47 +02:00
Daniel Hahler
7894b38c0c tests: move .cache to build, rename test/_utils.vim 2018-04-19 21:55:19 +02:00
Daniel Hahler
1c3078e9f9 get_script: additional_dynamic_modules: add only listed buffers
Unlisted buffers might come e.g. from `set viminfo+=%`, and Jedi would
crash on them.

This could additionally check for them to be readable, but this should
be handled in Jedi itself anyway.
2018-04-17 23:55:30 +02:00
Daniel Hahler
79b332a3c6 Update submodule pythonx/jedi 02f238c...bd7c65d
* pythonx/jedi 02f238c...bd7c65d (413):
      > Finally fix all the get_system_environment issues
      > Fix a test
      > There's really no bin/activate needed for an environment to work
      > Document get_sys_path and change the signature of get_system_environment a bit
      > Rework the time cache.
      > Cache default environment
      > Require parso 0.2.0 at least
      > Set a release date
      > Don't install the latest pip version anymore in appveyor
      > Fix some references
      > Mention Virtualenv support in readme and features
      > Title case for Mänu :)
      > Better overview over functions in the documentation
      > A small docs correction
      > Remove the old static analysis stuff. It was never really used
      > Fix a lot of old docs code that doesn't exist anymore
      > Remove the old parser documentation (that's now part of parso)
      > Don't call it the plugin API anymore, that's confusing
      > Reorder some functions
      > Adda  lot of environment documentation to sphinx
      > find_python_environments -> find_system_environments
      > A small refactoring
      > Remove from_executable, were not really using it, yet.
      > For the second time in a row it's called creationflags not creation_flags
      > Refactor something small
      > Remove an unnecessary else
      > CREATE_NO_WINDOW was introduced in Python 3.7 and didn't exist before
      > The SameEnvironment should not load by default if it's a portable
      > Do binary comparisons to get virtualenvs working and not just venvs
      > Use the correct parameter name for creation flags
      > Add a way to generalize Popen
      > Check the windows environments in a better way
      > Fix some issues with the latest changes
      > DefaultEnvironment -> SameEnvironment
      > Better docs for Environment
      > Some docstrings
      > Make the Environment clearly non-public
      > Make some names public
      > Make sure Windows environments are safe
      > Fix the module_name issue again
      > Write a test for #1079 to avoid a regression in the future.
      > Cleanup some of the module cache stuff
      > Do not cache unimportable compiled module (#1079)
      > Merge branch 'master' of github.com:davidhalter/jedi
      > Multiple inheritance completion in Python 2 did not work
      > Give the run.py script an environment parameter
      > Fix an import
      > Merge the environment changes for Windows
      > Better tests for venvs
      > Write a test for venvs
      > Obviously Python 3 syntax cannot be used in Python 2
      > Update the changelog about f-strings
      > Use the latest parso version from master.
      > Better goto definition for fstrings
      > Fix an issue around the new grammar
      > Fix some fstring issues for now
      > Make a few modifications to always use the latest environment available.
      > Better tests for fstrings
      > With the changes in parso, f-strings are now completable
      > With the changes in parso, f-strings are now completable
      > Fix lambda dynamic param searches, fixes #1070
      > Cleanup the namespace lookups so that it also works for Python 3.7
      > Add a note about the fixed Windows tests in the changelog
      > Add micbou to AUTHORS
      > Add a badge for AppVeyor. Running tests for Windows
      > Add comment explaining why test_versions is disabled on Windows
      > Add JEDI_TEST_ENVIRONMENT_EXECUTABLE for AppVeyor
      > Add AppVeyor configuration
      > Improve venv_and_pths test
      > Properly raise broken pipe exception
      > Remove SourceLair from products, because it's a paid product
      > Add a note to the readme.
      > Fix another windows issue
      > Merge branch 'master' of github.com:davidhalter/jedi
      > Merge the windows fixes
      > Some code cleanup
      > Fix another error that surfaced in pandas
      > Fix an issue with docstrings that contain errors
      > Upgrade the wx widgets paths
      > Somehow forgot about subscriptlist. Just ignore those for now.
      > Fix the first issue in #1010
      > colorama should always color, even if it's not a shell
      > os.path.join completion speed test is sometimes slow, so give it a bit more of time
      > Fix some code_lines issues
      > Remove stdout/stderr from subprocesses (redirected to /dev/null)
      > Add the module_path again
      > Clean up the namedtuple test for #1060
      > All modules now have a code_lines attribute, see #1062
      > The release date for 0.12.0 should not be set, yet. See #1061.
      > And now remove a pep0484 function that is no longer needed
      > Some more code to a function
      > More rewriting of the pep0484 logic
      > Start moving some of the pep0484 comment code around
      > Cleanup some instance stuff
      > Better docs for funciton annotations
      > Fix an error in param comments
      > Catch parser errors instead of error recovery when splitting param comments
      > Merge branch 'function_comment' of https://github.com/wilfred/jedi into mypy-comments
      > Fix a few version issues in tests
      > Use inspect.Parameter.kind for better differentiation between param types
      > Fix REPL completion param name completion
      > Add keyword argument test for #292
      > Fix an interpreter test in Python 2
      > Clean up zombie subprocesses, fixes #1048
      > Fix an issue around __dir__ in the interpreter
      > Fix doctest for replstartup
      > Fix shell completion issues and documentation
      > Merge branch 'master' of github.com:davidhalter/jedi
      > Fix issues with default parameters in functions and classes
      > Correct mistakes of lambda names
      > eval_element -> eval_node
      > Use the correct class for params when used in names. Fixes #1006
      > Get rid of a regex warning, where escaping was not properly used in a normal string
      > Get rid of the imp library import in Python3 to avoid warnings, fixes #1001
      > Don't need the tests from #122
      > Refactor the namespace package tests
      > Add a failing test for nested PEP420 namespace packages
      > Include __init__.py files in search for the project directory, fixes #773
      > Add pytest cache to gitignore
      > Improve some documentation/a failing doctest
      > Fix the recursion error with globals
      > Always pop nodes in recursion detector
      > Globals should be looked up with the same priority as other defined nodes.
      > fix set.append syntax error
      > Add a few bits to the changelog
      > Autocompletion in comments should at least not fail
      > Fix the last async issue
      > Fix a few numpydocs tests
      > Fix some more await things
      > Fix a yield from test
      > AbstractIterableMixin -> IterableMixin
      > Support generator returns when used with yield from.
      > Show in a test that something doesn't work properly around async analysis
      > A few documentation improvements
      > Try to make the whole Builtin overwriting more abstract
      > Fix a small remaining issue in Python 2
      > Reorder tests to make the async stuff pass on all python versions
      > Fix for all python versions
      > Getting more edget cases work in 3.6 for async
      > Fix an issue with async for
      > Use the await method properly and just use it instead of some crazy things
      > Refactor the way builtins can be overwritten by jedi's own contexts
      > Move all the asynchronous contexts to a separate module
      > Fix the merge issues. Now async stuff should at least partially work
      > Merge the async branch
      > Get rid of an unused import
      > Add the name always to the script module
      > Add the travere_parents function to a utility directory
      > Fix Python 2 old-school relative imports
      > Use the project path as a prefix, because many times it's used as a higher priority than other stuff
      > Move the buildout_project stuff to a separate examples folder
      > Rename of buildout stuff
      > Small rename
      > Use generators instead of complicated return of lists
      > Some more sys path corrections.
      > Generalize the use of smart import paths
      > Better handling of smart sys path
      > Some simplifications
      > Add comments to implicit namespaces and fix some minor things.
      > Merge the implicit namespace improvement (pkgutils.itermodules modification)
      > Relative imports should be working again even when used in more special occasions. Fixes #973
      > parent_module is not needed for loading modules
      > Try to avoid CachedMetaClass for modules
      > DOn't check the parser cache, that's parso's responsibility
      > Better module loading
      > Try to put all module loading in one place including namespace packages
      > Unify load_module access
      > Prepare a test to eventually solve a relative import problem
      > Add a module cache that has a bit more capabilites
      > print_to_stderr needs to be used with one argument
      > Print errors that happen when importing certain objects
      > Use unicode literals, to avoid potential issues
      > Merge branch 'master' of github.com:davidhalter/jedi
      > Fix some more dict.get/dict.values stuff
      > Implememnt dict.values for FakeDict to avoid a recursion error. Fixes #1014.
      > Add better error reporting
      > Use a better string
      > Add better debugging for an assert, see also #1010
      > Make some things clearer about lazy contexts
      > Finding the autocompletion stack is a bit more complicated than I initially thought
      > Move the ahead of time tests to the pep0526 file
      > Fix an issue where a default value was wrongly used
      > Update the ahead of time tests
      > Fix the last remaining issues with ahead of time annotations, see #982
      > Fix a bug related to a wrong parametrization at one point
      > Merge branch 'master' of https://github.com/johannesmik/jedi
      > Force unicode on django paths
      > Forgot to add the examples folder
      > Fix a goto_assignments issue with a better internal API
      > Merge remote-tracking branch 'origin/master' into virtualenv
      > Disable predefined name analysis (if stmts) for all non-analysis tasks
      > Remove something that obviously never happened
      > Reorder some open flags for Python 2
      > inspect.signature throws weird errors sometimes, just make it a bit simpler
      > Fix the implicit namespace test
      > Undo most of the namespace changes and use module again
      > Differentiate between namespace and module as a type
      > Use Scripts for virtualenvs instead of bin for windows
      > Refactor django path support
      > Fix project path finding
      > Add a repr for Project
      > Use the PathFinder, because the FileFinder doesn't work without suffixes
      > Create the importer stuff Python2.7 and 3.3
      > Trying to use the import machinery to import jedi/parso in python3.4+
      > Better reporting of internal errors
      > Better error handling for subprocesses
      > Another merge with master
      > Get rid of a cwd to tmpdir, because with the subprocess it doesn't behave the same depending on which tests you run first
      > Hopefully the last merge with master
      > Merge with master again
      > Merge with master
      > Get rid of some potential issues when using pandas interactively
      > Clarity
      > Remove the get_default_project caching
      > Add a comment about why the project is None in the subprocess
      > evaluate.project doesn't exist anymore. Eliminated code that used it
      > At the moment, don't allow projects as an input to script
      > Remove the old project
      > Make the new project API fully work in tests
      > Try to migrate to the new project API
      > Refactor to make configuratios of sys paths easier
      > Use the evaluate.project sys path stuff for api.project
      > Cache the default project
      > A possible introduction for projects
      > Check for safe and unsafe environments when searching for them
      > Sith still used NotFoundError which doesn't exist anymore in jedi
      > Ignore pypy in travis for now
      > A path to ignore in coveragerc was wrong
      > Allowing the cov tests did not properly work. Trying again.
      > Somehow previously removed the allowed failurs of TOXENV=cov
      > Try to put env variables on one line
      > Coverage was unfortunately excluded
      > Merge with master
      > Add a comment to refactoring that it's not in active development
      > Change coveragerc a bit
      > Use Python3.4 for coverage.
      > Correct the issue about has_zlib
      > Move the zip tests to the environment
      > Only execute the zipimport tests fully if zlib is available for the environment Python.
      > Some tests that involved jedi were actually a bit wrong and only worked in certain environments.
      > Skip some 3.3 tests for travis
      > Skipping was done wrong
      > Try a bit more if modifying the PATH is now possible.
      > A comparison was wrong
      > A new version of the travis install script
      > Try to use the virtual env that was defined in the VIRTUAL_ENV variable, if possible.
      > If a subprocess gets killed by an OOM killer or whatever it should respawn and raise an InternalError
      > Merge Subprocess and CompiledSubprocess
      > Try to recover from errors that are happening in subprocesses
      > Move the default environment around
      > More travis trying
      > Better debugging for travis
      > Forgot to add the executable bit to the travis installer.
      > Experiment with travis and installing packages differently
      > The tags should be annotated if possible
      > Remove 2.6 from travis
      > Correct the travis file
      > Some refactoring to finally get tests working with py27 and 3 environments
      > Use the parser to check for certain namedtuple features
      > Use unicode strings in test to pass some tests in Python 2
      > Use Script everywhere where cwd_at is used, otherwise Python 2.7 is annoying
      > The given sys_path gets converted to unicode now in py2
      > Try to avoid the pth tests not working because of the created virtualenv in tox
      > Test if virtualenvs and pth files work
      > Move the module name searching to the subprocess
      > Move the last test out of test_regressions and delete the file
      > Move most of the regression tests into other test files
      > Cleanup test_regression tests
      > Move test_integration_keywrod to test_api/test_keyword
      > Cleanup the docstring tests
      > More test_evaluate Script fixtures
      > stdlib fixture conversions
      > More Script fixture conversions in test_evaluate
      > Migrate parso integration to script fixture
      > Use Script in more places
      > Use the Script fixture more generally
      > Differentiate between different Python versions in a specific test
      > Start replacing Script calls with a fixture
      > Monkeypatch the Unpickler in Python3.3
      > Try to pass the environment variable for JEDI_TEST_ENVIRONMENT to pytest over tox
      > Correct the two last unicode issues
      > Some repr went crazy
      > Make it more clear for debugging where dynamic search ended
      > Fix pep0484 comments
      > Better display of descriptors
      > Remove some of the last py27 errors that were caused in combination with 3.6
      > Forgot to cast a map to a list
      > Fixing more py27 stuff
      > More unicode literals
      > Use force_unicode for all sys paths
      > Add a print_to_stderr function in compatibility
      > Some more small improvements for Python 2
      > There were a few bugs in the previous commit
      > Use unicode in way more cases
      > Use unicode always for getting special objects
      > Skip the correct tests
      > Always use the parser of the environment
      > Try to test on travis with different jedi test environment variables
      > Try adding more automated tests to travis
      > Fix potential issues with py2 analysis
      > Check for bytes and unicode in dicts for Python 2
      > Eliminate is_py3 usages
      > Don't use python_version directly on evaluator anymore
      > Use unicode always in getattr
      > Fix an issue with the new behavior of special methods
      > Fix some more py36 to py27 issues
      > Refactor some things regarding Python 2 support
      > Also don't cast do a string for other names
      > Casting to str is not necessary
      > Skip tests according to the current environment
      > Remove unused keyword code
      > Do more comparisons in the subprocess
      > Use unicode in compiled access
      > Remove unused code
      > Refactor allowed_getattr_callback a bit to not raise random errors.
      > The default of one function was not actually used
      > The string_name of a Name should always be unicode
      > Refactor a bit and force unicode in some places and use an appropriate function name for it
      > Fix a test fail because of the unicode changes
      > The environment selection had a bug
      > More unicode conversions
      > Don't use getattr, use the abstractions
      > More unicode conversions
      > Avoid execution of Jedi in test setup
      > Start using a lot more unicode literals for Python 2
      > Make it possible to explicitly state the version in pytest for different envs
      > Use unicode sys paths always
      > Don't cast bytes to strings when unpickling
      > By default enable cross Python version tests in tox
      > Skip more tests if it's necessary.
      > Move the import logic to the subprocess
      > Move even more import stuff to a separate function
      > Move some import parts around to refactor it
      > Make ImplicitNamespaceContext a bit cleaner
      > Change two tests that were written in a strange way
      > Add a way to skip typing tests in non default environments
      > Use better error messages for import errors
      > Start using the new virtualenv code
      > Start using the correct parser for each environment
      > Add a way to specify environments in tox
      > Fix sys_path propagation for builtins load_module
      > A small refactoring
      > Merge branch 'master' into virtualenv
      > evaluate/docstrings.py
      > Don't import numpydoc in the beginning
      > Ignore the build directory for pytest
      > Refactor environments a bit
      > Make it possible to get the right version parser for a certain environment
      > api.virtualenv -> api.environment
      > DefaultEnvironment -> get_default_environment
      > Better support for searching python environments
      > Add an optimization around compiled dir()
      > Fix a potential issue in evaluate/stdlib
      > Cache the subprocess results
      > Remove unit test class from speed tests
      > Make get_repr static in access.
      > There was a bug in creating modules in a subprocess
      > Fix the Python 2.7 tests
      > Don't try to pickle ellipsis
      > Ignore __main__ modules
      > Use builtins_module instead of BUILTINS
      > Don't use the pickler modification anymore. That doesn't work in other python versions and was in general a bit hard to do
      > Remove the last test failures.
      > Get the subprocess mostly working
      > Don't use the create function anymore in compiled
      > Use even more subprocess accesses
      > Use the subprocess access to create acceses
      > Use access handles everywhere
      > Create a way of accessing access objects through a subprocess
      > Use a class instead of a dict in get_special_objects
      > Move get_special_object
      > Move load_module a bit around
      > Move another usage of create to builtin_from_name
      > Use sys.modules instead of __import__
      > Remove unused code
      > Start creating access objects in a different way
      > Use create_simple_object for a lot of use cases
      > Move some of the compiled.create calls to compiled.builtin_from_name
      > Move some stuff from compiled to context
      > Remove stuff from CompiledObject that didn't belong there and wasn't used
      > create_from_access -> _create_from_access
      > Refactor a bit more and remove the parent_context parameter from create_from_access
      > Isolate fake stuff a bit more
      > Simplify an if
      > Rewrite bases
      > Use create only for non access objects
      > Some simplification of _create_from_access
      > Remove the old now unused fake code
      > Fake context python code is now not the base for a lot of things anymore. It just gets executed.
      > Rename SelfNameFilter to SelfAttributeFilter
      > Simplify one if statement
      > Refactor LazyInstanceName -> SelfName
      > Fix all tests except fake docstring stuff
      > Fix a slice test with a better helper function
      > Fix a few more tests
      > Creating objects works now a bit better but is a huge mess.
      > Get a lot of tests passing
      > Make params work with access
      > Add an access abstraction (only array tests work, yet)
      > The check if we should add type completions is now a bit more obvious
      > Eliminate CompiledObject.type
      > Make some faked things private
      > Cleanup some compiled stuff.
      > Progress in executing builtin stuff in submodules.
      > Exceptions now also work over the subprocess.
      > Finally got compiled_objects and the access to them working
      > Progress when working with evaluators
      > Make the subprocesses work and return the right sys paths for the different versions
      > Make it possible to connect to a subprocess to get the sys path
      > Subprocess progress
      > Use types instead of special objects (see also #988)
      > Some subprocess progress
      > virtualenv progress
2018-04-17 23:42:11 +02:00
Daniel Hahler
24a0369d0f Update submodule pythonx/parso 2ca629a...579146b
* pythonx/parso 2ca629a...579146b (22):
      > Don't test python 2.6 in tox by default, because the newer pip versions don't support it anymore
      > Set a release date
      > Fix whitespace issues with prefixes
      > Use proper leafs for fstring start/end
      > Fix a Python 2 related issue.
      > Forgot to delete another print. WTF I'm tired
      > Unfortunately forgot to delete a print
      > Start to write a changelog for 0.2.0
      > Merge branch 'fstrings'
      > A comparison was slightly off
      > Ignore the pytest cache
      > Fix an error message change in Python 3.7
      > Fix an issue in the diff parser about endmarker newlines
      > Remove the copyright for good
      > Remove copyright years from documentation. (Closes: #25)
      > Fix typo: containes→contains
      > tox: use older pytest only for py26/py33
      > Merge branch 'master' of github.com:davidhalter/parso
      > Don't use a newer pytest version
      > The tags should be annotated if possible
      > Bump version for the next release
      > Use 3.7-dev not 3.7 for travis
2018-04-17 23:42:11 +02:00
Daniel Hahler
d430570fd0 pythonx/jedi_vim: flake8 fixes 2018-04-17 23:26:22 +02:00
Daniel Hahler
79c6172be7 Update .gitignore
- add build/ (used in Makefile)
- use .pytest-cache instead of .cache for newer pytest
2018-04-17 23:25:48 +02:00
30 changed files with 913 additions and 496 deletions

7
.coveragerc Normal file
View File

@@ -0,0 +1,7 @@
[run]
branch = 1
# Used by/for neovim-python-client.
concurrency = greenlet
[report]
include = pythonx/jedi_*.py,test/*

4
.gitignore vendored
View File

@@ -3,4 +3,6 @@
*.py[cod]
.ropeproject
doc/tags
.cache
.pytest-cache
build
.coverage*

View File

@@ -1,15 +1,34 @@
sudo: false
dist: xenial
language: python
python: 3.6
python: 3.7
env:
matrix:
- ENV=test
- ENV=check
- ENV=test_coverage
matrix:
include:
- env: ENV=test_coverage
python: 2.7
install:
- |
if [ "$ENV" = "test" ]; then
python3.6 -m pip install pytest
pip install pytest
elif [ "$ENV" = "test_coverage" ]; then
sudo add-apt-repository ppa:neovim-ppa/stable -y
sudo apt-get update -q
sudo apt-get install neovim -y
pip install pynvim pytest-cov
else
vim --version
fi
script:
- vim --version
- make "$ENV"
- make --keep-going "$ENV" BUILD_VIRTUAL_ENV=$VIRTUAL_ENV
after_success:
- |
if [ "$ENV" = "test_coverage" ]; then
coverage xml
bash <(curl -s https://codecov.io/bash) -X gcov -X coveragepy -X fix -X search -X xcode -f coverage.xml -F py${TRAVIS_PYTHON_VERSION//./}
fi

View File

@@ -51,5 +51,7 @@ Bagrat Aznauryan (@n9code)
Tomoyuki Kashiro (@kashiro)
Tommy Allen (@tweekmonster)
Mingliang (@Aulddays)
Brian Mego (@brianmego)
Stevan Milic (@stevanmilic) <stevan.milic@yahoo.com>
@something are github user names.

View File

@@ -1,16 +1,35 @@
test:
py.test
BUILD_VIRTUAL_ENV:=build/venv
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)
test:
pytest
test_nvim:
VSPEC_VIM=nvim pytest
test_coverage: export PYTEST_ADDOPTS:=--cov pythonx --cov test --cov-report=term-missing:skip-covered
test_coverage: test_nvim
$(dir $(BUILD_VIRTUAL_ENV)):
mkdir -p $@
$(BUILD_VIRTUAL_ENV): | $(dir $(BUILD_VIRTUAL_ENV))
python -m venv $@
$(BUILD_VIRTUAL_ENV)/bin/vint: | $(BUILD_VIRTUAL_ENV)
$|/bin/python -m pip install vim-vint==0.3.19
$(BUILD_VIRTUAL_ENV)/bin/flake8: | $(BUILD_VIRTUAL_ENV)
$|/bin/python -m pip install -q flake8==3.5.0
vint: $(BUILD_VIRTUAL_ENV)/bin/vint
$(BUILD_VIRTUAL_ENV)/bin/vint after autoload ftplugin plugin
flake8: $(BUILD_VIRTUAL_ENV)/bin/flake8
$(BUILD_VIRTUAL_ENV)/bin/flake8 pythonx/jedi_*.py
check: vint flake8
clean:
rm -rf .cache build
rm -rf build
.PHONY: test check clean
.PHONY: test check clean vint flake8

View File

@@ -1,3 +1,5 @@
.. image:: https://github.com/davidhalter/jedi-vim/blob/master/doc/logotype-a.svg
#################################################
jedi-vim - awesome Python autocompletion with VIM
#################################################
@@ -70,9 +72,8 @@ 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
You need a VIM version that was compiled with Python 2.7 or later
(``+python`` or ``+python3``). You can check this from within VIM using
``:python3 import sys; print(sys.version)`` (use ``:python`` for Python 2).
Manual installation
@@ -81,9 +82,8 @@ Manual installation
You might want to use `pathogen <https://github.com/tpope/vim-pathogen>`_ or
`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 install it via ``pip install jedi`` or with
``git submodule update --init`` in your jedi-vim repository.
The first thing you need after that is an up-to-date version of Jedi. Install
``git submodule update --init --recursive`` in your jedi-vim repository.
Example installation command using Pathogen:
@@ -99,6 +99,9 @@ Add the following line in your `~/.vimrc`
Plugin 'davidhalter/jedi-vim'
For installing Jedi, ``pip install jedi`` will also work, but you might run
into issues when working in virtual environments. Please use git submodules.
Installation with your distribution
-----------------------------------

View File

@@ -26,7 +26,9 @@ if g:jedi#show_call_signatures > 0 && has('conceal')
hi def link jediFunction CursorLine
hi def link jediFat TabLine
else
hi jediFunction term=NONE cterm=NONE ctermfg=6 guifg=Black gui=NONE ctermbg=0 guibg=Grey
hi jediFat term=bold,underline cterm=bold,underline gui=bold,underline ctermbg=0 guibg=#555555
hi def jediFunction term=NONE cterm=NONE ctermfg=6 guifg=Black gui=NONE ctermbg=0 guibg=Grey
hi def jediFat term=bold,underline cterm=bold,underline gui=bold,underline ctermbg=0 guibg=#555555
endif
endif
hi def jediUsage cterm=reverse gui=standout

View File

@@ -19,6 +19,7 @@ let s:default_settings = {
\ 'goto_command': "'<leader>d'",
\ 'goto_assignments_command': "'<leader>g'",
\ 'goto_definitions_command': "''",
\ 'goto_stubs_command': "'<leader>s'",
\ 'completions_command': "'<C-Space>'",
\ 'call_signatures_command': "'<leader>n'",
\ 'usages_command': "'<leader>n'",
@@ -34,7 +35,7 @@ let s:default_settings = {
\ 'popup_select_first': 1,
\ 'quickfix_window_height': 10,
\ 'force_py_version': "'auto'",
\ 'smart_auto_mappings': 1,
\ 'smart_auto_mappings': 0,
\ 'use_tag_stack': 1
\ }
@@ -57,80 +58,82 @@ endfor
" ------------------------------------------------------------------------
let s:script_path = fnameescape(expand('<sfile>:p:h:h'))
" Initialize Python (PythonJedi command).
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)
" Use g:jedi#force_py_version for loading Jedi, or fall back to using
" `has()` - preferring Python 3.
let loader_version = get(g:, 'jedi#loader_py_version', g:jedi#force_py_version)
if loader_version ==# 'auto'
if has('python3')
let loader_version = 3
elseif has('python')
let loader_version = 2
else
throw 'jedi-vim requires Vim with support for Python 2 or 3.'
endif
else
if loader_version =~# '^3'
let loader_version = 3
elseif loader_version =~# '^2'
let loader_version = 2
else
if !exists('g:jedi#squelch_py_warning')
echohl WarningMsg
echom printf("jedi-vim: could not determine Python loader version from 'g:jedi#loader_py_version/g:jedi#force_py_version' (%s), using 3.",
\ loader_version)
echohl None
endif
let loader_version = 3
endif
endif
call jedi#setup_python_imports(loader_version)
return 1
endfunction
function! jedi#reinit_python() abort
unlet! s:_init_python
let s:_init_python = -1
call jedi#init_python()
endfunction
" This is meant to be called with `:unsilent` (for &shortmess+=F).
function! s:display_exception() abort
let error_lines = split(v:exception, '\n')
let msg = 'Error: jedi-vim failed to initialize Python: '
\ .error_lines[0].' (in '.v:throwpoint.')'
if len(error_lines) > 1
echohl ErrorMsg
echom 'jedi-vim error: '.error_lines[0]
for line in error_lines[1:]
echom line
endfor
echohl None
let help_cmd = ':JediDebugInfo'
if exists(':checkhealth') == 2
let help_cmd .= ' / :checkhealth'
endif
let msg .= printf('. See :messages and/or %s for more information.',
\ help_cmd)
endif
redraw " Redraw to only have the main message by default.
echoerr msg
endfunction
let s:_init_python = -1
function! jedi#init_python() abort
if s:_init_python == -1
let s:_init_python = 0
try
let s:_init_python = s:init_python()
catch
let s:_init_python = 0
let s:_init_python = 1
catch /^jedi/
" Only catch errors from jedi-vim itself here, so that for
" unexpected Python exceptions the traceback will be shown
" (e.g. with NameError in jedi#setup_python_imports's code).
if !exists('g:jedi#squelch_py_warning')
echoerr 'Error: jedi-vim failed to initialize Python: '
\ .v:exception.' (in '.v:throwpoint.')'
unsilent call s:display_exception()
endif
endtry
endif
@@ -139,7 +142,7 @@ endfunction
let s:python_version = 'null'
function! jedi#setup_py_version(py_version) abort
function! jedi#setup_python_imports(py_version) abort
if a:py_version == 2
let cmd_exec = 'python'
let s:python_version = 2
@@ -147,70 +150,68 @@ function! jedi#setup_py_version(py_version) abort
let cmd_exec = 'python3'
let s:python_version = 3
else
throw 'jedi#setup_py_version: invalid py_version: '.a:py_version
throw 'jedi#setup_python_imports: invalid py_version: '.a:py_version
endif
execute 'command! -nargs=1 PythonJedi '.cmd_exec.' <args>'
let s:init_outcome = 0
let g:_jedi_init_error = 0
let init_lines = [
\ 'import vim',
\ 'try:',
\ ' import jedi_vim',
\ ' if hasattr(jedi_vim, "jedi_import_error"):',
\ ' from jedi_vim_debug import format_exc_info',
\ ' vim.vars["_jedi_init_error"] = format_exc_info(jedi_vim.jedi_import_error)',
\ '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
\ ' from jedi_vim_debug import format_exc_info',
\ ' vim.vars["_jedi_init_error"] = format_exc_info()',
\ ]
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)
if g:_jedi_init_error isnot 0
throw printf('jedi#setup_python_imports: %s', g:_jedi_init_error)
endif
return 1
endfunction
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
echo "\n"
echo '##### jedi-vim version'
echo "\n"
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 pythonx/jedi'), '\v\n$', '', '')
echo ' - parso git submodule status: '
echon substitute(system('git -C '.s:script_path.' submodule status pythonx/parso'), '\v\n$', '', '')
echo "\n"
echo '##### Global Python'
echo "\n"
echo 'Using Python version '.s:python_version.' to access Jedi.'
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.'
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 "\n"
echo '```'
let jedi_settings = items(filter(copy(g:), "v:key =~# '\\v^jedi#'"))
let has_nondefault_settings = 0
@@ -252,23 +253,6 @@ function! jedi#debug_info() abort
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) abort
@@ -304,8 +288,21 @@ function! jedi#goto_definitions() abort
PythonJedi jedi_vim.goto(mode="definition")
endfunction
function! jedi#goto_stubs() abort
PythonJedi jedi_vim.goto(mode="stubs")
endfunction
function! jedi#usages() abort
PythonJedi jedi_vim.goto(mode="related_name")
call jedi#remove_usages()
PythonJedi jedi_vim.usages()
endfunction
function! jedi#remove_usages() abort
for match in getmatches()
if stridx(match['group'], 'jediUsage') == 0
call matchdelete(match['id'])
endif
endfor
endfunction
function! jedi#rename(...) abort
@@ -341,9 +338,10 @@ function! jedi#py_import_completions(argl, cmdl, pos) abort
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()
PythonJedi jedi_vim.jedi.cache.clear_time_caches(True)
else
PythonJedi jedi_vim.jedi.cache.clear_time_caches(False)
endif
endfunction
@@ -385,7 +383,9 @@ function! jedi#show_documentation() abort
" quit comands
nnoremap <buffer> q ZQ
if len(g:jedi#documentation_command)
execute 'nnoremap <buffer> '.g:jedi#documentation_command.' ZQ'
endif
endfunction
" ------------------------------------------------------------------------

View File

@@ -1,75 +0,0 @@
import os
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-1.4.1')
VSPEC_RUNNER = os.path.join(VSPEC_FOLDER, 'bin/vspec')
TEST_DIR = 'test'
class IntegrationTestFile(object):
def __init__(self, path):
self.path = path
def run(self):
output = subprocess.check_output(
[VSPEC_RUNNER, '.', VSPEC_FOLDER, self.path])
had_ok = False
for line in output.splitlines():
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)
def pytest_configure(config):
if not os.path.isdir(CACHE_FOLDER):
os.mkdir(CACHE_FOLDER)
if not os.path.exists(VSPEC_FOLDER):
name, hdrs = urllib.request.urlretrieve(VSPEC_URL)
z = zipfile.ZipFile(name)
for n in z.namelist():
dest = os.path.join(CACHE_FOLDER, n)
destdir = os.path.dirname(dest)
if not os.path.isdir(destdir):
os.makedirs(destdir)
data = z.read(n)
if not os.path.isdir(dest):
with open(dest, 'wb') as f:
f.write(data)
z.close()
os.chmod(VSPEC_RUNNER, 0o777)
def pytest_generate_tests(metafunc):
"""
:type metafunc: _pytest.python.Metafunc
"""
def collect_tests():
for f in os.listdir(TEST_DIR):
if f.endswith('.vim') and f != 'utils.vim':
yield IntegrationTestFile(os.path.join(TEST_DIR, f))
tests = list(collect_tests())
metafunc.parametrize('case', tests, ids=[test.name for test in tests])

View File

@@ -60,7 +60,7 @@ Jedi-vim is a Vim binding to the awesome Python autocompletion library
- Infers function arguments from Sphinx/Epydoc strings
- Doesn't execute Python code
- Supports Virtualenv
- Supports Python 2.5+ and 3.2+
- Supports Python 2.7 and 3.4+
By leveraging this library, jedi-vim adds the following capabilities to Vim:
@@ -78,15 +78,6 @@ By leveraging this library, jedi-vim adds the following capabilities to Vim:
First of all, jedi-vim requires Vim to be compiled with the `+python` option.
The jedi library has to be installed for jedi-vim to work properly. You can
install it first, by using e.g. your distribution's package manager, or by
using pip: >
pip install jedi
However, you can also install it as a git submodule if you don't want to use
jedi for anything but this plugin. How to do this is detailed below.
It is best if you have VIM >= 7.3, compiled with the `+conceal` option. With
older versions, you will probably not see the parameter recommendation list
for functions after typing the open bracket. Some platforms (including OS X
@@ -107,11 +98,7 @@ feature (such as MacVim on OS X, which also contains a console binary).
------------------------------------------------------------------------------
2.1. Installing manually *jedi-vim-installation-manually*
1a. Get the latest repository from Github: >
git clone http://github.com/davidhalter/jedi-vim path/to/bundles/jedi-vim
1b. If you want to install jedi as a submodule instead, issue this command: >
1. If you want to install jedi as a submodule instead, issue this command: >
git clone --recursive http://github.com/davidhalter/jedi-vim
@@ -161,8 +148,8 @@ repositories. On Arch Linux, install vim-jedi. On Debian (8+) or Ubuntu
==============================================================================
3. Supported Python features *jedi-vim-support*
The Jedi library does all the hard work behind the scenes. It supports
completion of a large number of Python features, among them:
The Jedi library does all the hard work behind the scenes. It understands most
Python features, among them:
- Builtins
- Multiple `return`s or `yield`s
@@ -185,10 +172,12 @@ completion of a large number of Python features, among them:
- Simple/usual `sys.path` modifications
- `isinstance` checks for `if`/`while`/`assert` case, that doesnt work with
Jedi
- Stubs
- And more...
Note: This list is not necessarily up to date. For a complete list of
features, please refer to the Jedi documentation at http://jedi.jedidjah.ch.
features, please refer to the Jedi documentation at
http://jedi.readthedocs.io.
==============================================================================
4. Usage *jedi-vim-usage*
@@ -308,7 +297,7 @@ Default: <leader>r Rename variables
Jedi-vim deletes the word currently under the cursor and puts Vim in insert
mode, where the user is expected to enter the new variable name. Upon leaving
insert mode, jedi-vim then renames all occurences of the old variable name
insert mode, jedi-vim then renames all occurrences of the old variable name
with the new one. The number of performed renames is displayed in the command
line.
@@ -439,10 +428,10 @@ Default: 500
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.
(0), they open in the current window instead.
Options: 0 or 1
Default: 0 (Command output is put in a new tab)
Default: 0 (Command output reuses current window)
------------------------------------------------------------------------------
6.9. `g:jedi#squelch_py_warning` *g:jedi#squelch_py_warning*
@@ -480,33 +469,32 @@ small a horizontal split happens.
------------------------------------------------------------------------------
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
will be used for every jedi call to the respective python interpreter.
The variable can be set in the .vimrc like this to force python 3:
If you have installed multiple Python versions, you can force the Python
version that is going to be used.
You don't have to compile VIM with multiple Python versions.
The variable can be set in the .vimrc like this to force python 2:
let g:jedi#force_py_version = 3
let g:jedi#force_py_version = 2
This variable can be switched during runtime using the following function:
Function: `jedi#force_py_version_switch()`
By default jedi loads the latest Python version installed on your system that
can be found.
or set directly using this function, which has the same name as the variable:
Function: `jedi#force_py_version(py_version)`
This variable can be changed during runtime.
Options: 2 or 3
Default: "auto" (will use sys.version_info from "python" in your $PATH)
Options: 2, 2.7, 3, 3.5, 3.6, ...
Default: "auto"
------------------------------------------------------------------------------
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.
can add the "import" statement and trigger the autocompletion popup.
This option can be disabled in the .vimrc:
`let g:jedi#smart_auto_mappings = 0`
You can enable this using: >
let g:jedi#smart_auto_mappings = 1
<
Options: 0 or 1
Default: 1 (enabled by default)
Default: 0 (disabled by default)
------------------------------------------------------------------------------
6.14. `g:jedi#use_tag_stack` *g:jedi#use_tag_stack*

140
doc/logotype-a.svg Normal file
View File

@@ -0,0 +1,140 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- Generator: Adobe Illustrator 15.1.0, SVG Export Plug-In . SVG Version: 6.00 Build 0) -->
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg version="1.1" id="Layer_2" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
width="897.845px" height="247.51px" viewBox="0 0 897.845 247.51" enable-background="new 0 0 897.845 247.51"
xml:space="preserve">
<g>
<g>
<linearGradient id="SVGID_1_" gradientUnits="userSpaceOnUse" x1="287.3965" y1="65.2686" x2="287.3965" y2="106.4546">
<stop offset="0" style="stop-color:#E27817"/>
<stop offset="0.3906" style="stop-color:#E47519"/>
<stop offset="0.7116" style="stop-color:#E96B1F"/>
<stop offset="1" style="stop-color:#F15A29"/>
</linearGradient>
<polygon fill="url(#SVGID_1_)" points="285.068,66.556 272.054,95.664 302.739,95.664 302.739,66.556 "/>
<linearGradient id="SVGID_2_" gradientUnits="userSpaceOnUse" x1="216.8877" y1="65.2686" x2="216.8877" y2="106.4546">
<stop offset="0" style="stop-color:#E27817"/>
<stop offset="0.3906" style="stop-color:#E47519"/>
<stop offset="0.7116" style="stop-color:#E96B1F"/>
<stop offset="1" style="stop-color:#F15A29"/>
</linearGradient>
<polygon fill="url(#SVGID_2_)" points="180.483,95.664 193.893,95.664 240.172,95.664 253.292,66.556 180.483,66.556 "/>
<g>
<polygon fill="#019733" points="256.464,59.293 253.603,65.696 253.593,65.696 253.197,66.592 240.172,95.7 215.738,150.321
199.788,185.978 231.676,185.978 231.676,185.969 272.071,95.7 275.634,87.737 285.089,66.592 288.355,59.293 "/>
</g>
<g>
<polygon fill="#019733" points="215.738,150.321 194.605,95.7 180.483,95.7 180.483,135.118 199.788,185.969 199.788,185.978
"/>
</g>
<path fill="#019733" d="M151.355,59.294v100.005h-28.989h-11.292v-7.972c3.644-4.232,6.749-9.936,6.749-16.218
c0-2.846-0.456-5.578-1.294-8.104h0.011l-4.274-12.151c-0.238-1.16-0.633-2.257-1.15-3.281v-0.032l-5.878-11.59
c-1.201-2.808-3.975-4.897-7.34-5.362c0.281-4.969,2.837-8.87,5.932-8.87l-3.137-1.004l3.137-3.033
c-5.01,0-9.098,5.775-9.388,13.021c-3.116,0.609-5.672,2.598-6.79,5.258l-5.723,11.271c-0.052,0.104-0.104,0.197-0.155,0.3v0.01
c-0.528,1.057-0.932,2.174-1.169,3.344l-4.232,12.079c-0.012,0.02-0.012,0.03-0.021,0.042c-0.828,2.525-1.294,5.258-1.294,8.104
c0,6.282,3.25,11.985,6.904,16.218v35.616h29.112h11.294h58.105V59.294H151.355z M86.554,117.834
c-0.673,2.019-2.442,3.252-3.954,2.744c-1.51-0.508-2.194-2.547-1.521-4.565c0.673-2.017,2.443-3.25,3.953-2.742
C86.544,113.777,87.228,115.817,86.554,117.834z M110.163,120.578c-1.51,0.508-3.27-0.726-3.954-2.744
c-0.672-2.017,0.011-4.057,1.521-4.563c1.512-0.508,3.282,0.726,3.955,2.742C112.357,118.031,111.674,120.07,110.163,120.578z"/>
<linearGradient id="SVGID_3_" gradientUnits="userSpaceOnUse" x1="134.6348" y1="65.2686" x2="134.6348" y2="106.4546">
<stop offset="0" style="stop-color:#E27817"/>
<stop offset="0.3906" style="stop-color:#E47519"/>
<stop offset="0.7116" style="stop-color:#E96B1F"/>
<stop offset="1" style="stop-color:#F15A29"/>
</linearGradient>
<polygon fill="url(#SVGID_3_)" points="151.292,66.556 117.914,66.556 117.914,95.664 145.981,95.664 151.292,95.664
151.355,95.664 151.355,66.592 151.292,66.592 "/>
<g opacity="0.5">
<linearGradient id="SVGID_4_" gradientUnits="userSpaceOnUse" x1="244.0713" y1="198.6924" x2="244.0713" y2="111.1674">
<stop offset="0" style="stop-color:#019733"/>
<stop offset="0.1363" style="stop-color:#0B732D;stop-opacity:0.8637"/>
<stop offset="0.2826" style="stop-color:#145529;stop-opacity:0.7174"/>
<stop offset="0.4366" style="stop-color:#1A3D25;stop-opacity:0.5634"/>
<stop offset="0.5997" style="stop-color:#1F2C22;stop-opacity:0.4003"/>
<stop offset="0.778" style="stop-color:#222221;stop-opacity:0.222"/>
<stop offset="1" style="stop-color:#231F20;stop-opacity:0"/>
</linearGradient>
<polygon fill="url(#SVGID_4_)" points="256.464,59.293 253.603,65.696 253.593,65.696 253.197,66.592 240.172,95.7
215.738,150.321 199.788,185.978 231.676,185.978 231.676,185.969 272.071,95.7 275.634,87.737 285.089,66.592 288.355,59.293
"/>
</g>
<linearGradient id="SVGID_5_" gradientUnits="userSpaceOnUse" x1="165.9131" y1="41.1123" x2="165.9131" y2="128.6277">
<stop offset="0" style="stop-color:#019733"/>
<stop offset="0.1363" style="stop-color:#0B732D;stop-opacity:0.8637"/>
<stop offset="0.2826" style="stop-color:#145529;stop-opacity:0.7174"/>
<stop offset="0.4366" style="stop-color:#1A3D25;stop-opacity:0.5634"/>
<stop offset="0.5997" style="stop-color:#1F2C22;stop-opacity:0.4003"/>
<stop offset="0.778" style="stop-color:#222221;stop-opacity:0.222"/>
<stop offset="1" style="stop-color:#231F20;stop-opacity:0"/>
</linearGradient>
<rect x="151.355" y="59.294" opacity="0.5" fill="url(#SVGID_5_)" width="29.116" height="127.649"/>
<g opacity="0.58">
<linearGradient id="SVGID_6_" gradientUnits="userSpaceOnUse" x1="198.1104" y1="83.4141" x2="198.1104" y2="154.2879">
<stop offset="0" style="stop-color:#019733"/>
<stop offset="0.0409" style="stop-color:#038E32;stop-opacity:0.9591"/>
<stop offset="0.2465" style="stop-color:#0F662B;stop-opacity:0.7535"/>
<stop offset="0.4491" style="stop-color:#184726;stop-opacity:0.5509"/>
<stop offset="0.6453" style="stop-color:#1E3123;stop-opacity:0.3547"/>
<stop offset="0.8322" style="stop-color:#222421;stop-opacity:0.1678"/>
<stop offset="1" style="stop-color:#231F20;stop-opacity:0"/>
</linearGradient>
<polygon fill="url(#SVGID_6_)" points="215.738,150.321 194.605,95.7 180.483,95.7 180.483,135.118 199.788,185.969
199.788,185.978 "/>
</g>
<linearGradient id="SVGID_7_" gradientUnits="userSpaceOnUse" x1="127.7627" y1="192.1367" x2="127.7627" y2="137.5901">
<stop offset="0" style="stop-color:#019733"/>
<stop offset="0.0409" style="stop-color:#038E32;stop-opacity:0.9591"/>
<stop offset="0.2465" style="stop-color:#0F662B;stop-opacity:0.7535"/>
<stop offset="0.4491" style="stop-color:#184726;stop-opacity:0.5509"/>
<stop offset="0.6453" style="stop-color:#1E3123;stop-opacity:0.3547"/>
<stop offset="0.8322" style="stop-color:#222421;stop-opacity:0.1678"/>
<stop offset="1" style="stop-color:#231F20;stop-opacity:0"/>
</linearGradient>
<path opacity="0.6" fill="url(#SVGID_7_)" d="M151.355,59.294v100.005h-28.989h-11.292v-7.972
c3.644-4.232,6.749-9.936,6.749-16.218c0-2.846-0.456-5.578-1.294-8.104h0.011l-4.274-12.151c-0.238-1.16-0.633-2.257-1.15-3.281
v-0.032l-5.878-11.59c-1.201-2.808-3.975-4.897-7.34-5.362c0.281-4.969,2.837-8.87,5.932-8.87l-3.137-1.004l3.137-3.033
c-5.01,0-9.098,5.775-9.388,13.021c-3.116,0.609-5.672,2.598-6.79,5.258l-5.723,11.271c-0.052,0.104-0.104,0.197-0.155,0.3v0.01
c-0.528,1.057-0.932,2.174-1.169,3.344l-4.232,12.079c-0.012,0.02-0.012,0.03-0.021,0.042c-0.828,2.525-1.294,5.258-1.294,8.104
c0,6.282,3.25,11.985,6.904,16.218v35.616h29.112h11.294h58.105V59.294H151.355z M86.554,117.834
c-0.673,2.019-2.442,3.252-3.954,2.744c-1.51-0.508-2.194-2.547-1.521-4.565c0.673-2.017,2.443-3.25,3.953-2.742
C86.544,113.777,87.228,115.817,86.554,117.834z M110.163,120.578c-1.51,0.508-3.27-0.726-3.954-2.744
c-0.672-2.017,0.011-4.057,1.521-4.563c1.512-0.508,3.282,0.726,3.955,2.742C112.357,118.031,111.674,120.07,110.163,120.578z"/>
<g opacity="0.5">
<linearGradient id="SVGID_8_" gradientUnits="userSpaceOnUse" x1="244.0713" y1="53.3584" x2="244.0713" y2="78.0277">
<stop offset="0" style="stop-color:#019733"/>
<stop offset="0.1363" style="stop-color:#0B732D;stop-opacity:0.8637"/>
<stop offset="0.2826" style="stop-color:#145529;stop-opacity:0.7174"/>
<stop offset="0.4366" style="stop-color:#1A3D25;stop-opacity:0.5634"/>
<stop offset="0.5997" style="stop-color:#1F2C22;stop-opacity:0.4003"/>
<stop offset="0.778" style="stop-color:#222221;stop-opacity:0.222"/>
<stop offset="1" style="stop-color:#231F20;stop-opacity:0"/>
</linearGradient>
<polygon fill="url(#SVGID_8_)" points="256.464,59.293 253.603,65.696 253.593,65.696 253.197,66.592 240.172,95.7
215.738,150.321 199.788,185.978 231.676,185.978 231.676,185.969 272.071,95.7 275.634,87.737 285.089,66.592 288.355,59.293
"/>
</g>
<polygon fill="#019733" points="180.483,59.198 183.329,66.556 180.471,66.556 "/>
<polygon fill="#019733" points="180.483,59.198 183.329,66.556 180.471,66.556 "/>
<g>
<polygon fill="#019733" points="290.713,66.592 285.054,66.592 288.32,59.293 "/>
<polygon fill="#019733" points="308.417,120.554 283.562,95.7 300.261,95.7 "/>
<polygon opacity="0.6" fill="#019733" points="308.417,120.554 283.562,95.7 300.261,95.7 "/>
<polygon fill="#019733" points="290.713,66.592 285.054,66.592 288.32,59.293 "/>
</g>
</g>
<g>
<path fill="#666666" d="M358.849,130.077v23.827h28.81V77.887h16.547v91.732h-62.987v-39.542H358.849z"/>
<path fill="#666666" d="M434.61,93.602v22.677h45.356v14.949H434.61v22.677h45.356v15.715h-62.987V77.887h62.987v15.715H434.61z"
/>
<path fill="#666666" d="M492.744,169.619V77.887h56.342l6.643,8.05v75.634l-6.579,8.049H492.744z M539.184,93.602h-28.811v60.303
h28.811V93.602z"/>
<path fill="#666666" d="M586.136,169.619h-17.632V77.887h17.632V169.619z"/>
<path fill="#666666" d="M598.913,116.278h33.281v14.949h-33.281V116.278z"/>
<path fill="#666666" d="M691.412,77.887h16.544l-19.995,91.732h-21.462l-21.527-91.732h17.63l13.798,70.588L691.412,77.887z"/>
<path fill="#666666" d="M738.364,169.619h-17.631V77.887h17.631V169.619z"/>
<path fill="#666666" d="M768.77,169.619h-17.632V77.887h17.632l17.886,50.273l18.59-50.273h16.545v91.732h-16.545v-38.392
l-12.84,38.392h-10.35l-13.286-38.392V169.619z"/>
</g>
</g>
</svg>

After

Width:  |  Height:  |  Size: 9.8 KiB

View File

@@ -16,6 +16,9 @@ if g:jedi#auto_initialization
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#goto_stubs_command)
execute 'nnoremap <buffer> '.g:jedi#goto_stubs_command.' :call jedi#goto_stubs()<CR>'
endif
if len(g:jedi#usages_command)
execute 'nnoremap <buffer> '.g:jedi#usages_command.' :call jedi#usages()<CR>'
endif
@@ -47,4 +50,8 @@ if g:jedi#auto_initialization
autocmd! InsertLeave <buffer> if pumvisible() == 0|pclose|endif
augroup END
endif
augroup jedi_usages
autocmd! TextChanged <buffer> call jedi#remove_usages()
autocmd! InsertEnter <buffer> call jedi#remove_usages()
augroup END
endif

View File

@@ -15,6 +15,11 @@ if get(g:, 'jedi#auto_vim_configuration', 1)
" jedi-vim really needs, otherwise jedi-vim cannot start.
filetype plugin on
augroup jedi_pyi
au!
autocmd BufNewFile,BufRead *.pyi set filetype=python
augroup END
" 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
@@ -48,7 +53,21 @@ 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()
function! s:jedi_debug_info()
" Ensure the autoload file has been loaded (and ignore any errors, which
" will be displayed with the debug info).
let unset = {}
let saved_squelch_py_warning = get(g:, 'jedi#squelch_py_warning', unset)
let g:jedi#squelch_py_warning = 1
call jedi#init_python()
if saved_squelch_py_warning is unset
unlet g:jedi#squelch_py_warning
else
let g:jedi#squelch_py_warning = saved_squelch_py_warning
endif
call jedi#debug_info()
endfunction
command! -nargs=0 -bar JediDebugInfo call s:jedi_debug_info()
command! -nargs=0 -bang JediClearCache call jedi#clear_cache(<bang>0)
" vim: set et ts=4:

View File

@@ -1,3 +0,0 @@
[pytest]
# Ignore all files
norecursedirs = *

View File

@@ -25,6 +25,16 @@ else:
ELLIPSIS = u""
try:
# Somehow sys.prefix is set in combination with VIM and virtualenvs.
# However the sys path is not affected. Just reset it to the normal value.
sys.prefix = sys.base_prefix
sys.exec_prefix = sys.base_exec_prefix
except AttributeError:
# If we're not in a virtualenv we don't care. Everything is fine.
pass
class PythonToVimStr(unicode):
""" Vim has a different string implementation of single quotes """
__slots__ = []
@@ -73,11 +83,11 @@ def _catch_exception(string, is_eval):
def vim_command(string):
_catch_exception(string, False)
_catch_exception(string, is_eval=False)
def vim_eval(string):
return _catch_exception(string, True)
return _catch_exception(string, is_eval=True)
def no_jedi_warning(error=None):
@@ -100,10 +110,9 @@ sys.path.insert(0, parso_path)
try:
import jedi
except ImportError as e:
no_jedi_warning(str(e))
except ImportError:
jedi = None
jedi_import_error = str(e)
jedi_import_error = sys.exc_info()
else:
try:
version = jedi.__version__
@@ -148,18 +157,68 @@ def _check_jedi_availability(show_error=False):
return func_receiver
current_environment = (None, None)
def get_environment(use_cache=True):
global current_environment
vim_force_python_version = vim_eval("g:jedi#force_py_version")
if use_cache and vim_force_python_version == current_environment[0]:
return current_environment[1]
environment = None
if vim_force_python_version == "auto":
environment = jedi.api.environment.get_cached_default_environment()
else:
force_python_version = vim_force_python_version
if '0000' in force_python_version or '9999' in force_python_version:
# It's probably a float that wasn't shortened.
try:
force_python_version = "{:.1f}".format(float(force_python_version))
except ValueError:
pass
elif isinstance(force_python_version, float):
force_python_version = "{:.1f}".format(force_python_version)
try:
environment = jedi.get_system_environment(force_python_version)
except jedi.InvalidPythonEnvironment as exc:
environment = jedi.api.environment.get_cached_default_environment()
echo_highlight(
"force_python_version=%s is not supported: %s - using %s." % (
vim_force_python_version, str(exc), str(environment)))
current_environment = (vim_force_python_version, environment)
return environment
def get_known_environments():
"""Get known Jedi environments."""
envs = list(jedi.api.environment.find_virtualenvs())
envs.extend(jedi.api.environment.find_system_environments())
return envs
@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')]
jedi.settings.additional_dynamic_modules = [
b.name for b in vim.buffers if (
b.name is not None and
b.name.endswith('.py') and
b.options['buflisted'])]
if source is None:
source = '\n'.join(vim.current.buffer)
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)
return jedi.Script(
source, row, column, buf_path,
encoding=vim_eval('&encoding') or 'latin1',
environment=get_environment(),
)
@_check_jedi_availability(show_error=False)
@@ -173,7 +232,7 @@ def completions():
if vim.eval('a:findstart') == '1':
count = 0
for char in reversed(vim.current.line[:column]):
if not re.match('[\w\d]', char):
if not re.match(r'[\w\d]', char):
break
count += 1
vim.command('return %i' % (column - count))
@@ -229,35 +288,30 @@ def tempfile(content):
finally:
os.unlink(f.name)
@_check_jedi_availability(show_error=True)
@catch_and_print_exceptions
def goto(mode="goto", no_output=False):
def goto(mode="goto"):
"""
:param str mode: "related_name", "definition", "assignment", "auto"
:param str mode: "definition", "assignment", "goto"
: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()
definitions = script.goto_assignments(follow_imports=True)
elif mode == "definition":
definitions = script.goto_definitions()
elif mode == "assignment":
definitions = script.goto_assignments()
elif mode == "stubs":
definitions = script.goto_assignments(follow_imports=True, only_stubs=True)
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.column is None:
if d.is_keyword:
echo_highlight("Cannot get the definition of Python keywords.")
else:
@@ -270,10 +324,12 @@ def goto(mode="goto", no_output=False):
using_tagstack=using_tagstack)
if not result:
return []
if d.module_path and os.path.exists(d.module_path) and using_tagstack:
if (using_tagstack and d.module_path and
os.path.exists(d.module_path)):
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:
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:
@@ -289,23 +345,74 @@ def goto(mode="goto", no_output=False):
repr(PythonToVimStr(old_wildignore)))
vim.current.window.cursor = d.line, d.column
else:
# multiple solutions
show_goto_multi_results(definitions)
return definitions
def relpath(path):
"""Make path relative to cwd if it is below."""
abspath = os.path.abspath(path)
if abspath.startswith(os.getcwd()):
return os.path.relpath(path)
return path
def annotate_description(d):
code = d.get_line_code().strip()
if d.type == 'statement':
return code
if d.type == 'function':
if code.startswith('def'):
return code
typ = 'def'
else:
typ = d.type
return '[%s] %s' % (typ, code)
def show_goto_multi_results(definitions):
"""Create a quickfix list for multiple definitions."""
lst = []
for d in definitions:
if d.in_builtin_module():
lst.append(dict(text=PythonToVimStr('Builtin ' + d.description)))
elif d.module_path is None:
if d.column 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),
text = annotate_description(d)
lst.append(dict(filename=PythonToVimStr(relpath(d.module_path)),
lnum=d.line, col=d.column + 1,
text=PythonToVimStr(d.description)))
text=PythonToVimStr(text)))
vim_eval('setqflist(%s)' % repr(lst))
vim_eval('jedi#add_goto_window(' + str(len(lst)) + ')')
@catch_and_print_exceptions
def usages(visuals=True):
script = get_script()
definitions = script.usages()
if not definitions:
echo_highlight("No usages found here.")
return definitions
if visuals:
highlight_usages(definitions)
show_goto_multi_results(definitions)
return definitions
def highlight_usages(definitions, length=None):
for definition in definitions:
# Only color the current module/buffer.
if (definition.module_path or '') == vim.current.buffer.name:
# mathaddpos needs a list of positions where a position is a list
# of (line, column, length).
# The column starts with 1 and not 0.
positions = [
[definition.line, definition.column + 1, length or len(definition.name)]
]
vim_eval("matchaddpos('jediUsage', %s)" % repr(positions))
@_check_jedi_availability(show_error=True)
@catch_and_print_exceptions
@@ -313,8 +420,6 @@ 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 = []
@@ -375,6 +480,7 @@ def show_call_signatures(signatures=()):
if int(vim_eval("g:jedi#show_call_signatures")) == 2:
return cmdline_call_signatures(signatures)
seen_sigs = []
for i, signature in enumerate(signatures):
line, column = signature.bracket_start
# signatures are listed above each other
@@ -389,13 +495,19 @@ def show_call_signatures(signatures=()):
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]
params = [p.description.replace('\n', '').replace('param ', '', 1)
for p in signature.params]
try:
# *_*PLACEHOLDER*_* makes something fat. See after/syntax file.
params[signature.index] = '*_*%s*_*' % params[signature.index]
except (IndexError, TypeError):
pass
# Skip duplicates.
if params in seen_sigs:
continue
seen_sigs.append(params)
# This stuff is reaaaaally a hack! I cannot stress enough, that
# this is a stupid solution. But there is really no other yet.
# There is no possibility in VIM to draw on the screen, but there
@@ -528,7 +640,13 @@ def rename():
vim_command('augroup END')
vim_command("let s:jedi_replace_orig = expand('<cword>')")
line = vim_eval('getline(".")')
vim_command('normal! diw')
if re.match(r'\w+$', line[cursor[1]:]):
# In case the deleted word is at the end of the line we need to
# move the cursor to the end.
vim_command('startinsert!')
else:
vim_command('startinsert')
else:
@@ -573,7 +691,7 @@ def do_rename(replace, orig=None):
saved_tab = int(vim_eval('tabpagenr()'))
saved_win = int(vim_eval('winnr()'))
temp_rename = goto(mode="related_name", no_output=True)
temp_rename = usages(visuals=False)
# Sort the whole thing reverse (positions at the end of the line
# must be first, because they move the stuff before the position).
temp_rename = sorted(temp_rename, reverse=True,
@@ -587,20 +705,16 @@ def do_rename(replace, orig=None):
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))
echo_highlight('Failed to create buffer window for %s!' % (
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)
r_line = vim.current.buffer[r.line - 1]
vim.current.buffer[r.line - 1] = (r_line[:r.column] + replace +
r_line[r.column + len(orig):])
# Restore previous tab and window.
vim_command('tabnext {0:d}'.format(saved_tab))
@@ -620,13 +734,13 @@ def py_import():
args = shsplit(vim.eval('a:args'))
import_path = args.pop()
text = 'import %s' % import_path
scr = jedi.Script(text, 1, len(text), '')
scr = jedi.Script(text, 1, len(text), '', environment=get_environment())
try:
completion = scr.goto_assignments()[0]
except IndexError:
echo_highlight('Cannot find %s in sys.path!' % import_path)
else:
if completion.in_builtin_module():
if completion.column is None: # Python modules always have a line number.
echo_highlight('%s is a builtin module.' % import_path)
else:
cmd_args = ' '.join([a.replace(' ', '\\ ') for a in args])
@@ -643,7 +757,7 @@ def py_import_completions():
comps = []
else:
text = 'import %s' % argl
script = jedi.Script(text, 1, len(text), '')
script = jedi.Script(text, 1, len(text), '', environment=get_environment())
comps = ['%s%s' % (argl, c.complete) for c in script.completions()]
vim.command("return '%s'" % '\n'.join(comps))

View File

@@ -1,44 +1,87 @@
"""Used in jedi-vim's jedi#debug_info()"""
import sys
import vim
from jedi_vim import PythonToVimStr
def echo(msg):
vim.command('echo %r' % PythonToVimStr(msg))
def echo_error(msg):
vim.command('echohl ErrorMsg')
echo(msg)
vim.command('echohl None')
def format_exc_info(exc_info=None, tb_indent=2):
import traceback
if exc_info is None:
exc_info = sys.exc_info()
exc_msg = traceback.format_exception_only(exc_info[0], exc_info[1])
lines = ''.join(exc_msg).rstrip('\n').split('\n')
lines.append('Traceback (most recent call last):')
tb = traceback.format_tb(exc_info[2])
lines.extend(''.join(tb).rstrip('\n').split('\n'))
indent = ' ' * tb_indent
return '{0}'.format(('\n' + indent).join(lines))
def display_debug_info():
import vim
def echo(msg):
vim.command('echo {0}'.format(msg))
echo("printf(' - sys.version: `%s`', {0!r})".format(
echo(' - global sys.version: `{0}`'.format(
', '.join([x.strip()
for x in __import__('sys').version.split('\n')])))
echo("printf(' - site module: `%s`', {0!r})".format(
__import__('site').__file__))
for x in sys.version.split('\n')])))
echo(' - global site module: `{0}`'.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)))
except Exception:
echo_error('ERROR: could not import jedi_vim: {0}'.format(
format_exc_info()))
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")))
if hasattr(jedi_vim, 'jedi_import_error'):
error_msg = format_exc_info(jedi_vim.jedi_import_error)
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:'")
error_msg = 'unknown error'
echo_error('ERROR: could not import the "jedi" Python module: {0}'.format(
error_msg))
else:
echo('\n##### Jedi\n\n - path: `{0}`'.format(jedi_vim.jedi.__file__))
echo(' - version: {0}'.format(jedi_vim.jedi.__version__))
try:
environment = jedi_vim.get_environment(use_cache=False)
except AttributeError:
script_evaluator = jedi_vim.jedi.Script('')._evaluator
try:
sys_path = script_evaluator.project.sys_path
except AttributeError:
sys_path = script_evaluator.sys_path
else:
echo('\n##### Jedi environment: {0}\n\n'.format(environment))
echo(' - executable: {0}'.format(environment.executable))
try:
sys_path = environment.get_sys_path()
except Exception:
echo_error('ERROR: failed to get sys path from environment: {0}'.format(
format_exc_info()))
return
echo(' - 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))
echo(' - `{0}`'.format(p))
if environment:
echo('\n##### Known environments\n\n')
for environment in jedi_vim.get_known_environments():
echo(' - {0} ({1})\n'.format(
environment,
environment.executable,
))

5
setup.cfg Normal file
View File

@@ -0,0 +1,5 @@
[tool:pytest]
testpaths = test
[flake8]
max-line-length = 100

View File

@@ -1,71 +0,0 @@
let g:jedi#completions_command = 'X'
source plugin/jedi.vim
describe 'completions'
before
new
set filetype=python
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
Expect getline('.') == 'import'
normal a subproX
Expect getline('.') == 'import subprocess'
end
it 'exception'
normal oIndentationErrX
Expect getline('.') == 'IndentationError'
normal a().filenaX
Expect getline('.') == 'IndentationError().filename'
end
it 'multi complete'
normal oImpXErrX()
Expect getline('.') == 'ImportError()'
end
it 'cycling through entries popup_select_first=0'
let g:jedi#popup_select_first = 0
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
" vim: et:ts=4:sw=4

65
test/test_integration.py Normal file
View File

@@ -0,0 +1,65 @@
"""Runs tests from ./vspec in vim-vspec."""
import os
import subprocess
try:
from urllib.request import urlretrieve
except ImportError:
from urllib import urlretrieve
import zipfile
import pytest
vspec_version = '1.8.1'
VSPEC_URL = 'https://github.com/kana/vim-vspec/archive/%s.zip' % vspec_version
root = os.path.dirname(os.path.dirname(__file__))
CACHE_FOLDER = os.path.join(root, 'build')
VSPEC_FOLDER = os.path.join(CACHE_FOLDER, 'vim-vspec-%s' % vspec_version)
VSPEC_RUNNER = os.path.join(VSPEC_FOLDER, 'bin/vspec')
TEST_DIR = os.path.join(root, 'test', 'vspec')
@pytest.fixture(scope='session')
def install_vspec(request):
if not os.path.isdir(CACHE_FOLDER):
os.mkdir(CACHE_FOLDER)
if not os.path.exists(VSPEC_FOLDER):
name, hdrs = urlretrieve(VSPEC_URL)
z = zipfile.ZipFile(name)
for n in z.namelist():
dest = os.path.join(CACHE_FOLDER, n)
destdir = os.path.dirname(dest)
if not os.path.isdir(destdir):
os.makedirs(destdir)
data = z.read(n)
if not os.path.isdir(dest):
with open(dest, 'wb') as f:
f.write(data)
z.close()
os.chmod(VSPEC_RUNNER, 0o777)
def get_vspec_tests():
for f in os.listdir(TEST_DIR):
yield os.path.relpath(os.path.join(TEST_DIR, f))
@pytest.mark.parametrize('path', get_vspec_tests())
def test_integration(install_vspec, path):
output = subprocess.check_output(
[VSPEC_RUNNER, '.', VSPEC_FOLDER, os.path.relpath(path, root)],
cwd=root,
)
had_ok = False
for line in output.splitlines():
if (line.startswith(b'not ok') or
line.startswith(b'Error') or
line.startswith(b'Bail out!')):
pytest.fail(u"{0} failed:\n{1}".format(
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(u"{0} failed: no 'ok' found:\n{1}".format(
path, output.decode('utf-8')), pytrace=False)

8
test/vimrc Normal file
View File

@@ -0,0 +1,8 @@
" Minimal vimrc to use jedi-vim.
"
" Not used anywhere yet, but allows for easy testing.
let script_dir = fnamemodify(expand('<sfile>'), ':h:h')
let &runtimepath = script_dir.','.&runtimepath.','.script_dir.'/after'
syntax on
filetype plugin indent on

131
test/vspec/completions.vim Normal file
View File

@@ -0,0 +1,131 @@
let g:jedi#completions_command = 'X'
source plugin/jedi.vim
describe 'completions'
before
new
set filetype=python
end
after
" default
let g:jedi#popup_select_first = 1
bd!
end
it 'longest in completeopt'
" This gets set up with Vim only on VimEnter.
if has('nvim')
Expect stridx(&completeopt, 'longest') > -1
else
Expect stridx(&completeopt, 'longest') == -1
doautocmd VimEnter
Expect stridx(&completeopt, 'longest') > -1
endif
" Do not use it for following tests.
set completeopt-=longest
end
it 'no smart import by default'
exec "normal ifrom os "
Expect getline('.') == 'from os '
end
it 'import'
" X is the completion command
normal oimporX
Expect getline('.') == 'import'
normal a subproX
Expect getline('.') == 'import subprocess'
end
it 'exception'
normal oIndentationErrX
Expect getline('.') == 'IndentationError'
" Do not remap keys (".") here, otherwise this triggers completion in
" Neovim already.
normal! a().filena
normal aX
Expect getline('.') == 'IndentationError().filename'
end
it 'multi complete'
" NOTE: nvim results in "importErr()" here with completeopt+=longest,
" but Vim is fine.
" This is due to `pumvisible()` in jedi#complete_opened being true
" with nvim still, but it is 0 with Vim, i.e. Vim appears to close
" the pum already (with the tests).
"
" This might be a misunderstanding though, since the test might not
" expect the "import" keyword to be offered for completion?!
normal oImpXErrX()
Expect getline('.') == 'ImportError()'
end
it 'cycling through entries popup_select_first=0'
set completeopt+=longest
let g:jedi#popup_select_first = 0
execute "normal oraise impX\<C-n>"
Expect getline('.') == 'raise ImportError'
set completeopt-=longest
end
it 'cycling through entries popup_select_first=1'
execute "normal oraise impX\<C-n>"
Expect getline('.') == 'raise ImportWarning'
end
it 'cycling through entries popup_select_first=1 and longest'
set completeopt+=longest
execute "normal oraise impX"
Expect getline('.') == 'raise Import'
" With Neovim pumvisible() is 1 in jedi#complete_opened, which then
" triggers the <Down>. This is not the case with Vim.
if has('nvim')
execute "normal oraise impX\<C-n>"
Expect getline('.') == 'raise ImportWarning'
execute "normal oraise impX\<C-n>\<C-n>"
Expect getline('.') == 'raise imp'
else
execute "normal oraise impX\<C-n>"
Expect getline('.') == 'raise ImportError'
execute "normal oraise impX\<C-n>\<C-n>"
Expect getline('.') == 'raise ImportWarning'
endif
set completeopt-=longest
end
end
describe 'smart completions'
before
new
let g:jedi#smart_auto_mappings = 1
set filetype=python
end
after
" default
let g:jedi#smart_auto_mappings = 0
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
end
" vim: et:ts=4:sw=4

View File

@@ -4,12 +4,11 @@ source plugin/jedi.vim
describe 'completions_disabled'
before
new
set filetype=python
end
after
bd!
try | %bwipeout! | catch | endtry
end
it 'typing'

View File

@@ -6,11 +6,11 @@ describe 'documentation docstrings'
end
after
bd!
bd!
try | %bwipeout! | catch | endtry
end
it 'simple'
Expect maparg('K') == ':call jedi#show_documentation()<CR>'
put = 'ImportError'
normal GK
Expect bufname('%') == "__doc__"

View File

@@ -1,10 +1,10 @@
let mapleader = '\'
source plugin/jedi.vim
source test/utils.vim
source test/_utils.vim
describe 'goto simple'
describe 'goto simple:'
before
new " open a new split
new
set filetype=python
put =[
\ 'def a(): pass',
@@ -22,77 +22,78 @@ describe 'goto simple'
it 'goto definitions'
normal \d
Expect line('.') == 1
Expect col('.') == 5
Expect line('.') == 2
Expect col('.') == 1
end
it 'goto assignments'
silent normal \g
normal \g
Expect line('.') == 2
Expect col('.') == 1
" cursor before `=` means that it stays there.
silent normal \g
normal \g
Expect line('.') == 2
Expect col('.') == 1
" going to the last line changes it.
normal! $
silent normal \g
normal \g
Expect line('.') == 1
Expect col('.') == 5
end
end
describe 'goto with tabs'
describe 'goto with tabs:'
before
set filetype=python
let g:jedi#use_tabs_not_buffers = 1
end
after
bd!
bd!
try | %bwipeout! | catch | endtry
end
it 'follow import'
put = ['import subprocess', 'subprocess']
silent normal G\g
normal G\g
Expect getline('.') == 'import subprocess'
Expect line('.') == 2
Expect col('.') == 8
silent normal G\d
normal G\d
Expect CurrentBufferIsModule('subprocess') == 1
Expect line('.') == 1
Expect col('.') == 1
Expect tabpagenr('$') == 2
Expect winnr('$') == 1
tabprevious
bwipe
Expect tabpagenr('$') == 1
Expect bufname('%') == ''
end
it 'multi definitions'
" This used to behave differently. Now we don't have any real multi
" definitions.
" put = ['import tokenize']
" silent normal G$\d
" Expect CurrentBufferIsModule('tokenize') == 1
" Expect CurrentBufferIsModule('token') == 0
" execute "normal \<CR>"
" Expect tabpagenr('$') == 2
" Expect winnr('$') == 1
" Expect CurrentBufferIsModule('token') == 1
" bd
" silent normal G$\d
" execute "normal j\<CR>"
" Expect tabpagenr('$') == 2
" Expect winnr('$') == 1
" Expect CurrentBufferIsModule('tokenize') == 1
end
" it 'multi definitions'
" " This used to behave differently. Now we don't have any real multi
" " definitions.
"
" " put = ['import tokenize']
" " 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
" " normal G$\d
" " execute "normal j\<CR>"
" " Expect tabpagenr('$') == 2
" " Expect winnr('$') == 1
" " Expect CurrentBufferIsModule('tokenize') == 1
" end
end
@@ -103,8 +104,7 @@ describe 'goto with buffers'
end
after
bd!
bd!
try | %bwipeout! | catch | endtry
set nohidden
end
@@ -125,47 +125,47 @@ describe 'goto with buffers'
Expect col('.') == 1
end
it 'multi definitions'
" set hidden
" put = ['import tokenize']
" silent normal G$\d
" Expect CurrentBufferIsModule('tokenize') == 0
" Expect CurrentBufferIsModule('token') == 0
" execute "normal \<CR>"
" Expect tabpagenr('$') == 1
" Expect winnr('$') == 1
" Expect CurrentBufferIsModule('token') == 1
" bd
" silent normal G$\d
" execute "normal j\<CR>"
" Expect tabpagenr('$') == 1
" Expect winnr('$') == 1
" Expect CurrentBufferIsModule('tokenize') == 1
end
" it 'multi definitions'
" " set hidden
" " put = ['import tokenize']
" " 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
" " normal G$\d
" " execute "normal j\<CR>"
" " Expect tabpagenr('$') == 1
" " Expect winnr('$') == 1
" " Expect CurrentBufferIsModule('tokenize') == 1
" end
end
describe 'goto with splits'
before
enew!
set filetype=python
let g:jedi#use_splits_not_buffers = 'left'
end
after
bd!
bd!
try | %bwipeout! | catch | endtry
end
it 'follow import'
put = ['import subprocess', 'subprocess']
silent normal G\g
normal G\g
Expect getline('.') == 'import subprocess'
Expect line('.') == 2
Expect col('.') == 8
silent normal G\d
normal G\d
Expect CurrentBufferIsModule('subprocess') == 1
Expect line('.') == 1
Expect col('.') == 1
@@ -179,6 +179,7 @@ end
describe 'goto wildignore'
before
enew!
set filetype=python
set wildignore=*,with\ spaces,*.pyc
set hidden
@@ -189,12 +190,11 @@ describe 'goto wildignore'
put = ['from subprocess import Popen', 'Popen']
Expect CurrentBufferIsModule('subprocess') == 0
silent normal G
normal G
end
after
bd!
bd!
try | %bwipeout! | catch | endtry
set wildignore&vim
end

View File

@@ -1,5 +1,5 @@
source plugin/jedi.vim
source test/utils.vim
source test/_utils.vim
describe 'pyimport'
before
@@ -7,8 +7,7 @@ describe 'pyimport'
end
after
bd!
bd!
try | %bwipeout! | catch | endtry
end
it 'open_tab'

View File

@@ -2,22 +2,19 @@ source plugin/jedi.vim
describe 'signatures'
before
enew
set filetype=python
end
after
bd!
bd!
try | %bwipeout! | catch | endtry
end
it 'simple'
normal odef xyz(number): return
normal o
normal oxyz(
normal G$
" equals doautocmd CursorMovedI
Python jedi_vim.show_call_signatures()
normal oxyz()
doautocmd CursorHoldI
Expect getline(3) == '?!?jedi=0, ?!? (*_*number*_*) ?!?jedi?!?'
doautocmd InsertLeave
@@ -37,19 +34,18 @@ describe 'signatures'
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(
noautocmd normal istaticmethod()
doautocmd CursorHoldI
Expect getline(1) == '?!?jedi=0, ?!? (*_*object*_*) ?!?jedi?!?'
Expect getline(1) == '?!?jedi=0, ?!? (*_*f: Callable*_*) ?!?jedi?!?'
end
it 'no signature'
normal ostr
exe 'normal ostr '
Python jedi_vim.show_call_signatures()
Expect getline(1, '$') == ['', 'str ']
end
@@ -57,7 +53,7 @@ describe 'signatures'
it 'signatures disabled'
let g:jedi#show_call_signatures = 0
normal ostr(
exe 'normal ostr( '
Python jedi_vim.show_call_signatures()
Expect getline(1, '$') == ['', 'str( ']
@@ -68,11 +64,11 @@ describe 'signatures'
let g:jedi#show_call_signatures = 2
call jedi#configure_call_signatures()
normal ostr(
exe 'normal ostaticmethod( '
redir => msg
Python jedi_vim.show_call_signatures()
redir END
Expect msg == "\nstr(object)"
Expect msg == "\nstaticmethod(f: Callable)"
redir => msg
doautocmd InsertLeave
@@ -80,7 +76,7 @@ describe 'signatures'
Expect msg == "\n"
normal Sdef foo(a, b): pass
normal ofoo(a, b, c,
exe 'normal ofoo(a, b, c, '
redir => msg
Python jedi_vim.show_call_signatures()
redir END
@@ -98,25 +94,25 @@ describe 'signatures'
return msg
endfunction
let funcname = repeat('a', &columns - 30)
let funcname = repeat('a', &columns - (30 + (&ruler ? 18 : 0)))
put = 'def '.funcname.'(arg1, arg2, arg3, a, b, c):'
put = ' pass'
execute "normal o".funcname."( "
execute "normal o\<BS>".funcname."( "
Expect Signature() == "\n".funcname."(arg1, …)"
normal sarg1,
exe 'normal sarg1, '
Expect Signature() == "\n".funcname."(…, arg2, …)"
normal sarg2, arg3,
exe 'normal sarg2, arg3, '
Expect Signature() == "\n".funcname."(…, a, b, c)"
normal sa, b,
exe 'normal sa, b, '
Expect Signature() == "\n".funcname."(…, c)"
g/^/d
put = 'def '.funcname.'('.repeat('b', 20).', arg2):'
put = ' pass'
execute "normal o".funcname."( "
execute "normal o\<BS>".funcname."( "
Expect Signature() == "\n".funcname."(…)"
end
@@ -124,7 +120,7 @@ describe 'signatures'
let g:jedi#show_call_signatures = 2
call jedi#configure_call_signatures()
normal ostr
exe 'normal ostr '
redir => msg
Python jedi_vim.show_call_signatures()
redir END

View File

@@ -1,2 +0,0 @@
def test_integration(case, monkeypatch, pytestconfig):
case.run()