Skip to content
Permalink
Browse files

Implement new AST: `assert`.

This is a new AST that will allow executing a
simple expression and conditionally pass/fail
and cleanup when it completes.
  • Loading branch information...
ConnorRigby committed Aug 20, 2019
1 parent a04ddf0 commit 7e1ceaf7be212352c7e2e6594e489c2afcecc0d0
@@ -56,3 +56,4 @@ nerves-hub
*.pem
*.db
*.db-journal
*.lua
@@ -0,0 +1,74 @@
# CeleryScript IF `expression` field.

The CeleryScript `if` block takes a possible left hand side value of
`expression` which allows an arbitrary string to be evaluated. This
expression is evaluated against a lua 5.2 interpreter.

## Lua API
The following functions are available for usage along with [Lua's
standard library](https://www.lua.org/manual/5.2/).

```lua
-- Comments are ignored by the interpreter
-- help(function_name)
-- Returns docs for a function
print(help("send_message"));
print(help("get_position"));
-- get_position()
-- Returns a table containing the current position data
position = get_position();
if position.x <= 20.55 then
return true;
else
print("current position: (", position.x, ",", position.y, "," position.z, ")");
return false;
end
-- get_pins()
-- Returns a table containing current pin data
pins = get_pins();
if pins[9] == 1.0 then
return true;
end
-- send_message(type, message, channels)
-- Sends a message to farmbot's logger
send_message("info", "hello, world", ["toast"])
```

## Expression contract
Expressions are expected to be evaluated in a certain way. The evaluation will fail
if this contract is not met. An expression should return one of the following values:
* `true`
* `false`
* `("error", "string reason signaling an error happened")`

### Examples

Check if the x position is within a range of 5 and 10

```lua
position = get_position();
return position.x >= 5 and position.x <= 10;
```

Check is a pin is a toggled, with error checking

```lua
-- All farmbot functions will return a tuple containing an error
-- if something bad happens
position, positionErr = get_position();
pins, pinErr = get_pins();
if positionErr or pinErr then
return "error", positionErr or pinErr;
else
return pins[9] == 1.0
end
```
@@ -166,8 +166,35 @@ defmodule FarmbotCeleryScript.Compiler do
end
end

# `Assert` is a internal node useful for self testing.
compile :assertion, %{lua: expression, op: op, _then: then_ast} do
quote location: :keep do
case FarmbotCeleryScript.SysCalls.eval_assertion(unquote(compile_ast(expression))) do
{:error, reason} ->
{:error, reason}

true ->
:ok

false when unquote(op) == "abort" ->
FarmbotCeleryScript.SysCalls.log("Assertion failed (aborting)")
{:error, "Assertion failed (aborting)"}

false when unquote(op) == "recover" ->
FarmbotCeleryScript.SysCalls.log("Assertion failed (recovering)")
unquote(compile_block(then_ast))

false when unquote(op) == "abort_recover" ->
FarmbotCeleryScript.SysCalls.log("Assertion failed (recovering then aborting)")
unquote(compile_block([then_ast, %AST{kind: :abort, args: %{}}]))
end
end
end

# Compiles an if statement.
compile :_if, %{_then: then_ast, _else: else_ast, lhs: lhs, op: op, rhs: rhs} do
rhs = compile_ast(rhs)

# Turns the left hand side arg into
# a number. x, y, z, and pin{number} are special that need to be
# evaluated before evaluating the if statement.
@@ -188,6 +215,10 @@ defmodule FarmbotCeleryScript.Compiler do
quote [location: :keep],
do: FarmbotCeleryScript.SysCalls.read_pin(unquote(String.to_integer(pin)), nil)

"expression" ->
quote [location: :keep],
do: FarmbotCeleryScript.SysCalls.eval_assertion(rhs)

# Named pin has two intents here
# in this case we want to read the named pin.
%AST{kind: :named_pin} = ast ->
@@ -198,8 +229,6 @@ defmodule FarmbotCeleryScript.Compiler do
compile_ast(ast)
end

rhs = compile_ast(rhs)

# Turn the `op` arg into Elixir code
if_eval =
case op do
@@ -238,6 +267,11 @@ defmodule FarmbotCeleryScript.Compiler do
quote location: :keep do
unquote(lhs) > unquote(rhs)
end

_ ->
quote location: :keep do
unquote(lhs)
end
end

# Finally, compile the entire if statement.
@@ -336,6 +370,12 @@ defmodule FarmbotCeleryScript.Compiler do
end
end

compile :abort do
quote location: :keep do
Macro.escape({:error, "aborted"})
end
end

# Compiles move_absolute
compile :move_absolute, %{location: location, offset: offset, speed: speed} do
quote location: :keep do
@@ -136,7 +136,7 @@ defmodule FarmbotCeleryScript.Scheduler do
end

def handle_info(:checkup, %{next: nil} = state) do
Logger.debug("Scheduling next checkup with no next")
# Logger.debug("Scheduling next checkup with no next")

state
|> schedule_next_checkup()
@@ -67,6 +67,20 @@ defmodule FarmbotCeleryScript.SysCalls do
@callback log(message :: String.t()) :: any()
@callback sequence_init_log(message :: String.t()) :: any()
@callback sequence_complete_log(message :: String.t()) :: any()
@callback eval_assertion(expression :: String.t()) :: true | false | error()

def eval_assertion(sys_calls \\ @sys_calls, expression) when is_binary(expression) do
case sys_calls.eval_assertion(expression) do
true ->
true

false ->
false

{:error, reason} when is_binary(reason) ->
or_error(sys_calls, :eval_assertion, [expression], reason)
end
end

def log(sys_calls \\ @sys_calls, message) when is_binary(message) do
apply(sys_calls, :log, [message])
@@ -129,6 +129,9 @@ defmodule FarmbotCeleryScript.SysCalls.Stubs do
@impl true
def zero(axis), do: error(:zero, [axis])

@impl true
def eval_assertion(expression), do: error(:eval_assertion, [expression])

defp error(fun, _args) do
msg = """
CeleryScript syscall stubbed: #{fun}
@@ -0,0 +1,56 @@
defmodule FarmbotOS.Lua do
@type t() :: tuple()
@type table() :: [{any, any}]
alias FarmbotOS.Lua.CeleryScript

@doc """
Evaluates some Lua code. The code should
return a boolean value.
"""
def eval_assertion(str) when is_binary(str) do
init()
|> set_table([:get_position], &CeleryScript.get_position/2)
|> set_table([:get_pins], &CeleryScript.get_pins/2)
|> set_table([:send_message], &CeleryScript.send_message/2)
|> set_table([:help], &CeleryScript.help/2)
|> set_table([:version], &CeleryScript.version/2)
|> eval(str)
|> case do
{:ok, [true | _]} ->
true

{:ok, [false | _]} ->
false

{:ok, [_, reason]} when is_binary(reason) ->
{:error, reason}

{:ok, _data} ->
{:error, "bad return value from expression evaluation"}

{:error, {:lua_error, _error, _lua}} ->
{:error, "lua runtime error evaluating expression"}

{:error, {:badmatch, {:error, [{line, :luerl_parse, parse_error}], _}}} ->
{:error, "failed to parse expression (line:#{line}): #{IO.iodata_to_binary(parse_error)}"}

error ->
error
end
end

@spec init() :: t()
def init do
:luerl.init()
end

@spec set_table(t(), Path.t(), any()) :: t()
def set_table(lua, path, value) do
:luerl.set_table(path, value, lua)
end

@spec eval(t(), String.t()) :: {:ok, any()} | {:error, any()}
def eval(lua, hook) when is_binary(hook) do
:luerl.eval(hook, lua)
end
end

0 comments on commit 7e1ceaf

Please sign in to comment.
You can’t perform that action at this time.