Merge branch 'feature/26-toolbar'

* feature/26-toolbar:
  Fix merge conflict with package_data.
  Set separators above and below the help pane.
  Refactor getting and setting of config options code.
  Add styles to menu and toolbar.
  Add toolbar and hotkey support.
  Hook up config options.
  Add config and unit test.
  Add build_config_file_path method to refactor config file path code.
  Implement awslabs#28: Add auto suggest completions.
  Update to prompt-toolkit 0.52.

Author: donnemartin

awsshell/__init__.py

@@ -59,10 +59,10 @@ def main():
         t = threading.Thread(target=write_doc_index, args=(doc_index_file,))
         t.daemon = True
         t.start()
-    completer = shellcomplete.AWSShellCompleter(
-        autocomplete.AWSCLIModelCompleter(index_data))
+    model_completer = autocomplete.AWSCLIModelCompleter(index_data)
+    completer = shellcomplete.AWSShellCompleter(model_completer)
     history = InMemoryHistory()
-    shell = app.create_aws_shell(completer, history, doc_data)
+    shell = app.create_aws_shell(completer, model_completer, history, doc_data)
     shell.run()
 
 

awsshell/app.py

@@ -16,37 +16,116 @@
 from prompt_toolkit.interface import AbortAction, AcceptAction
 from prompt_toolkit.key_binding.manager import KeyBindingManager
 from prompt_toolkit.utils import Callback
+from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
 
 from awsshell.ui import create_default_layout
+from awsshell.config import Config
+from awsshell.keys import KeyManager
+from awsshell.style import StyleFactory
+from awsshell.toolbar import Toolbar
 
 
 LOG = logging.getLogger(__name__)
 
 
-def create_aws_shell(completer, history, docs):
-    return AWSShell(completer, history, docs)
+def create_aws_shell(completer, model_completer, history, docs):
+    return AWSShell(completer, model_completer, history, docs)
+
+
+class InputInterrupt(Exception):
+    """Stops the input of commands.
+
+    Raising `InputInterrupt` is useful to force a cli rebuild, which is
+    sometimes necessary in order for config changes to take effect.
+    """
+    pass
 
 
 class AWSShell(object):
-    def __init__(self, completer, history, docs):
+    """Encapsulates the ui, completer, command history, docs, and config.
+
+    Runs the input event loop and delegates the command execution to either
+    the `awscli` or the underlying shell.
+
+    :type refresh_cli: bool
+    :param refresh_cli: Flag to refresh the cli.
+
+    :type config_obj: :class:`configobj.ConfigObj`
+    :param config_obj: Contains the config information for reading and writing.
+
+    :type config_section: :class:`configobj.Section`
+    :param config_section: Convenience attribute to access the main section
+        of the config.
+
+    :type model_completer: :class:`AWSCLIModelCompleter`
+    :param model_completer: Matches input with completions.  `AWSShell` sets
+        and gets the attribute `AWSCLIModelCompleter.match_fuzzy`.
+
+    :type enable_vi_bindings: bool
+    :param enable_vi_bindings: If True, enables Vi key bindings. Else, Emacs
+        key bindings are enabled.
+
+    :type show_completion_columns: bool
+    param show_completion_columns: If True, completions are shown in multiple
+        columns.  Else, completions are shown in a single scrollable column.
+
+    :type show_help: bool
+    :param show_help: If True, shows the help pane.  Else, hides the help pane.
+
+    :type theme: str
+    :param theme: The pygments theme.
+    """
+
+    def __init__(self, completer, model_completer, history, docs):
         self.completer = completer
+        self.model_completer = model_completer
         self.history = history
         self._cli = None
         self._docs = docs
         self.current_docs = u''
+        self.refresh_cli = False
+        self.load_config()
+
+    def load_config(self):
+        """Loads the config from the config file or template."""
+        config = Config()
+        self.config_obj = config.load('awsshellrc')
+        self.config_section = self.config_obj['aws-shell']
+        self.model_completer.match_fuzzy = self.config_section.as_bool(
+            'match_fuzzy')
+        self.enable_vi_bindings = self.config_section.as_bool(
+            'enable_vi_bindings')
+        self.show_completion_columns = self.config_section.as_bool(
+            'show_completion_columns')
+        self.show_help = self.config_section.as_bool('show_help')
+        self.theme = self.config_section['theme']
+
+    def save_config(self):
+        """Saves the config to the config file."""
+        self.config_section['match_fuzzy'] = self.model_completer.match_fuzzy
+        self.config_section['enable_vi_bindings'] = self.enable_vi_bindings
+        self.config_section['show_completion_columns'] = \
+            self.show_completion_columns
+        self.config_section['show_help'] = self.show_help
+        self.config_section['theme'] = self.theme
+        self.config_obj.write()
 
     @property
     def cli(self):
