Rewrite response validation system

Author: neumond

computercraft/back.lua

@@ -22,15 +22,23 @@ while true do
         msg = textutils.unserializeJSON(p2)
         if msg.action == 'task' then
             local fn, err = loadstring(msg.code)
-            if fn ~= nil then
-                setfenv(fn, genv)
-                tasks[msg.task_id] = coroutine.create(fn)
-            else
+            if fn == nil then
                 ws.send(textutils.serializeJSON{
                     action='task_result',
                     task_id=msg.task_id,
                     result={false, err},
                 })
+            else
+                setfenv(fn, genv)
+                if msg.immediate then
+                    ws.send(textutils.serializeJSON{
+                        action='task_result',
+                        task_id=msg.task_id,
+                        result={fn()},
+                    })
+                else
+                    tasks[msg.task_id] = coroutine.create(fn)
+                end
             end
         elseif msg.action == 'sub' then
             event_sub[msg.event] = true

computercraft/rproc.py

@@ -0,0 +1,112 @@
+from .errors import LuaException
+
+
+def coro(result):
+    assert isinstance(result, list)
+    if len(result) < 2:
+        result.append(None)
+    assert len(result) == 2
+    success, result = result
+    assert isinstance(success, bool)
+    if not success:
+        raise LuaException(result)
+    return result
+
+
+def nil(result):
+    assert result is None
+    return result
+
+
+def boolean(result):
+    assert result is True or result is False
+    return result
+
+
+def integer(result):
+    assert isinstance(result, int)
+    assert not isinstance(result, bool)
+    return result
+
+
+def number(result):
+    assert isinstance(result, (int, float))
+    assert not isinstance(result, bool)
+    return result
+
+
+def string(result):
+    assert isinstance(result, str)
+    return result
+
+
+def any_dict(result):
+    assert isinstance(result, dict)
+    return result
+
+
+def any_list(result):
+    if result == {}:
+        result = []
+    assert isinstance(result, list)
+    return result
+
+
+def fact_tuple(*components):
+    def proc(result):
+        result = any_list(result)
+        assert len(components) == result
+        return tuple(comp(value) for comp, value in zip(components, result))
+    return proc
+
+
+def fact_array(component):
+    def proc(result):
+        result = any_list(result)
+        return [component(value) for value in result]
+    return proc
+
+
+def fact_option(component):
+    def proc(result):
+        if result is None:
+            return None
+        return component(result)
+    return proc
+
+
+def fact_union(*case_pairs, pelse):
+    def proc(result):
+        for detector, processor in case_pairs:
+            if detector(result):
+                return processor(result)
+        return pelse(result)
+    return proc
+
+
+def fact_scheme_dict(components):
+    def proc(result):
+        result = any_dict(result)
+        assert set(result.keys()) == set(components.keys())
+        return {key: component(result[key]) for key, component in components.items()}
+    return proc
+
+
+def fact_scheme_dict_kw(**components):
+    return fact_scheme_dict(components)
+
+
+def fact_mono_dict(key, value):
+    def proc(result):
+        result = any_dict(result)
+        return {key(k): value(v) for k, v in result.items()}
+    return proc
+
+
+tuple3_number = fact_tuple(number, number, number)
+tuple2_integer = fact_tuple(integer, integer)
+tuple3_integer = fact_tuple(integer, integer, integer)
+array_integer = fact_array(integer)
+array_string = fact_array(string)
+option_integer = fact_option(integer)
+option_string = fact_option(string)

computercraft/server.py

@@ -8,7 +8,7 @@
 import argparse
 
 from .subapis.root import RootAPIMixin
-from .errors import LuaException
+from . import rproc
 
 from .subapis.colors import ColorsAPI
 from .subapis.commands import CommandsAPI
@@ -101,24 +101,26 @@ def _new_task_id(self) -> str:
         self._task_autoid += 1
         return task_id
 
-    async def raw_eval(self, lua_code):
+    async def raw_eval(self, lua_code, immediate=False):
         task_id = self._new_task_id()
         self._result_locks[task_id] = asyncio.Event()
         await self._cmd.put({
             'action': 'task',
             'task_id': task_id,
             'code': lua_code,
+            'immediate': immediate,
         })
         await self._result_locks[task_id].wait()
         del self._result_locks[task_id]
-        return self._result_values.pop(task_id)
+        result = self._result_values.pop(task_id)
+        print('{} → {}'.format(lua_code, repr(result)))
+        return result
+
+    async def raw_eval_coro(self, lua_code):
+        return rproc.coro(await self.raw_eval(lua_code))
 
     async def _send_cmd(self, lua):
-        result = await self.raw_eval(lua)
-        print('{} → {}'.format(lua, result))
-        if not result[0]:
-            raise LuaException(*result[1:])
-        return result[1:]
+        return await self.raw_eval_coro(lua)
 
     async def _start_queue(self, event):
         task_id = self._new_task_id()
@@ -173,6 +175,12 @@ async def _launch_program(self, ws):
                     'error': 'protocol error',
                 })
                 return None
+            if len(msg['args']) == 0:
+                await ws.send_json({
+                    'action': 'close',
+                    'error': 'arguments required',
+                })
+                return None
             module = import_module(self['source_module'])
             program = getattr(module, msg['args'][0], None)
             if program is None:

computercraft/subapis/colors.py

@@ -1,6 +1,7 @@
 from typing import Tuple
 
-from .base import BaseSubAPI, bool_return, int_return
+from .base import BaseSubAPI
+from ..rproc import boolean, integer, tuple3_number
 
 
 class ColorsAPI(BaseSubAPI):
