Split the web REPL into its own file (#114)

Also make the Dockerfile only handle web stuff

.args

···
--m
-scrapscript
-...

.github/workflows/ci.yml

···
         push: true
         tags: ${{ steps.meta.outputs.tags }}
         labels: ${{ steps.meta.outputs.labels }}
-    - name: Try a little hello world
-      run: docker run ${{ steps.meta.outputs.tags }} apply "1 + 2"
   deploy:
     runs-on: ubuntu-latest
     if: |

.github/workflows/stage.yml

···
 
       - name: Deploy
         id: deploy
-        uses: superfly/fly-pr-review-apps@1.2.0
+        uses: superfly/fly-pr-review-apps@1.2.1
         with:
           name: scrapscript-pr-${{ github.event.number }}
           region: ewr

Dockerfile

···
 RUN sh bin/zip -A --delete bin/python "Lib/site-packages/*"
 RUN mkdir Lib
 COPY scrapscript.py Lib
-COPY .args .
+COPY webrepl.py Lib
 RUN bin/ape.elf bin/python -m compileall Lib
 RUN mv Lib/__pycache__/scrapscript*.pyc Lib/scrapscript.pyc
+RUN mv Lib/__pycache__/webrepl*.pyc Lib/webrepl.pyc
 RUN rm Lib/scrapscript.py
+RUN rm Lib/webrepl.py
 RUN cp bin/python bin/scrapscript.com
 COPY style.css Lib
 COPY repl.html Lib
+RUN printf "-m\nwebrepl\n..." > .args
 RUN sh bin/zip -A -r bin/scrapscript.com Lib .args
 RUN bin/ape.elf bin/assimilate bin/scrapscript.com
 
 # Set up the container
-FROM scratch
+FROM scratch as webrepl
 COPY --from=build /cosmo/bin/scrapscript.com .
 EXPOSE 8000
 ENTRYPOINT ["./scrapscript.com"]
-CMD ["repl"]

fly.toml

···
   memory_mb = 256
 
 [experimental]
-cmd = ["serve", "--port", "8000", "--debug", "--fork"]
+cmd = ["--port", "8000", "--debug", "--fork"]

scrapscript.py

···
 import code
 import dataclasses
 import enum
-import http.server
 import json
 import logging
 import os
 import re
-import socketserver
 import sys
 import typing
 import unittest
-import urllib.parse
 import urllib.request
 from dataclasses import dataclass
 from enum import auto
···
         if isinstance(result, EnvObject):
             return result, ScrapMonad({**env, **result.env})
         return result, ScrapMonad({**env, "_": result})
-
-
-ASSET_DIR = os.path.dirname(__file__)
-
-
-class ScrapReplServer(http.server.SimpleHTTPRequestHandler):
-    def do_GET(self) -> None:
-        logger.debug("GET %s", self.path)
-        parsed_path = urllib.parse.urlsplit(self.path)
-        query = urllib.parse.parse_qs(parsed_path.query)
-        logging.debug("PATH %s", parsed_path)
-        logging.debug("QUERY %s", query)
-        if parsed_path.path == "/repl":
-            return self.do_repl()
-        if parsed_path.path == "/eval":
-            try:
-                return self.do_eval(query)
-            except Exception as e:
-                self.send_response(400)
-                self.send_header("Content-type", "text/plain")
-                self.end_headers()
-                self.wfile.write(str(e).encode("utf-8"))
-                return
-        if parsed_path.path == "/style.css":
-            self.send_response(200)
-            self.send_header("Content-type", "text/css")
-            self.end_headers()
-            with open(os.path.join(ASSET_DIR, "style.css"), "rb") as f:
-                self.wfile.write(f.read())
-            return
-        return self.do_404()
-
-    def do_repl(self) -> None:
-        self.send_response(200)
-        self.send_header("Content-type", "text/html")
-        self.end_headers()
-        with open(os.path.join(ASSET_DIR, "repl.html"), "rb") as f:
-            self.wfile.write(f.read())
-        return
-
-    def do_404(self) -> None:
-        self.send_response(404)
-        self.send_header("Content-type", "text/html")
-        self.end_headers()
-        self.wfile.write(b"""try hitting <a href="/repl">/repl</a>""")
-        return
-
-    def do_eval(self, query: Dict[str, Any]) -> None:
-        exp = query.get("exp")
-        if exp is None:
-            raise TypeError("Need expression to evaluate")
-        if len(exp) != 1:
-            raise TypeError("Need exactly one expression to evaluate")
-        exp = exp[0]
-        tokens = tokenize(exp)
-        ast = parse(tokens)
-        env = query.get("env")
-        if env is None:
-            env = STDLIB
-        else:
-            if len(env) != 1:
-                raise TypeError("Need exactly one env")
-            env_object = deserialize(env[0])
-            assert isinstance(env_object, EnvObject)
-            env = env_object.env
-        logging.debug("env is %s", env)
-        monad = ScrapMonad(env)
-        result, next_monad = monad.bind(ast)
-        serialized = EnvObject(next_monad.env).serialize()
-        encoded = bencode(serialized)
-        response = {"env": encoded.decode("utf-8"), "result": str(result)}
-        self.send_response(200)
-        self.send_header("Content-type", "text/plain")
-        self.send_header("Cache-Control", "max-age=3600")
-        self.end_headers()
-        self.wfile.write(json.dumps(response).encode("utf-8"))
-        return
 
 
 class TokenizerTests(unittest.TestCase):
···
     unittest.main(argv=[__file__, *args.unittest_args])
 
 
-def serve_command(args: argparse.Namespace) -> None:
-    if args.debug:
-        logging.basicConfig(level=logging.DEBUG)
-    server: Union[type[socketserver.TCPServer], type[socketserver.ForkingTCPServer]]
-    if args.fork:
-        server = socketserver.ForkingTCPServer
-    else:
-        server = socketserver.TCPServer
-    server.allow_reuse_address = True
-    with server(("", args.port), ScrapReplServer) as httpd:
-        host, port = httpd.server_address
-        print(f"serving at http://{host!s}:{port}")
-        httpd.serve_forever()
-
-
 def main() -> None:
     parser = argparse.ArgumentParser(prog="scrapscript")
     subparsers = parser.add_subparsers(dest="command")
···
     apply.set_defaults(func=apply_command)
     apply.add_argument("program")
     apply.add_argument("--debug", action="store_true")
-
-    serve = subparsers.add_parser("serve")
-    serve.set_defaults(func=serve_command)
-    serve.add_argument("--port", type=int, default=8000)
-    serve.add_argument("--debug", action="store_true")
-    serve.add_argument("--fork", action="store_true")
 
     args = parser.parse_args()
     if not args.command:

webrepl.py

···
+#!/usr/bin/env python3.10
+import argparse
+import logging
+import http.server
+import urllib.parse
+import socketserver
+import os
+import json
+from scrapscript import ScrapMonad, parse, tokenize, deserialize, EnvObject, bencode, STDLIB
+from typing import Any, Dict, Union
+
+
+ASSET_DIR = os.path.dirname(__file__)
+logger = logging.getLogger(__name__)
+
+
+class ScrapReplServer(http.server.SimpleHTTPRequestHandler):
+    def do_GET(self) -> None:
+        logger.debug("GET %s", self.path)
+        parsed_path = urllib.parse.urlsplit(self.path)
+        query = urllib.parse.parse_qs(parsed_path.query)
+        logger.debug("PATH %s", parsed_path)
+        logger.debug("QUERY %s", query)
+        if parsed_path.path == "/repl":
+            return self.do_repl()
+        if parsed_path.path == "/eval":
+            try:
+                return self.do_eval(query)
+            except Exception as e:
+                self.send_response(400)
+                self.send_header("Content-type", "text/plain")
+                self.end_headers()
+                self.wfile.write(str(e).encode("utf-8"))
+                return
+        if parsed_path.path == "/style.css":
+            self.send_response(200)
+            self.send_header("Content-type", "text/css")
+            self.end_headers()
+            with open(os.path.join(ASSET_DIR, "style.css"), "rb") as f:
+                self.wfile.write(f.read())
+            return
+        return self.do_404()
+
+    def do_repl(self) -> None:
+        self.send_response(200)
+        self.send_header("Content-type", "text/html")
+        self.end_headers()
+        with open(os.path.join(ASSET_DIR, "repl.html"), "rb") as f:
+            self.wfile.write(f.read())
+        return
+
+    def do_404(self) -> None:
+        self.send_response(404)
+        self.send_header("Content-type", "text/html")
+        self.end_headers()
+        self.wfile.write(b"""try hitting <a href="/repl">/repl</a>""")
+        return
+
+    def do_eval(self, query: Dict[str, Any]) -> None:
+        exp = query.get("exp")
+        if exp is None:
+            raise TypeError("Need expression to evaluate")
+        if len(exp) != 1:
+            raise TypeError("Need exactly one expression to evaluate")
+        exp = exp[0]
+        tokens = tokenize(exp)
+        ast = parse(tokens)
+        env = query.get("env")
+        if env is None:
+            env = STDLIB
+        else:
+            if len(env) != 1:
+                raise TypeError("Need exactly one env")
+            env_object = deserialize(env[0])
+            assert isinstance(env_object, EnvObject)
+            env = env_object.env
+        logger.debug("env is %s", env)
+        monad = ScrapMonad(env)
+        result, next_monad = monad.bind(ast)
+        serialized = EnvObject(next_monad.env).serialize()
+        encoded = bencode(serialized)
+        response = {"env": encoded.decode("utf-8"), "result": str(result)}
+        self.send_response(200)
+        self.send_header("Content-type", "text/plain")
+        self.send_header("Cache-Control", "max-age=3600")
+        self.end_headers()
+        self.wfile.write(json.dumps(response).encode("utf-8"))
+        return
+
+
+def serve(args: argparse.Namespace) -> None:
+    if args.debug:
+        logging.basicConfig(level=logging.DEBUG)
+    server: Union[type[socketserver.TCPServer], type[socketserver.ForkingTCPServer]]
+    if args.fork:
+        server = socketserver.ForkingTCPServer
+    else:
+        server = socketserver.TCPServer
+    server.allow_reuse_address = True
+    with server(("", args.port), ScrapReplServer) as httpd:
+        host, port = httpd.server_address
+        print(f"serving at http://{host!s}:{port}")
+        httpd.serve_forever()
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(prog="webrepl")
+    parser.add_argument("--port", type=int, default=8000)
+    parser.add_argument("--debug", action="store_true")
+    parser.add_argument("--fork", action="store_true")
+    args = parser.parse_args()
+    serve(args)
+
+
+if __name__ == "__main__":
+    main()