add CLI interface

Author: Deric-W

README.md

@@ -3,4 +3,33 @@
 ![Tests](https://github.com/Deric-W/lambda_repl/actions/workflows/Tests.yaml/badge.svg)
 [![codecov](https://codecov.io/gh/Deric-W/lambda_repl/branch/main/graph/badge.svg?token=SU3982mC17)](https://codecov.io/gh/Deric-W/lambda_repl)
 
-REPL for the lambda calculus, implemented in Python
+The `lambda_repl` package contains a [REPL](https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop) for the [lambda calculus](https://en.wikipedia.org/wiki/Lambda_calculus).
+
+To use it, execute `lambda-repl` or `python3 -m lambda_repl` and enter commands.
+
+## Requirements
+
+Python >= 3.10 and the `lambda_calculus` package are required to use this package.
+
+## Installation
+
+```sh
+python3 -m pip install lambda-repl
+```
+
+## Examples
+
+```
+python3 -m lambda_repl
+Welcome to the the Lambda REPL, type 'help' for help
+λ alias I = \x.x
+λ alias K = λx.λy.x
+λ aliases
+I = (λx.x)
+K = (λx.(λy.x))
+λ trace K a b
+β ((λy.a) b)
+β a
+λ exit
+Exiting REPL...
+```

lambda_repl/__init__.py

@@ -14,13 +14,14 @@
 from .parsing import LambdaTransformer
 from .aliases import Aliases
 
-__version__ = "0.6.0"
+__version__ = "1.0.0"
 __author__  = "Eric Niklas Wolf"
 __email__   = "eric_niklas.wolf@mailbox.tu-dresden.de"
 __all__ = (
     "LambdaREPL",
-    "parsing",
-    "aliases"
+    "aliases",
+    "main",
+    "parsing"
 )
 
 
@@ -38,6 +39,7 @@ def __init__(self, aliases: Aliases[str], transformer: LambdaTransformer, visito
         self.aliases = aliases
         self.transformer = transformer
         self.visitor = visitor
+        self.intro = "Welcome to the the Lambda REPL, type 'help' for help"
         self.prompt = "λ "
 
     def parse_term(self, term: str) -> Term[str] | None:
@@ -96,7 +98,7 @@ def do_alias(self, arg: str) -> bool:
     def do_aliases(self, _: object) -> bool:
         """list defined aliases"""
         for alias, term in self.aliases.items():
-            self.stdout.write(f"{alias}: {term}\n")
+            self.stdout.write(f"{alias} = {term}\n")
         return False
 
     def do_clear(self, arg: str) -> bool:

lambda_repl/__main__.py

@@ -0,0 +1,8 @@
+#!/usr/bin/python3
+
+"""CLI entry point"""
+
+import sys
+from .main import main_cli
+
+sys.exit(main_cli())

lambda_repl/main.py

@@ -0,0 +1,49 @@
+#!/usr/bin/python3
+
+"""CLI entry point utilities"""
+
+from argparse import ArgumentParser, Namespace, FileType
+from lambda_calculus.visitors.normalisation import BetaNormalisingVisitor
+from lambda_calculus.visitors.substitution.renaming import CountingSubstitution
+from . import LambdaREPL, __doc__ as description, __version__
+from .aliases import LetAliases
+from .parsing import LambdaTransformer
+
+__all__ = (
+    "ARGUMENT_PARSER",
+    "main",
+    "main_cli"
+)
+
+ARGUMENT_PARSER = ArgumentParser(description=description)
+ARGUMENT_PARSER.add_argument(
+    "-v",
+    "--version",
+    action="version",
+    version=f"%(prog)s {__version__}"
+)
+ARGUMENT_PARSER.add_argument(
+    "-f",
+    "--file",
+    type=FileType("r"),
+    help="file which should be executed in the REPL"
+)
+
+
+def main(args: Namespace) -> int:
+    """Entry point for the REPL"""
+    repl = LambdaREPL(
+        LetAliases(CountingSubstitution),
+        LambdaTransformer(),
+        BetaNormalisingVisitor()
+    )
+    if args.file is not None:
+        for line in args.file:
+            repl.cmdqueue.append(line)
+    repl.cmdloop()
+    return 0
+
+
+def main_cli() -> int:
+    """CLI entry point"""
+    return main(ARGUMENT_PARSER.parse_args())

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lambda_repl"
-version = "0.6.0"
+version = "1.0.0"
 description = "REPL for the lambda calculus"
 requires-python = ">=3.10"
 keywords = []
@@ -30,6 +30,9 @@ email = "eric_niklas.wolf@mailbox.tu-dresden.de"
 Repository = "https://github.com/Deric-W/lambda_repl"
 Bugtracker = "https://github.com/Deric-W/lambda_repl/issues"
 
+[project.scripts]
+lambda-repl = "lambda_repl.main:main_cli"
+
 [build-system]
 requires = ["setuptools >= 61.0.0"]
 build-backend = "setuptools.build_meta"

tests/test_aliases.py

@@ -23,12 +23,12 @@ def test_set(self) -> None:
         self.aliases["b"] = Variable("a").apply_to(Variable("c"))
         self.aliases["c"] = Variable("2")
         self.assertEqual(
-            self.aliases,
-            {
-                "a": Variable("1"),
-                "b": Variable("1").apply_to(Variable("c")),
-                "c": Variable("2")
-            }
+            list(self.aliases.items()),
+            [
+                ("a", Variable("1")),
+                ("b", Variable("1").apply_to(Variable("c"))),
+                ("c", Variable("2"))
+            ]
         )
 
     def test_override(self) -> None:
@@ -37,11 +37,11 @@ def test_override(self) -> None:
         self.aliases["b"] = Variable("a").apply_to(Variable("c"))
         self.aliases["a"] = Variable("2")
         self.assertEqual(
-            self.aliases,
-            {
-                "a": Variable("2"),
-                "b": Variable("1").apply_to(Variable("c")),
-            }
+            list(self.aliases.items()),
+            [
+                ("b", Variable("1").apply_to(Variable("c"))),
+                ("a", Variable("2"))
+            ]
         )
 
     def test_apply(self) -> None:

tests/test_repl.py

@@ -0,0 +1,139 @@
+#!/usr/bin/python3
+
+"""Tests for the REPL"""
+
+from io import StringIO
+from unittest import TestCase
+from lambda_calculus.terms import Variable
+from lambda_calculus.visitors.substitution.renaming import CountingSubstitution
+from lambda_calculus.visitors.normalisation import BetaNormalisingVisitor
+from lambda_repl import LambdaREPL
+from lambda_repl.aliases import LetAliases
+from lambda_repl.parsing import LambdaTransformer
+
+
+class REPLTest(TestCase):
+    """Test for the REPL"""
+
+    repl: LambdaREPL
+
+    stdin: StringIO
+
+    stdout: StringIO
+
+    def setUp(self) -> None:
+        """create a REPL"""
+        self.stdin = StringIO()
+        self.stdout = StringIO()
+        self.repl = LambdaREPL(
+            LetAliases(CountingSubstitution),
+            LambdaTransformer(),
+            BetaNormalisingVisitor(),
+            stdin=self.stdin,
+            stdout=self.stdout
+        )
+        self.repl.use_rawinput = False
+
+    def test_empty(self) -> None:
+        """test handling of empty lines"""
+        self.assertFalse(self.repl.onecmd(""))
+        self.assertEqual(self.stdout.getvalue(), "")
+
+    def test_evaluate(self) -> None:
+        """test evaluating terms"""
+        self.assertFalse(self.repl.onecmd(r"evaluate (\x.\y.x) a b"))
+        self.assertEqual(
+            self.stdout.getvalue(),
+            "a\n"
+        )
+
+    def test_eval(self) -> None:
+        """test eval alias"""
+        self.assertFalse(self.repl.onecmd(r"eval (\x.\y.x) a b"))
+        self.assertEqual(
+            self.stdout.getvalue(),
+            "a\n"
+        )
+
+    def test_trace(self) -> None:
+        """test tracing term evaluation"""
+        self.assertFalse(self.repl.onecmd(r"trace (\x.\y.x) a b"))
+        self.assertEqual(
+            self.stdout.getvalue(),
+            "β ((λy.a) b)\nβ a\n"
+        )
+
+    def test_syntax_error(self) -> None:
+        """test handling of syntax errors while parsing"""
+        self.assertFalse(self.repl.onecmd(r"eval (\x.\y.x) a b."))
+        self.assertTrue(self.stdout.getvalue().startswith("Error while parsing: "))
+        self.assertTrue(self.stdout.getvalue().endswith("\n"))
+
+    def test_alias(self) -> None:
+        """test setting aliases"""
+        self.assertFalse(self.repl.onecmd("alias a = b c"))
+        self.assertEqual(
+            self.repl.aliases,
+            {
+                "a": Variable("b").apply_to(Variable("c"))
+            }
+        )
+
+    def test_invalid_alias(self) -> None:
+        """test handling invalid aliases"""
+        self.assertFalse(self.repl.onecmd("alias a = b c."))
+        self.assertEqual(self.repl.aliases, {})
+        self.assertTrue(self.stdout.getvalue().startswith("Error while parsing: "))
+        self.assertTrue(self.stdout.getvalue().endswith("\n"))
+
+    def test_no_alias_value(self) -> None:
+        """test handling missing alias values"""
+        self.assertFalse(self.repl.onecmd("alias a"))
+        self.assertEqual(self.repl.aliases, {})
+        self.assertTrue(self.stdout.getvalue().startswith("invalid Command: "))
+        self.assertTrue(self.stdout.getvalue().endswith("\n"))
+
+    def test_aliases(self) -> None:
+        """test listing aliases"""
+        self.assertFalse(self.repl.onecmd("alias x = 1"))
+        self.assertFalse(self.repl.onecmd("alias a = x b"))
+        self.assertFalse(self.repl.onecmd("alias b = b c"))
+        self.assertFalse(self.repl.onecmd("aliases"))
+        self.assertEqual(
+            self.stdout.getvalue(),
+            "x = 1\na = (1 b)\nb = (b c)\n"
+        )
+
+    def test_clear(self) -> None:
+        """test clearing aliases"""
+        self.assertFalse(self.repl.onecmd("alias x = 1"))
+        self.assertFalse(self.repl.onecmd("alias a = x b"))
+        self.assertFalse(self.repl.onecmd("alias b = b c"))
+        self.assertFalse(self.repl.onecmd("clear x"))
+        self.assertEqual(
+            self.repl.aliases,
+            {
+                "a": Variable("1").apply_to(Variable("b")),
+                "b": Variable("b").apply_to(Variable("c"))
+            }
+        )
+        self.assertEqual(self.stdout.getvalue(), "")
+
+    def test_clear_all(self) -> None:
+        """test clearing all aliases"""
+        self.assertFalse(self.repl.onecmd("alias x = 1"))
+        self.assertFalse(self.repl.onecmd("alias a = x b"))
+        self.assertFalse(self.repl.onecmd("alias b = b c"))
+        self.assertFalse(self.repl.onecmd("clear"))
+        self.assertEqual(self.repl.aliases, {})
+        self.assertEqual(self.stdout.getvalue(), "")
+
+    def test_exit(self) -> None:
+        """test exiting the REPL"""
+        self.assertTrue(self.repl.onecmd("exit"))
+        self.assertTrue(self.stdout.getvalue().startswith("Exiting "))
+
+    def test_eof(self) -> None:
+        """test handling EOF"""
+        self.assertTrue(self.repl.onecmd("EOF"))
+        self.assertTrue(self.stdout.getvalue().startswith("Exiting "))