Support reading Basilisp code from CLI stdin (#349)

* Support reading Basilisp code from CLI stdin

* Slightly more stylish Makefile

* Skip CLI tests on PyPy for now

* Use this nicer Module skip

* UGH

* I literally hate PyPy

Author: chrisrink10

Makefile

@@ -33,16 +33,18 @@ repl:
 test-pypy:
 	@docker run \
 		--mount src=`pwd`,target=/usr/src/app,type=bind \
+		--workdir /usr/src/app \
 		pypy:3.6-7.0-slim-jessie \
-		/bin/sh -c 'cd /usr/src/app && pip install tox && tox -e pypy3'
+		/bin/sh -c 'pip install tox && tox -e pypy3'
 
 
 .PHONY: pypy-shell
 pypy-shell:
 	@docker run -it \
 		--mount src=`pwd`,target=/usr/src/app,type=bind \
+		--workdir /usr/src/app \
 		pypy:3.6-7.0-slim-jessie \
-		/bin/sh -c 'cd /usr/src/app && pip install -e . && basilisp repl'
+		/bin/sh -c 'pip install -e . && basilisp repl'
 
 
 .PHONY: test

src/basilisp/cli.py

@@ -1,6 +1,7 @@
 import atexit
 import importlib
 import os.path
+import platform
 import traceback
 import types
 from typing import Any
@@ -20,11 +21,13 @@
 )
 BASILISP_REPL_HISTORY_LENGTH = 1000
 REPL_INPUT_FILE_PATH = "<REPL Input>"
+STDIN_INPUT_FILE_PATH = "<stdin>"
+STDIN_FILE_NAME = "-"
 
 
 try:
     import readline
-except ImportError:
+except ImportError:  # pragma: no cover
     pass
 else:
     readline.parse_and_bind("tab: complete")
@@ -34,23 +37,34 @@
     try:
         readline.read_history_file(BASILISP_REPL_HISTORY_FILE_PATH)
         readline.set_history_length(BASILISP_REPL_HISTORY_LENGTH)
-    except FileNotFoundError:
+    except FileNotFoundError:  # pragma: no cover
         pass
-
-    atexit.register(readline.write_history_file, BASILISP_REPL_HISTORY_FILE_PATH)
+    except Exception:  # noqa  # pragma: no cover
+        # PyPy 3.6's ncurses implementation throws an error here
+        if platform.python_implementation() != "PyPy":
+            raise
+    else:
+        atexit.register(readline.write_history_file, BASILISP_REPL_HISTORY_FILE_PATH)
 
 
 @click.group()
 def cli():
     """Basilisp is a Lisp dialect inspired by Clojure targeting Python 3."""
-    pass
 
 
 def eval_file(filename: str, ctx: compiler.CompilerContext, module: types.ModuleType):
     """Evaluate a file with the given name into a Python module AST node."""
     last = None
     for form in reader.read_file(filename, resolver=runtime.resolve_alias):
-        last = compiler.compile_and_exec_form(form, ctx, module, filename)
+        last = compiler.compile_and_exec_form(form, ctx, module)
+    return last
+
+
+def eval_stream(stream, ctx: compiler.CompilerContext, module: types.ModuleType):
+    """Evaluate the forms in stdin into a Python module AST node."""
+    last = None
+    for form in reader.read(stream, resolver=runtime.resolve_alias):
+        last = compiler.compile_and_exec_form(form, ctx, module)
     return last
 
 