-        if self._cli is None:
-            self._cli = self.create_cli_interface()
+        if self._cli is None or self.refresh_cli:
+            self._cli = self.create_cli_interface(self.show_completion_columns)
+            self.refresh_cli = False
         return self._cli
 
     def run(self):
         while True:
             try:
                 document = self.cli.run()
                 text = document.text
+            except InputInterrupt:
+                pass
             except (KeyboardInterrupt, EOFError):
+                self.save_config()
                 break
             else:
                 if text.strip() in ['quit', 'exit']:
@@ -78,38 +157,118 @@ def run(self):
                     p = subprocess.Popen(full_cmd, shell=True)
                     p.communicate()
 
-    def create_layout(self):
+    def stop_input_and_refresh_cli(self):
+        """Stops input by raising an `InputInterrupt`, forces a cli refresh.
+
+        The cli refresh is necessary because changing options such as key
+        bindings, single vs multi column menu completions, and the help pane
+        all require a rebuild.
+
+        :raises: :class:`InputInterrupt <exceptions.InputInterrupt>`.
+        """
+        self.refresh_cli = True
+        self.cli.request_redraw()
+        raise InputInterrupt
+
+    def create_layout(self, display_completions_in_columns, toolbar):
         return create_default_layout(
             self, u'aws> ', reserve_space_for_menu=True,
-            display_completions_in_columns=True)
+            display_completions_in_columns=display_completions_in_columns,
+            get_bottom_toolbar_tokens=toolbar.handler)
 
     def create_buffer(self, completer, history):
         return Buffer(
             history=history,
+            auto_suggest=AutoSuggestFromHistory(),
+            enable_history_search=True,
             completer=completer,
             complete_while_typing=Always(),
             accept_action=AcceptAction.RETURN_DOCUMENT)
 
-    def create_application(self, completer, history):
-        key_bindings_registry = KeyBindingManager(
-            enable_vi_mode=True,
-            enable_system_bindings=False,
-            enable_open_in_editor=False).registry
+    def create_key_manager(self):
+        """Creates the :class:`KeyManager`.
+
+        The inputs to KeyManager are expected to be callable, so we can't
+        use the standard @property and @attrib.setter for these attributes.
+        Lambdas cannot contain assignments so we're forced to define setters.
+
+        :rtype: :class:`KeyManager`
+        :return: A KeyManager with callables to set the toolbar options.  Also
+            includes the method stop_input_and_refresh_cli to ensure certain
+            options take effect within the current session.
+        """
+
+        def set_match_fuzzy(match_fuzzy):
+            """Setter for fuzzy matching mode.
+
+            :type match_fuzzy: bool
+            :param match_fuzzy: The match fuzzy flag.
+            """
+            self.model_completer.match_fuzzy = match_fuzzy
+
+        def set_enable_vi_bindings(enable_vi_bindings):
+            """Setter for vi mode keybindings.
+
+            If vi mode is off, emacs mode is enabled by default by
+            `prompt_toolkit`.
+
+            :type enable_vi_bindings: bool
+            :param enable_vi_bindings: The enable Vi bindings flag.
+            """
+            self.enable_vi_bindings = enable_vi_bindings
+
+        def set_show_completion_columns(show_completion_columns):
+            """Setter for showing the completions in columns flag.
+
+            :type show_completion_columns: bool
+            :param show_completion_columns: The show completions in
+                multiple columns flag.
+            """
+            self.show_completion_columns = show_completion_columns
+
+        def set_show_help(show_help):
+            """Setter for showing the help container flag.
+
+            :type show_help: bool
+            :param show_help: The show help flag.
+            """
+            self.show_help = show_help
+
+        return KeyManager(
+            lambda: self.model_completer.match_fuzzy, set_match_fuzzy,
+            lambda: self.enable_vi_bindings, set_enable_vi_bindings,
+            lambda: self.show_completion_columns, set_show_completion_columns,
+            lambda: self.show_help, set_show_help,
+            self.stop_input_and_refresh_cli)
+
+    def create_application(self, completer, history,
+                           display_completions_in_columns):
+        self.key_manager = self.create_key_manager()
+        toolbar = Toolbar(
+            lambda: self.model_completer.match_fuzzy,
+            lambda: self.enable_vi_bindings,
+            lambda: self.show_completion_columns,
+            lambda: self.show_help)
+        style_factory = StyleFactory(self.theme)
         buffers = {
             'clidocs': Buffer(read_only=True)
         }
 
         return Application(
-            layout=self.create_layout(),
+            layout=self.create_layout(display_completions_in_columns, toolbar),
+            mouse_support=False,
+            style=style_factory.style,
             buffers=buffers,
             buffer=self.create_buffer(completer, history),
             on_abort=AbortAction.RAISE_EXCEPTION,
             on_exit=AbortAction.RAISE_EXCEPTION,
             on_input_timeout=Callback(self.on_input_timeout),
-            key_bindings_registry=key_bindings_registry,
+            key_bindings_registry=self.key_manager.manager.registry,
         )
 
     def on_input_timeout(self, cli):