@@ -43,23 +44,16 @@ class ColorsAPI(BaseSubAPI):
     }
 
     async def combine(self, *colors: int) -> int:
-        return int_return(await self._send('combine', *colors))
+        return integer(await self._send('combine', *colors))
 
     async def subtract(self, color_set: int, *colors: int) -> int:
-        return int_return(await self._send('subtract', color_set, *colors))
+        return integer(await self._send('subtract', color_set, *colors))
 
     async def test(self, colors: int, color: int) -> bool:
-        return bool_return(await self._send('test', colors, color))
+        return boolean(await self._send('test', colors, color))
 
     async def packRGB(self, r: float, g: float, b: float) -> int:
-        return int_return(await self._send('packRGB', r, g, b))
+        return integer(await self._send('packRGB', r, g, b))
 
     async def unpackRGB(self, rgb: int) -> Tuple[float, float, float]:
-        ret = await self._send('unpackRGB', rgb)
-        assert isinstance(ret, list)
-        assert len(ret) == 3
-        return tuple(ret)
-
-    async def rgb8(self, *args):
-        r = await self._send('rgb8', *args)
-        return r[0] if len(r) == 1 else r
+        return tuple3_number(await self._send('unpackRGB', rgb))

computercraft/subapis/commands.py

@@ -1,12 +1,15 @@
 from typing import Tuple, List, Optional
-from .base import BaseSubAPI, int_return, list_return, dict_return
+
+from .base import BaseSubAPI
 from ..errors import CommandException
+from ..rproc import tuple3_integer, any_dict, any_list, array_string, integer
 
 
 class CommandsAPI(BaseSubAPI):
     _API = 'commands'
 
     async def exec(self, command: str) -> Tuple[str, Optional[int]]:
+        # TODO: use rproc
         r = await self._send('exec', command)
         assert len(r) == 3
         assert isinstance(r[0], bool)
@@ -26,19 +29,16 @@ async def exec(self, command: str) -> Tuple[str, Optional[int]]:
         return r[1], r[2]
 
     async def execAsync(self, command: str) -> int:
-        return int_return(await self._send('execAsync', command))
+        return integer(await self._send('execAsync', command))
 
     async def list(self) -> List[str]:
-        return list_return(await self._send('list'))
+        return array_string(await self._send('list'))
 
     async def getBlockPosition(self) -> Tuple[int, int, int]:
-        ret = await self._send('getBlockPosition')
-        assert isinstance(ret, list)
-        assert len(ret) == 3
-        return tuple(ret)
+        return tuple3_integer(await self._send('getBlockPosition'))
 
     async def getBlockInfo(self, x: int, y: int, z: int) -> dict:
-        return dict_return(await self._send('getBlockInfo', x, y, z))
+        return any_dict(await self._send('getBlockInfo', x, y, z))
 
     async def getBlockInfos(self, x1: int, y1: int, z1: int, x2: int, y2: int, z2: int) -> List[dict]:
-        return list_return(await self._send('getBlockInfos', x1, y1, z1, x2, y2, z2))
+        return any_list(await self._send('getBlockInfos', x1, y1, z1, x2, y2, z2))

computercraft/subapis/disk.py

@@ -1,39 +1,50 @@
 from typing import Optional, Union
-from .base import BaseSubAPI, nil_return, bool_return, opt_str_return, opt_int_return, opt_str_bool_return
+
+from .base import BaseSubAPI
+from ..rproc import boolean, string, nil, option_integer, option_string, fact_option, fact_union
+
+
+option_string_bool = fact_option(fact_union(
+    (
+        lambda v: v is True or v is False,
+        boolean,
+    ),
+    pelse=string,
+))
 
 
 class DiskAPI(BaseSubAPI):
     _API = 'disk'
 
     async def isPresent(self, side: str) -> bool:
-        return bool_return(await self._send('isPresent', side))
+        return boolean(await self._send('isPresent', side))
 
     async def hasData(self, side: str) -> bool:
-        return bool_return(await self._send('hasData', side))
+        return boolean(await self._send('hasData', side))
 
     async def getMountPath(self, side: str) -> Optional[str]:
-        return opt_str_return(await self._send('getMountPath', side))
+        return option_string(await self._send('getMountPath', side))
 
     async def setLabel(self, side: str, label: str):
-        return nil_return(await self._send('setLabel', side, label))
+        return nil(await self._send('setLabel', side, label))
 
     async def getLabel(self, side: str) -> Optional[str]:
-        return opt_str_return(await self._send('getLabel', side))
+        return option_string(await self._send('getLabel', side))
 
     async def getID(self, side: str) -> Optional[int]:
-        return opt_int_return(await self._send('getID', side))
+        return option_integer(await self._send('getID', side))
 
     async def hasAudio(self, side: str) -> bool:
-        return bool_return(await self._send('hasAudio', side))
+        return boolean(await self._send('hasAudio', side))
 
     async def getAudioTitle(self, side: str) -> Optional[Union[bool, str]]:
-        return opt_str_bool_return(await self._send('getAudioTitle', side))
+        return option_string_bool(await self._send('getAudioTitle', side))
 
     async def playAudio(self, side: str):
-        return nil_return(await self._send('playAudio', side))
+        return nil(await self._send('playAudio', side))
 
     async def stopAudio(self, side: str):
-        return nil_return(await self._send('stopAudio', side))
+        return nil(await self._send('stopAudio', side))
 
     async def eject(self, side: str):
-        return nil_return(await self._send('eject', side))
+        return nil(await self._send('eject', side))