def test_pathcompleter_completes_directories_with_only_directories(self):
# setup: create a test dir with 10 files
test_dir = tempfile.mkdtemp()
write_test_files(test_dir)
# create a sub directory there
os.mkdir(os.path.join(test_dir, 'subdir'))
if not test_dir.endswith(os.path.sep):
test_dir += os.path.sep
with chdir(test_dir):
completer = PathCompleter(only_directories=True)
doc_text = ''
doc = Document(doc_text, len(doc_text))
event = CompleteEvent()
completions = list(completer.get_completions(doc, event))
result = [c.text for c in completions]
self.assertEqual(['subdir'], result)
# check that there is no completion when passing a file
with chdir(test_dir):
completer = PathCompleter(only_directories=True)
doc_text = '1'
doc = Document(doc_text, len(doc_text))
event = CompleteEvent()
completions = list(completer.get_completions(doc, event))
self.assertEqual([], completions)
# cleanup
shutil.rmtree(test_dir)
def test_pathcompleter_respects_completions_under_min_input_len(self):
# setup: create a test dir with 10 files
test_dir = tempfile.mkdtemp()
write_test_files(test_dir)
# min len:1 and no text
with chdir(test_dir):
completer = PathCompleter(min_input_len=1)
doc_text = ''
doc = Document(doc_text, len(doc_text))
event = CompleteEvent()
completions = list(completer.get_completions(doc, event))
self.assertEqual([], completions)
# min len:1 and text of len 1
with chdir(test_dir):
completer = PathCompleter(min_input_len=1)
doc_text = '1'
doc = Document(doc_text, len(doc_text))
event = CompleteEvent()
completions = list(completer.get_completions(doc, event))
result = [c.text for c in completions]
self.assertEqual([''], result)
# min len:0 and text of len 2
with chdir(test_dir):
completer = PathCompleter(min_input_len=0)
doc_text = '1'
doc = Document(doc_text, len(doc_text))
event = CompleteEvent()
completions = list(completer.get_completions(doc, event))
result = [c.text for c in completions]
self.assertEqual([''], result)
# create 10 files with a 2 char long name
for i in range(10):
with open(os.path.join(test_dir, str(i) * 2), 'wb') as out:
out.write(b'')
# min len:1 and text of len 1
with chdir(test_dir):
completer = PathCompleter(min_input_len=1)
doc_text = '2'
doc = Document(doc_text, len(doc_text))
event = CompleteEvent()
completions = list(completer.get_completions(doc, event))
result = sorted(c.text for c in completions)
self.assertEqual(['', '2'], result)
# min len:2 and text of len 1
with chdir(test_dir):
completer = PathCompleter(min_input_len=2)
doc_text = '2'
doc = Document(doc_text, len(doc_text))
event = CompleteEvent()
completions = list(completer.get_completions(doc, event))
self.assertEqual([], completions)
# cleanup
shutil.rmtree(test_dir)
def test_word_completer_ignore_case():
completer = WordCompleter(["abc", "def", "aaa"], ignore_case=True)
completions = completer.get_completions(Document("a"), CompleteEvent())
assert [c.text for c in completions] == ["abc", "aaa"]
completions = completer.get_completions(Document("A"), CompleteEvent())
assert [c.text for c in completions] == ["abc", "aaa"]
def test_word_completer_ignore_case():
completer = WordCompleter(['abc', 'def', 'aaa'], ignore_case=True)
completions = completer.get_completions(Document('a'), CompleteEvent())
assert [c.text for c in completions] == ['abc', 'aaa']
completions = completer.get_completions(Document('A'), CompleteEvent())
assert [c.text for c in completions] == ['abc', 'aaa']
def test_pathcompleter_respects_completions_under_min_input_len():
# setup: create a test dir with 10 files
test_dir = tempfile.mkdtemp()
write_test_files(test_dir)
# min len:1 and no text
with chdir(test_dir):
completer = PathCompleter(min_input_len=1)
doc_text = ""
doc = Document(doc_text, len(doc_text))
event = CompleteEvent()
completions = list(completer.get_completions(doc, event))
assert [] == completions
# min len:1 and text of len 1
with chdir(test_dir):
completer = PathCompleter(min_input_len=1)
doc_text = "1"
doc = Document(doc_text, len(doc_text))
event = CompleteEvent()
completions = list(completer.get_completions(doc, event))
result = [c.text for c in completions]
assert [""] == result
# min len:0 and text of len 2
with chdir(test_dir):
completer = PathCompleter(min_input_len=0)
doc_text = "1"
doc = Document(doc_text, len(doc_text))
event = CompleteEvent()
completions = list(completer.get_completions(doc, event))
result = [c.text for c in completions]
assert [""] == result
# create 10 files with a 2 char long name
for i in range(10):
with open(os.path.join(test_dir, str(i) * 2), "wb") as out:
out.write(b"")
# min len:1 and text of len 1
with chdir(test_dir):
completer = PathCompleter(min_input_len=1)
doc_text = "2"
doc = Document(doc_text, len(doc_text))
event = CompleteEvent()
completions = list(completer.get_completions(doc, event))
result = sorted(c.text for c in completions)
assert ["", "2"] == result
# min len:2 and text of len 1
with chdir(test_dir):
completer = PathCompleter(min_input_len=2)
doc_text = "2"
doc = Document(doc_text, len(doc_text))
event = CompleteEvent()
completions = list(completer.get_completions(doc, event))
assert [] == completions
# cleanup
shutil.rmtree(test_dir)
def test_pathcompleter_completes_directories_with_only_directories():
# setup: create a test dir with 10 files
test_dir = tempfile.mkdtemp()
write_test_files(test_dir)
# create a sub directory there
os.mkdir(os.path.join(test_dir, "subdir"))
if not test_dir.endswith(os.path.sep):
test_dir += os.path.sep
with chdir(test_dir):
completer = PathCompleter(only_directories=True)
doc_text = ""
doc = Document(doc_text, len(doc_text))
event = CompleteEvent()
completions = list(completer.get_completions(doc, event))
result = [c.text for c in completions]
assert ["subdir"] == result
# check that there is no completion when passing a file
with chdir(test_dir):
completer = PathCompleter(only_directories=True)
doc_text = "1"
doc = Document(doc_text, len(doc_text))
event = CompleteEvent()
completions = list(completer.get_completions(doc, event))
assert [] == completions
# cleanup
shutil.rmtree(test_dir)
def test_word_completer_sentence():
# With sentence=True
completer = WordCompleter(['hello world', 'www', 'hello www', 'hello there'], sentence=True)
completions = completer.get_completions(Document('hello w'), CompleteEvent())
assert [c.text for c in completions] == ['hello world', 'hello www']
# With sentence=False
completer = WordCompleter(['hello world', 'www', 'hello www', 'hello there'], sentence=False)
completions = completer.get_completions(Document('hello w'), CompleteEvent())
assert [c.text for c in completions] == ['www']
def test_word_completer_pattern():
# With a pattern which support '.'
completer = WordCompleter(['abc', 'a.b.c', 'a.b', 'xyz'],
pattern=re.compile(r'^([a-zA-Z0-9_.]+|[^a-zA-Z0-9_.\s]+)'))
completions = completer.get_completions(Document('a.'), CompleteEvent())
assert [c.text for c in completions] == ['a.b.c', 'a.b']
# Without pattern
completer = WordCompleter(['abc', 'a.b.c', 'a.b', 'xyz'])
completions = completer.get_completions(Document('a.'), CompleteEvent())
assert [c.text for c in completions] == []
def test_word_completer_pattern():
# With a pattern which support '.'
completer = WordCompleter(
["abc", "a.b.c", "a.b", "xyz"],
pattern=re.compile(r"^([a-zA-Z0-9_.]+|[^a-zA-Z0-9_.\s]+)"),
)
completions = completer.get_completions(Document("a."), CompleteEvent())
assert [c.text for c in completions] == ["a.b.c", "a.b"]
# Without pattern
completer = WordCompleter(["abc", "a.b.c", "a.b", "xyz"])
completions = completer.get_completions(Document("a."), CompleteEvent())
assert [c.text for c in completions] == []
def test_get_completions(self, mock_generate_url, mock_request):
mock_request.return_value = self.default_response
completer = ResourceCompleter('api_1_0.serverlist',
'name',
match_middle=False)
# Static list on empty input.
completions = completer.get_completions(Document(""), CompleteEvent())
self.assertListEqual(["dev1", "dev2", "node3"],
[c.text for c in completions])
completions = completer.get_completions(Document("d"), CompleteEvent())
self.assertListEqual(["dev1", "dev2"], [c.text for c in completions])
def test_word_completer_sentence():
# With sentence=True
completer = WordCompleter(
["hello world", "www", "hello www", "hello there"], sentence=True
)
completions = completer.get_completions(Document("hello w"), CompleteEvent())
assert [c.text for c in completions] == ["hello world", "hello www"]
# With sentence=False
completer = WordCompleter(
["hello world", "www", "hello www", "hello there"], sentence=False
)
completions = completer.get_completions(Document("hello w"), CompleteEvent())
assert [c.text for c in completions] == ["www"]
def test_filter(self, mock_generate_url, mock_request):
mock_request.return_value = self.default_response
completer = ResourceCompleter('servers', 'name', match_middle=True)
completions = completer.get_completions(Document("3"), CompleteEvent())
self.assertListEqual(["node3"], [c.text for c in completions])
completer = ResourceCompleter('servers',
'name',
ignore_case=True,
match_middle=False)
completions = completer.get_completions(Document("D"), CompleteEvent())
self.assertListEqual(["dev1", "dev2"], [c.text for c in completions])
def test_completer(self):
class completer1(Completer):
def get_completions(self, document, complete_event):
yield Completion('before-%s-after' % document.text,
-len(document.text))
yield Completion('before-%s-after-B' % document.text,
-len(document.text))
class completer2(Completer):
def get_completions(self, document, complete_event):
yield Completion('before2-%s-after2' % document.text,
-len(document.text))
yield Completion('before2-%s-after2-B' % document.text,
-len(document.text))
# Create grammar. "var1" + "whitespace" + "var2"
g = compile(r'(?P<var1>[a-z]*) \s+ (?P<var2>[a-z]*)')
# Test 'get_completions()'
completer = GrammarCompleter(g, {
'var1': completer1(),
'var2': completer2()
})
completions = list(
completer.get_completions(Document('abc def', len('abc def')),
CompleteEvent()))
self.assertEqual(len(completions), 2)
self.assertEqual(completions[0].text, 'before2-def-after2')
self.assertEqual(completions[0].start_position, -3)
self.assertEqual(completions[1].text, 'before2-def-after2-B')
self.assertEqual(completions[1].start_position, -3)
def _get_completions(self, text, requested=False):
text = text_type(text)
doc = Document(text, len(text))
c_e = CompleteEvent(completion_requested=requested)
completions = self.completer.get_completions(doc, c_e)
c = [text_type(c.text) for c in completions]
return c
def test_pathcompleter_completes_in_current_directory(self):
completer = PathCompleter()
doc_text = ''
doc = Document(doc_text, len(doc_text))
event = CompleteEvent()
completions = list(completer.get_completions(doc, event))
self.assertTrue(len(completions) > 0)
def test_pathcompleter_does_not_expanduser_by_default(self):
completer = PathCompleter()
doc_text = '~'
doc = Document(doc_text, len(doc_text))
event = CompleteEvent()
completions = list(completer.get_completions(doc, event))
self.assertEqual([], completions)
def display_completions_like_readline(event: E) -> None:
"""
Key binding handler for readline-style tab completion.
This is meant to be as similar as possible to the way how readline displays
completions.
Generate the completions immediately (blocking) and display them above the
prompt in columns.
Usage::
# Call this handler when 'Tab' has been pressed.
key_bindings.add(Keys.ControlI)(display_completions_like_readline)
"""
# Request completions.
b = event.current_buffer
if b.completer is None:
return
complete_event = CompleteEvent(completion_requested=True)
completions = list(b.completer.get_completions(b.document, complete_event))
# Calculate the common suffix.
common_suffix = get_common_complete_suffix(b.document, completions)
# One completion: insert it.
if len(completions) == 1:
b.delete_before_cursor(-completions[0].start_position)
b.insert_text(completions[0].text)
# Multiple completions with common part.
elif common_suffix:
b.insert_text(common_suffix)
# Otherwise: display all completions.
elif completions:
_display_completions_like_readline(event.app, completions)
def test_completer():
class completer1(Completer):
def get_completions(self, document, complete_event):
yield Completion("before-%s-after" % document.text, -len(document.text))
yield Completion("before-%s-after-B" % document.text, -len(document.text))
class completer2(Completer):
def get_completions(self, document, complete_event):
yield Completion("before2-%s-after2" % document.text, -len(document.text))
yield Completion("before2-%s-after2-B" % document.text, -len(document.text))
# Create grammar. "var1" + "whitespace" + "var2"
g = compile(r"(?P<var1>[a-z]*) \s+ (?P<var2>[a-z]*)")
# Test 'get_completions()'
completer = GrammarCompleter(g, {"var1": completer1(), "var2": completer2()})
completions = list(
completer.get_completions(Document("abc def", len("abc def")), CompleteEvent())
)
assert len(completions) == 2
assert completions[0].text == "before2-def-after2"
assert completions[0].start_position == -3
assert completions[1].text == "before2-def-after2-B"
assert completions[1].start_position == -3
def get_completions(self, text):
text = text_type(text)
doc = Document(text, len(text))
c_e = CompleteEvent()
completions = self.completer.get_completions(doc, c_e)
c = [text_type(c.text) for c in completions]
return c
def test_pathcompleter_does_not_expanduser_by_default():
completer = PathCompleter()
doc_text = "~"
doc = Document(doc_text, len(doc_text))
event = CompleteEvent()
completions = list(completer.get_completions(doc, event))
assert [] == completions
def test_pathcompleter_completes_in_current_directory():
completer = PathCompleter()
doc_text = ""
doc = Document(doc_text, len(doc_text))
event = CompleteEvent()
completions = list(completer.get_completions(doc, event))
assert len(completions) > 0
def test_pathcompleter_can_expanduser():
completer = PathCompleter(expanduser=True)
doc_text = '~'
doc = Document(doc_text, len(doc_text))
event = CompleteEvent()
completions = list(completer.get_completions(doc, event))
assert len(completions) > 0
def test_next_phrase_word_is_suggested_for_typed_word_being_its_prefix():
completer = PhraseWordCompleter('add genesis transaction')
document = Document('add genesis tra')
complete_event = CompleteEvent(text_inserted=True)
completions = list(completer.get_completions(document, complete_event))
assert [Completion('transaction', -3)] == completions
def test_first_phrase_word_is_suggested_for_empty_input():
completer = PhraseWordCompleter('add genesis transaction')
document = Document('')
complete_event = CompleteEvent(completion_requested=True)
completions = list(completer.get_completions(document, complete_event))
assert [Completion('add')] == completions
def test_none_is_suggested_for_any_input_after_all_phrase_and_space():
completer = PhraseWordCompleter('add genesis transaction')
document = Document('add genesis transaction new tr')
complete_event = CompleteEvent(completion_requested=True)
completions = list(completer.get_completions(document, complete_event))
assert [] == completions
def test_pathcompleter_can_expanduser(monkeypatch):
monkeypatch.setenv('HOME', '/tmp')
completer = PathCompleter(expanduser=True)
doc_text = "~"
doc = Document(doc_text, len(doc_text))
event = CompleteEvent()
completions = list(completer.get_completions(doc, event))
assert len(completions) > 0
def test_word_completer_static_word_list():
completer = WordCompleter(['abc', 'def', 'aaa'])
# Static list on empty input.
completions = completer.get_completions(Document(''), CompleteEvent())
assert [c.text for c in completions] == ['abc', 'def', 'aaa']
# Static list on non-empty input.
completions = completer.get_completions(Document('a'), CompleteEvent())
assert [c.text for c in completions] == ['abc', 'aaa']
completions = completer.get_completions(Document('A'), CompleteEvent())
assert [c.text for c in completions] == []
# Multiple words. (Check last only.)
completions = completer.get_completions(Document('test a'), CompleteEvent())
assert [c.text for c in completions] == ['abc', 'aaa']
def test_word_completer_dynamic_word_list():
called = [0]
def get_words():
called[0] += 1
return ['abc', 'def', 'aaa']
completer = WordCompleter(get_words)
# Dynamic list on empty input.
completions = completer.get_completions(Document(''), CompleteEvent())
assert [c.text for c in completions] == ['abc', 'def', 'aaa']
assert called[0] == 1
# Static list on non-empty input.
completions = completer.get_completions(Document('a'), CompleteEvent())
assert [c.text for c in completions] == ['abc', 'aaa']
assert called[0] == 2
def complete(part: str,
completer: Completer,
return_meta: bool = False) -> Set[str]:
return {
a.display_meta_text if return_meta else a.text
for a in completer.get_completions(Document(part, len(part)),
CompleteEvent())
}
def test_next_phrase_word_is_suggested_for_space_typed_inside_input():
completer = PhraseWordCompleter('add genesis transaction')
document = Document('add transaction', 4)
complete_event = CompleteEvent(text_inserted=True)
completions = list(completer.get_completions(document, complete_event))
assert [Completion('genesis')] == completions