+        if not self.show_help:
+            return
         document = cli.current_buffer.document
         text = document.text
         LOG.debug("document.text = %s", text)
@@ -129,11 +288,13 @@ def on_input_timeout(self, cli):
             initial_document=Document(self.current_docs, cursor_position=0))
         cli.request_redraw()
 
-    def create_cli_interface(self):
+    def create_cli_interface(self, display_completions_in_columns):
         # A CommandLineInterface from prompt_toolkit
         # accepts two things: an application and an
         # event loop.
         loop = create_eventloop()
-        app = self.create_application(self.completer, self.history)
+        app = self.create_application(self.completer,
+                                      self.history,
+                                      display_completions_in_columns)
         cli = CommandLineInterface(application=app, eventloop=loop)
         return cli

awsshell/autocomplete.py

@@ -1,5 +1,6 @@
 from __future__ import print_function
 from awsshell.fuzzy import fuzzy_search
+from awsshell.substring import substring_search
 
 
 class AWSCLIModelCompleter(object):
@@ -9,7 +10,7 @@ class AWSCLIModelCompleter(object):
     AWS service (which we pull through botocore's data loaders).
 
     """
-    def __init__(self, index_data):
+    def __init__(self, index_data, match_fuzzy=True):
         self._index = index_data
         self._root_name = 'aws'
         self._global_options = index_data[self._root_name]['arguments']
@@ -22,6 +23,7 @@ def __init__(self, index_data):
         self.last_option = ''
         # This will get populated as a command is completed.
         self.cmd_path = [self._current_name]
+        self.match_fuzzy = match_fuzzy
 
     @property
     def arg_metadata(self):
@@ -99,8 +101,14 @@ def autocomplete(self, line):
             # We don't need to recompute this until the args are
             # different.
             all_args = self._get_all_args()
-            return fuzzy_search(last_word, all_args)
-        return fuzzy_search(last_word, self._current['commands'])
+            if self.match_fuzzy:
+                return fuzzy_search(last_word, all_args)
+            else:
+                return substring_search(last_word, all_args)
+        if self.match_fuzzy:
+            return fuzzy_search(last_word, self._current['commands'])
+        else:
+            return substring_search(last_word, self._current['commands'])
 
     def _get_all_args(self):
         if self._current['arguments'] != self._global_options:

awsshell/awsshellrc

@@ -0,0 +1,20 @@
+[aws-shell]
+
+# fuzzy or substring match.
+match_fuzzy = True
+
+# vi or emacs key bindings.
+enable_vi_bindings = False
+
+# multi or single column completion menu.
+show_completion_columns = False
+
+# show or hide the help pane.
+show_help = True
+
+# visual theme. possible values: manni, igor, xcode, vim,
+# autumn,vs, rrt, native, perldoc, borland, tango, emacs,
+# friendly, monokai, paraiso-dark, colorful, murphy, bw,
+# pastie, paraiso-light, trac, default, fruity.
+# to disable themes, set theme = none
+theme = vim