Merge branch 'better-dot'

* better-dot:
  Incorporate review feedback
  Extract dot commands to separate object

Author: jamesls

awsshell/app.py

@@ -4,9 +4,11 @@
 
 """
 from __future__ import unicode_literals
+import os
 import tempfile
 import subprocess
 import logging
+import sys
 
 from prompt_toolkit.document import Document
 from prompt_toolkit.shortcuts import create_eventloop
@@ -25,6 +27,7 @@
 from awsshell.style import StyleFactory
 from awsshell.toolbar import Toolbar
 from awsshell.utils import build_config_file_path
+from awsshell import compat
 
 
 LOG = logging.getLogger(__name__)
@@ -43,6 +46,76 @@ class InputInterrupt(Exception):
     pass
 
 
+class EditHandler(object):
+    def __init__(self, popen_cls=None, env=None):
+        if popen_cls is None:
+            popen_cls = subprocess.Popen
+        self._popen_cls = popen_cls
+        if env is None:
+            env = os.environ
+        self._env = env
+
+    def _get_editor_command(self):
+        if 'EDITOR' in self._env:
+            return self._env['EDITOR']
+        else:
+            return compat.default_editor()
+
+    def run(self, command, application):
+        """Open application's history buffer in an editor.
+
+        :type command: list
+        :param command: The dot command as a list split
+            on whitespace, e.g ``['.foo', 'arg1', 'arg2']``
+
+        :type application: AWSShell
+        :param application: The application object.
+
+        """
+        all_commands = '\n'.join(
+            ['aws ' + h for h in list(application.history)
+             if not h.startswith(('.', '!'))])
+        with tempfile.NamedTemporaryFile('w') as f:
+            f.write(all_commands)
+            f.flush()
+            editor = self._get_editor_command()
+            p = self._popen_cls([editor, f.name])
+            p.communicate()
+
+
+class DotCommandHandler(object):
+    HANDLER_CLASSES = {
+        'edit': EditHandler,
+    }
+
+    def __init__(self, output=sys.stdout, err=sys.stderr):
+        self._output = output
+        self._err = err
+
+    def handle_cmd(self, command, application):
+        """Handles running a given dot command from a user.
+
+        :type command: str
+        :param command: The full dot command string, e.g. ``.edit``,
+            of ``.profile prod``.
+
+        :type application: AWSShell
+        :param application: The application object.
+
+        """
+        parts = command.split()
+        cmd_name = parts[0][1:]
+        if cmd_name not in self.HANDLER_CLASSES:
+            self._unknown_cmd(parts, application)
+        else:
+            # Note we expect the class to support no-arg
+            # instantiation.
+            self.HANDLER_CLASSES[cmd_name]().run(parts, application)
+
+    def _unknown_cmd(self, cmd_parts, application):
+        self._err.write("Unknown dot command: %s\n" % cmd_parts[0])
+
+
 class AWSShell(object):
     """Encapsulates the ui, completer, command history, docs, and config.
 
@@ -81,12 +154,13 @@ class AWSShell(object):
     def __init__(self, completer, model_completer, docs):
         self.completer = completer
         self.model_completer = model_completer
-        self.memory_history = InMemoryHistory()
+        self.history = InMemoryHistory()
         self.file_history = FileHistory(build_config_file_path('history'))
         self._cli = None
         self._docs = docs
         self.current_docs = u''
         self.refresh_cli = False
+        self._dot_cmd = DotCommandHandler()
         self.load_config()
 
     def load_config(self):
@@ -136,23 +210,14 @@ def run(self):
                 if text.startswith('.'):
                     # These are special commands.  The only one supported for
                     # now is .edit.
-                    if text.startswith('.edit'):
-                        # TODO: Use EDITOR env var.
-                        all_commands = '\n'.join(
-                            ['aws ' + h for h in list(self.memory_history)
-                             if not h.startswith(('.', '!'))])
-                    with tempfile.NamedTemporaryFile('w') as f:
-                        f.write(all_commands)
-                        f.flush()
-                        p = subprocess.Popen(['vim', f.name])
-                        p.communicate()
+                    self._dot_cmd.handle_cmd(text, application=self)
                 else:
                     if text.startswith('!'):
                         # Then run the rest as a normally shell command.
                         full_cmd = text[1:]
                     else:
                         full_cmd = 'aws ' + text
-                        self.memory_history.append(full_cmd)
+                        self.history.append(full_cmd)
                     self.current_docs = u''
                     self.cli.buffers['clidocs'].reset(
                         initial_document=Document(self.current_docs,

awsshell/compat.py

@@ -1,7 +1,11 @@
 from __future__ import print_function
 import sys
+import platform
+
 
 PY3 = sys.version_info[0] == 3
+ON_WINDOWS = platform.system() == 'Windows'
+
 
 if PY3:
     from html.parser import HTMLParser
@@ -13,3 +17,11 @@
     text_type = unicode
     from cStringIO import StringIO
     import anydbm as dbm
+
+
+if ON_WINDOWS:
+    def default_editor():
+        return 'notepad.exe'
+else:
+    def default_editor():
+        return 'vim'

tests/unit/test_app.py

@@ -0,0 +1,44 @@
+import pytest
+import mock
+
+
+from awsshell import app
+from awsshell import compat
+
+
+@pytest.fixture
+def errstream():
+    return compat.StringIO()
+
+
+def test_can_dispatch_dot_commands():
+    call_args = []
+    class CustomHandler(object):
+        def run(self, command, context):
+            call_args.append((command, context))
+    handler = app.DotCommandHandler()
+    handler.HANDLER_CLASSES['foo'] = CustomHandler
+    context = object()
+
+    handler.handle_cmd('.foo a b c', context)
+
+    assert call_args == [(['.foo', 'a', 'b', 'c'], context)]
+
+
+def test_edit_handler():
+    env = {'EDITOR': 'my-editor'}
+    popen_cls = mock.Mock()
+    context = mock.Mock()
+    context.history = []
+    handler = app.EditHandler(popen_cls, env)
+    handler.run(['.edit'], context)
+    # Ensure our editor was called with some arbitrary temp filename.
+    command_run = popen_cls.call_args[0][0]
+    assert len(command_run) == 2
+    assert command_run[0] == 'my-editor'
+
+
+def test_prints_error_message_on_unknown_dot_command(errstream):
+    handler = app.DotCommandHandler(err=errstream)
+    handler.handle_cmd(".unknown foo bar", None)
+    assert errstream.getvalue() == "Unknown dot command: .unknown\n"