Implemented a FuzzySelect interaction

Author: joguSD

awsshell/interaction.py

@@ -2,13 +2,17 @@
 import sys
 import jmespath
 
-from six import with_metaclass
 from abc import ABCMeta, abstractmethod
+from six import with_metaclass, string_types
 
 from prompt_toolkit import prompt
+from prompt_toolkit.completion import Completer, Completion
+from prompt_toolkit.contrib.validators.base import SentenceValidator
 from prompt_toolkit.contrib.completers import PathCompleter
+
 from awsshell.utils import FSLayer, FileReadError
 from awsshell.selectmenu import select_prompt
+from awsshell.fuzzy import fuzzy_search
 
 
 class InteractionException(Exception):
@@ -108,13 +112,69 @@ def execute(self, data):
         return data
 
 
+class FuzzyCompleter(Completer):
+    """Filters the completion list by doing a fuzzy search with the input."""
+
+    def __init__(self, corpus, meta_dict={}):
+        self.corpus = list(corpus)
+        self.meta_dict = meta_dict
+        assert all(isinstance(w, string_types) for w in self.corpus)
+
+    def get_completions(self, document, complete_event):
+        text = document.text_before_cursor
+        if len(text) == 0:
+            matches = self.corpus
+        else:
+            matches = fuzzy_search(text, self.corpus)
+        for match in matches:
+            display_meta = self.meta_dict.get(match)
+            yield Completion(match, -len(text), display_meta=display_meta)
+
+
+class FuzzySelect(Interaction):
+    """Typing will apply a case senstive fuzzy filter to the options.
+
+    Show completions based on the given list of options, allowing the user to
+    type to begin filtering the options with a fuzzy search. The prompt will
+    also validate that the input is from the list and will reject all other
+    inputs.
+    """
+
+    def __init__(self, model, prompt_msg, prompter=prompt):
+        super(FuzzySelect, self).__init__(model, prompt_msg)
+        self._prompter = prompter
+        self._validator_opts = {
+            'move_cursor_to_end': True,
+            'error_message': 'Invalid Selection: Must choose from the list'
+        }
+
+    def execute(self, data):
+        if not isinstance(data, list) or len(data) < 1:
+            raise InteractionException('FuzzySelect expects a non-empty list')
+        if self._model.get('Path') is not None:
+            # This will not handle duplicate strings as options
+            display_data = jmespath.search(self._model['Path'], data)
+            option_dict = dict(zip(display_data, data))
+            completer = FuzzyCompleter(display_data)
+            validator = SentenceValidator(display_data, **self._validator_opts)
+            selection = self._prompter(self.prompt, completer=completer,
+                                       validator=validator)
+            return option_dict[selection]
+        else:
+            completer = FuzzyCompleter(data)
+            validator = SentenceValidator(data, **self._validator_opts)
+            return self._prompter(self.prompt, completer=completer,
+                                  validator=validator)
+
+
 class InteractionLoader(object):
     """An interaction loader. Create interactions based on their name.
 
     The class will maintain a dict of ScreenType to Interaction object so
     Interaction objects can be instantiated from their corresponding str.
     """
     _INTERACTIONS = {
+        'FuzzySelect': FuzzySelect,
         'SimpleSelect': SimpleSelect,
         'SimplePrompt': SimplePrompt,
         'FilePrompt': FilePrompt

tests/unit/test_interaction.py

@@ -2,8 +2,11 @@
 import pytest
 
 from awsshell.utils import InMemoryFSLayer
+from prompt_toolkit.buffer import Document
+from prompt_toolkit.contrib.validators.base import Validator, ValidationError
 from awsshell.interaction import InteractionLoader, InteractionException
 from awsshell.interaction import SimpleSelect, SimplePrompt, FilePrompt
+from awsshell.interaction import FuzzyCompleter, FuzzySelect
 
 
 @pytest.fixture
@@ -98,14 +101,15 @@ def test_simple_select_with_path():
     assert xformed == options[1]
 
 
-def test_simple_select_bad_data(simple_selector):
-    # Test that simple select throws exceptions when given bad data
+@pytest.mark.parametrize('selector', [simple_selector(), FuzzySelect({}, u'')])
+def test_simple_select_bad_data(selector):
+    # Test that a selector select throws exceptions when given bad data
     with pytest.raises(InteractionException) as ie:
-        simple_selector.execute({})
-    assert 'SimpleSelect expects a non-empty list' in str(ie.value)
+        selector.execute({})
+    assert 'expects a non-empty list' in str(ie.value)
     with pytest.raises(InteractionException) as ie:
-        simple_selector.execute([])
-    assert 'SimpleSelect expects a non-empty list' in str(ie.value)
+        selector.execute([])
+    assert 'expects a non-empty list' in str(ie.value)
 
 
 def test_simple_prompt():
@@ -126,3 +130,53 @@ def test_simple_prompt_bad_data(simple_prompt):
     with pytest.raises(InteractionException) as ie:
         simple_prompt.execute([])
     assert 'SimplePrompt expects a dict as data' in str(ie.value)
+
+
+def test_fuzzy_completer():
+    def to_list(candidates):
+        return [c.text for c in candidates]
+
+    corpus = ['A word', 'Awo', 'A b c']
+    document = Document(text=u'')
+    completer = FuzzyCompleter(corpus)
+    candidates = completer.get_completions(document, None)
+    assert to_list(candidates) == corpus
+    document = Document(text=u'Awo')
+    candidates = completer.get_completions(document, None)
+    assert to_list(candidates) == ['Awo', 'A word']
+
+
+def test_fuzzy_select():
+    # Verify that SimpleSelect calls prompt and it returns a selection
+    prompt = mock.Mock()
+    selector = FuzzySelect({}, 'one or two?', prompt)
+    options = ['one', 'two']
+    prompt.return_value = options[1]
+    xformed = selector.execute(options)
+    assert prompt.call_count == 1
+    assert xformed == options[1]
+    args, kwargs = prompt.call_args
+    validator = kwargs['validator']
+    assert isinstance(kwargs['validator'], Validator)
+    with pytest.raises(ValidationError):
+        document = Document(text=u'three')
+        validator.validate(document)
+
+
+def test_fuzzy_select_with_path():
+    # Verify that FuzzySelect calls prompt and it returns the corresponding
+    # item derived from the path.
+    prompt = mock.Mock()
+    model = {'Path': '[].a'}
+    fuzzy_selector = FuzzySelect(model, 'Promptingu', prompt)
+    options = [{'a': '1', 'b': 'one'}, {'a': '2', 'b': 'two'}]
+    prompt.return_value = '2'
+    xformed = fuzzy_selector.execute(options)
+    assert prompt.call_count == 1
+    assert xformed == options[1]
+    args, kwargs = prompt.call_args
+    validator = kwargs['validator']
+    assert isinstance(kwargs['validator'], Validator)
+    with pytest.raises(ValidationError):
+        document = Document(text=u'3')
+        validator.validate(document)