mirror of
https://github.com/xonsh/xonsh.git
synced 2025-03-04 08:24:40 +01:00
224fc55e41
* completion-context: Add CompletionContextParser placeholder
Implements the xonsh (tab-)completion context parser.
This parser is meant to parse a (possibly incomplete) command line.
* completers: tools: Implement ``contextual_completer`` decorator
This is used to mark completers that want to use the parsed completion context.
* completers: Enable using contextual completers in xonsh/completer.py
* completers: readline, ptk, jupyter: Enable using contextual completers
Pass ``multiline_text`` and ``cursor_index`` to ``Completer.complete()``
* parsers: base: Refactor out a ``raise_parse_error`` function
* tokenize: Enable ``tolerant`` mode
If ``tolerant`` is True, yield ERRORTOKEN instead of
throwing an exception when encountering an error.
* lexer: Enable ``tolerant`` mode
Tokenize without extra checks (e.g. paren matching).
When True, ERRORTOKEN contains the erroneous string instead of an error msg.
* tests: lexer: Test ``tolerant`` mode
* completion-context: Implement simple CommandContext parsing
* completion-context: tests: Test simple CommandContext parsing
* completion-context: Implement parsing sub-commands
* completion-context: tests: Test parsing sub-commands
* completion-context: Add news file
* completion-context: parser: Add parser table path to relevant locations
Code-coverage, mypy ignore list, etc.
* completion-context: Implement parsing partial strings and line continuations
* completion-context: tests: Test parsing partial strings and line continuations
* completion-context: Convert ``Span`` object to a ``slice``
* completion-context: Refactor out ``create_command`` and ``cursor_in_span``
* completion-context: Implement handling empty commands
* completion-context: tests: Test handling empty commands
* completion-context: Implement handling multiple commands
Separated by newlines, `;`, `and`, `or`, `|`, `&&`, `||`
* completion-context: tests: Test handling multiple commands
Separated by newlines, `;`, `and`, `or`, `|`, `&&`, `||`
* completion-context: Implement handling python context
* completion-context: tests: Test handling python context
* completers: tools: Add `contextual_command_completer`
* completers: Make `complete_skipper` contextual
* completers: Make `complete_from_man` contextual
* completers: Make `complete_from_bash` contextual and add test
* completers: Make `complete_pip` contextual and update tests
* completers: Keep opening string quote if it exists
* completion-context: Handle cursor after a closing quote
For example - cursor at the end of ``ls "/usr/"``.
1. The closing quote will be appended to all completions.
I.e the completion ``/usr/bin`` will turn into ``/usr/bin"``
2. If not specified, lprefix will cover the closing prefix.
I.e for ``ls "/usr/"``, the default lprefix will be 6 to include the closing quote.
* completion-context: tests: Test handling cursor after a closing quote
* completion-context: Fix bug with multiple empty commands
e.g. `;;;`
* completion-context: tests: Speed up tests
From ~15 seconds to ~500 ms
* completion-context: Expand commands and subcommands
* completion-context: Simplify `commands` rules
* completion-context: Simplify `sub_expression` rules
* completion-context: Simplify editing a multi-command token
* completion-context: Inline `create_command`
* completion-context: Implement `contextual_command_completer_for` helper
* completers: Make `complete_cd`/`complete_rmdir` contextual and add tests
* completers: path: Don't append a double-backslash in a raw string
When completing a path, if a raw string is used (e.g. `r"C:\Windows\"`),
there's no reason to append a double-backslash (e.g. `r"C:\Windows\\"`).
* completers: Make `complete_xonfig`/`complete_xontrib` contextual and add tests
* completers: Make `complete_completer` contextual and add tests
* completers: Make `complete_import` contextual and add tests
* completion-context: Add python `ctx` attribute
* completion: tools: Simplify `RichCompletion` attributes handling
* completers: Make `base`, `python`, and `commands` contextual
* Add tests
* No need for `python_mode` completer anymore
* completion: tools: Add `append_space` attribute to `RichCompletion`
* completion-context: Get all lines in a main python context
* xontrib: jedi: Make the `jedi` completer contextual
* completers: tools: Remove `get_ptk_completer` and `PromptToolkitCompleter.current_document`
These aren't needed anymore now that contextual completers can access the multiline code (via `PythonContext.multiline_code`).
* completion-context: ptk: Expand aliases
* completion-context: jupyter: Expand aliases and fix line handling
* completer: Preserve custom prefix after closing quote
* completers: bash: Ensure bash completion uses the complete prefix
* completers: pip: Append a space after a pip command
* completers: pip: Prevent bad package name completions
* completers: Remove a common prefix from `RichCompletion` if `display` wasn't provided
* completion-context: Treat cursor at edge of `&& || | ;` as normal args
This will be used for completing a space
* completers: Complete end proc keywords correctly
100 lines
2.9 KiB
Python
100 lines
2.9 KiB
Python
import pytest
|
|
|
|
from tests.tools import skip_if_pre_3_8
|
|
from xonsh.completers.python import python_signature_complete, complete_import, complete_python
|
|
from xonsh.parsers.completion_context import CommandArg, CommandContext, CompletionContext, CompletionContextParser, PythonContext
|
|
|
|
|
|
@pytest.fixture(autouse=True)
|
|
def xonsh_execer_autouse(xonsh_builtins, xonsh_execer, monkeypatch):
|
|
monkeypatch.setitem(xonsh_builtins.__xonsh__.env, "COMPLETIONS_BRACKETS", True)
|
|
return xonsh_execer
|
|
|
|
|
|
def foo(x, y, z):
|
|
pass
|
|
|
|
|
|
def bar(wakka="wow", jawaka="mom"):
|
|
pass
|
|
|
|
|
|
def baz(sonata, artica=True):
|
|
pass
|
|
|
|
|
|
def always_true(x, y):
|
|
return True
|
|
|
|
|
|
BASE_CTX = {"foo": foo, "bar": bar, "baz": baz}
|
|
FOO_ARGS = {"x=", "y=", "z="}
|
|
BAR_ARGS = {"wakka=", "jawaka="}
|
|
BAZ_ARGS = {"sonata=", "artica="}
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"line, end, exp",
|
|
[
|
|
("foo(", 4, FOO_ARGS), # I have no idea why this one needs to be first
|
|
("foo()", 3, set()),
|
|
("foo()", 4, FOO_ARGS),
|
|
("foo()", 5, set()),
|
|
("foo(x, ", 6, FOO_ARGS),
|
|
("foo(x, )", 6, FOO_ARGS),
|
|
("bar()", 4, BAR_ARGS),
|
|
("baz()", 4, BAZ_ARGS),
|
|
("foo(bar(", 8, BAR_ARGS),
|
|
("foo(bar()", 9, FOO_ARGS),
|
|
("foo(bar())", 4, FOO_ARGS),
|
|
],
|
|
)
|
|
def test_complete_python_signatures(line, end, exp):
|
|
ctx = dict(BASE_CTX)
|
|
obs = python_signature_complete("", line, end, ctx, always_true)
|
|
assert exp == obs
|
|
|
|
|
|
@pytest.mark.parametrize("code, exp", (
|
|
("x = su", "sum"),
|
|
("imp", "import"),
|
|
("{}.g", "{}.get("),
|
|
# no signature for native builtins under 3.7:
|
|
pytest.param("''.split(ma", "maxsplit=", marks=skip_if_pre_3_8),
|
|
))
|
|
def test_complete_python(code, exp):
|
|
res = complete_python(CompletionContext(python=PythonContext(code, len(code), ctx={})))
|
|
assert res and len(res) == 2
|
|
comps, _ = res
|
|
assert exp in comps
|
|
|
|
|
|
def test_complete_python_ctx():
|
|
class A:
|
|
def wow():
|
|
pass
|
|
|
|
a = A()
|
|
|
|
res = complete_python(CompletionContext(python=PythonContext("a.w", 2, ctx=locals())))
|
|
assert res and len(res) == 2
|
|
comps, _ = res
|
|
assert "a.wow(" in comps
|
|
|
|
|
|
@pytest.mark.parametrize("command, exp", (
|
|
(CommandContext(args=(CommandArg("import"),), arg_index=1, prefix="pathli"), {"pathlib"}),
|
|
(CommandContext(args=(CommandArg("from"),), arg_index=1, prefix="pathli"), {"pathlib "}),
|
|
(CommandContext(args=(CommandArg("import"),), arg_index=1, prefix="os.pa"), {"os.path"}),
|
|
(CommandContext(args=(
|
|
CommandArg("import"), CommandArg("os,"),
|
|
), arg_index=2, prefix="pathli"), {"pathlib"}),
|
|
(CommandContext(args=(
|
|
CommandArg("from"), CommandArg("pathlib"), CommandArg("import"),
|
|
), arg_index=3, prefix="PurePa"), {"PurePath"}),
|
|
))
|
|
def test_complete_import(command, exp):
|
|
result = complete_import(CompletionContext(command,
|
|
python=PythonContext("", 0) # `complete_import` needs this
|
|
))
|
|
assert result == exp
|