@@ -134,7 +148,7 @@ def repl(
             lsrc = input(f"{ns.name}=> ")
         except EOFError:
             break
-        except KeyboardInterrupt:
+        except KeyboardInterrupt:  # pragma: no cover
             print("")
             continue
 
@@ -143,7 +157,7 @@ def repl(
 
         try:
             result = eval_str(lsrc, ctx, ns.module, eof)
-            if result is eof:
+            if result is eof:  # pragma: no cover
                 continue
             print(runtime.lrepr(result))
             repl_module.mark_repl_result(result)
@@ -209,7 +223,11 @@ def run(  # pylint: disable=too-many-arguments
     """Run a Basilisp script or a line of code, if it is provided."""
     basilisp.init()
     ctx = compiler.CompilerContext(
-        filename=CLI_INPUT_FILE_PATH if code else file_or_code,
+        filename=CLI_INPUT_FILE_PATH
+        if code
+        else (
+            STDIN_INPUT_FILE_PATH if file_or_code == STDIN_FILE_NAME else file_or_code
+        ),
         opts={
             compiler.WARN_ON_SHADOWED_NAME: warn_on_shadowed_name,
             compiler.WARN_ON_SHADOWED_VAR: warn_on_shadowed_var,
@@ -222,16 +240,29 @@ def run(  # pylint: disable=too-many-arguments
     with runtime.ns_bindings(in_ns) as ns:
         if code:
             print(runtime.lrepr(eval_str(file_or_code, ctx, ns.module, eof)))
+        elif file_or_code == STDIN_FILE_NAME:
+            print(
+                runtime.lrepr(
+                    eval_stream(click.get_text_stream("stdin"), ctx, ns.module)
+                )
+            )
         else:
             print(runtime.lrepr(eval_file(file_or_code, ctx, ns.module)))
 
 
 @cli.command(short_help="run tests in a Basilisp project")
 @click.argument("args", nargs=-1)
-def test(args):
+def test(args):  # pragma: no cover
     """Run tests in a Basilisp project."""
     pytest.main(args=list(args))
 
 
+@cli.command(short_help="print the version of Basilisp")
+def version():
+    from basilisp.__version__ import __version__
+
+    print(f"Basilisp {__version__}")
+
+
 if __name__ == "__main__":
     cli()

tests/basilisp/cli_test.py

@@ -0,0 +1,77 @@
+import platform
+import re
+
+import pytest
+from click.testing import CliRunner
+
+from basilisp.cli import cli
+
+pytestmark = pytest.mark.skipif(
+    platform.python_implementation() == "PyPy", reason="CLI tests fail on PyPy 3.6"
+)
+
+
+class TestREPL:
+    def test_no_input(self):
+        runner = CliRunner()
+        result = runner.invoke(cli, ["repl"], input="")
+        assert "user=> " == result.stdout
+
+    def test_newline(self):
+        runner = CliRunner()
+        result = runner.invoke(cli, ["repl"], input="\n")
+        assert "user=> user=> " == result.stdout
+
+    def test_simple_expression(self):
+        runner = CliRunner()
+        result = runner.invoke(cli, ["repl"], input="(+ 1 2)")
+        assert "user=> 3\nuser=> " == result.stdout
+
+    def test_syntax_error(self):
+        runner = CliRunner()
+        result = runner.invoke(cli, ["repl"], input="(+ 1 2")
+        assert (
+            "basilisp.lang.reader.SyntaxError: Unexpected EOF in list\nuser=> "
+            in result.stdout
+        )
+
+    def test_compiler_error(self):
+        runner = CliRunner()
+        result = runner.invoke(cli, ["repl"], input="(fn*)")
+        assert (
+            "basilisp.lang.compiler.exception.CompilerException: fn form "
+            "must match: (fn* name? [arg*] body*) or (fn* name? method*)\nuser=> "
+        ) in result.stdout
+
+    def test_other_exception(self):
+        runner = CliRunner()
+        result = runner.invoke(
+            cli, ["repl"], input='(throw (builtins/Exception "CLI test"))'
+        )
+        assert "Exception: CLI test\nuser=> " in result.stdout
+
+
+class TestRun:
+    def test_run_code(self):
+        runner = CliRunner()
+        result = runner.invoke(cli, ["run", "-c", "(+ 1 2)"])
+        assert "3\n" == result.stdout
+
+    def test_run_file(self):
+        runner = CliRunner()
+        with runner.isolated_filesystem():
+            with open("test.lpy", mode="w") as f:
+                f.write("(+ 1 2)")
+            result = runner.invoke(cli, ["run", "test.lpy"])
+            assert "3\n" == result.stdout
+
+    def test_run_stdin(self):
+        runner = CliRunner()
+        result = runner.invoke(cli, ["run", "-"], input="(+ 1 2)")
+        assert "3\n" == result.stdout
+
+
+def test_version():
+    runner = CliRunner()
+    result = runner.invoke(cli, ["version"])
+    assert re.compile(r"^Basilisp (\d+)\.(\d+)\.(\w*)(\d+)\n$").match(result.stdout)