graphql: implement expressions parser and executor

Implement c-style filter expressions for graphql objects. Introduced
module containing parser and executor for them.

Needed for #13

Author: Hollow111

graphql/expressions.lua

@@ -1,4 +1,20 @@
 local lpeg = require('lulpeg')
+local utils = require('graphql.utils')
+local rex, is_pcre2 = utils.optional_require_rex()
+local bit = require('bit')
+
+--- NOTE: Functions that worth moving out into other modules:
+---       1) Regexp implementation (also lies inside of
+---          accessor_general.lua)
+---       2) Vararg iterator.
+
+--- TODO:
+---     1) Validation.
+---     2) Big numbers.
+---     3) Absence of variable in context.variables is equal
+---        to the situation when context.variables.var == nil.
+---     4) In case you change string inside of an expression
+---        object you need to manually change ast in object.
 
 local expressions = {}
 local P, R, S, V = lpeg.P, lpeg.R, lpeg.S, lpeg.V
@@ -220,6 +236,26 @@ local expression_grammar = P {
     value_terminal = (_literal + _variable + _field_path) / identical_node
 }
 
+-- Add one number to another.
+--
+-- It may be changed after introduction of "big ints".
+--
+-- @param operand_1
+-- @param operand_2
+--
+local function sum(operand_1, operand_2)
+    return operand_1 + operand_2
+end
+
+-- Subtract one number from another.
+--
+-- It may be changed after introduction of "big ints".
+-- @param operand_1
+-- @param operand_2
+local function subtract(operand_1, operand_2)
+    return operand_1 - operand_2
+end
+
 --- Parse given string which supposed to be a c-style expression.
 ---
 --- @tparam str string representation of expression.
@@ -230,4 +266,207 @@ function expressions.parse(str)
     return expression_grammar:match(str) or error('syntax error')
 end
 
+--function expressions.validate(context)
+--
+--end
+
+--- Recursively execute the syntax subtree. Of course it can be
+--- syntax tree itself.
+---
+--- @tparam node    node to be executed.
+---
+--- @tparam context table containing information useful for
+---                 execution (see @{expressions.new}).
+---
+--- @treturn subtree value.
+function expressions.execute(node, context)
+    if node.kind == 'const' then
+        if node.value_class == 'string' then
+            return node.value
+        end
+
+        if node.value_class == 'bool' then
+            if node.value == 'false' then
+                return false
+            end
+            return true
+        end
+
+        if node.value_class == 'number' then
+            return tonumber(node.value)
+        end
+    end
+
+    if node.kind == 'variable' then
+        local name = node.name
+        return context.variables[name]
+    end
+
+    if node.kind == 'object_field' then
+        local path = node.path
+        local field = context.object
+        local table_path = (path:split('.'))
+        for i = 1, #table_path do
+            field = field[table_path[i]]
+        end
+        return field
+    end
+
+    if node.kind == 'func' then
+        -- regexp() implementation.
+        if node.name == 'regexp' then
+            local flags = rex.flags()
+            local cfg = 0
+            local pattern = expressions.execute(node.args[1], context)
+            local str = expressions.execute(node.args[2], context)
+            if not is_pcre2 then
+                local cnt
+                pattern, cnt = pattern:gsub('^%(%?i%)', '')
+                if cnt > 0 then
+                    cfg = bit.bor(cfg, flags.CASELESS)
+                end
+            end
+            if is_pcre2 then
+                cfg = bit.bor(cfg, flags.UTF)
+                cfg = bit.bor(cfg, flags.UCP)
+            else
+                cfg = bit.bor(cfg, flags.UTF8)
+                cfg = bit.bor(cfg, flags.UCP)
+            end
+            local pattern = rex.new(pattern, cfg)
+            if not pattern:match(str) then
+                return false
+            end
+            return true
+        end
+
+        -- is_null() implementation.
+        if node.name == 'is_null' then
+            return expressions.execute(node.args[1], context) == nil
+        end
+
+        -- not_null() implementation.
+        if node.name == 'not_null' then
+            return expressions.execute(node.args[1], context) ~= nil
+        end
+    end
+
+    if node.kind == 'unary_operation' then
+        -- Negation.
+        if node.op == '!' then
+            return not expressions.execute(node.node, context)
+        end
+
+        -- Unary '+'.
+        if node.op == '+' then
+            return expressions.execute(node.node, context)
+        end
+
+        -- Unary '-'.
+        if node.op == '-' then
+            return -expressions.execute(node.node, context)
+        end
+    end
+
+    if node.kind == 'binary_operations' then
+        local prev = expressions.execute(node.operands[1], context)
+        for i, op in ipairs(node.operators) do
+            local second_operand = expressions.execute(node.operands[i + 1],
+                                                       context)
+            -- Sum.
+            if op == '+' then
+                prev = sum(prev, second_operand)
+            end
+
+            -- Subtraction.
+            if op == '-' then
+                prev = subtract(prev, second_operand)
+            end
+
+            -- Logical and.
+            if op == '&&' then
+                prev = prev and second_operand
+            end
+
+            -- Logical or.
+            if op == '||' then
+                prev = prev or second_operand
+            end
+
+            -- Equal.
+            if op == '==' then
+                prev = prev == second_operand
+            end
+
+            -- Not equal.
+            if op == '!=' then
+                prev = prev ~= second_operand
+            end
+
+            -- Greater than.
+            if op == '>' then
+                prev = prev > second_operand
+            end
+
+            -- Greater or equal.
+            if op == '>=' then
+                prev = prev >= second_operand
+            end
+
+            -- Lower than.
+            if op == '<' then
+                prev = prev < second_operand
+            end
+
+            -- Lower or equal.
+            if op == '&&' then
+                prev = prev and second_operand
+            end
+        end
+        return prev
+    end
+
+    if node.kind == 'root_expression' then
+        return expressions.execute(node.expr, context)
+    end
+end
+
+
+--- Compile and execute given string that represents a c-style
+--- expression.
+---
+--- @tparam str       string representation of expression.
+--- @tparam object    object considered inside of an expression.
+--- @tparam variables list of variables.
+---
+--- @treturn expression value.
+function expressions.compile_and_execute(str, object, variables)
+    local context = expressions.new(str, object, variables)
+    return expressions.execute(context.ast, context)
+end
+
+--- Create a new c-style expression object.
+---
+--- @tparam str       string representation of expression.
+--- @tparam object    object considered inside of an expression.
+--- @tparam variables list of variables.
+---
+--- @treturn expression object.
+function expressions.new(str, object, variables)
+    return setmetatable({
+        string = str,
+        object = object,
+        variables = variables,
+    }, {
+        __index = function(self, key)
+            if key == 'ast' then
+                return expressions.parse(self.string)
+            end
+            if key == 'execute' then
+                return expressions.execute(self.ast, self)
+            end
+        end
+    })
+end
+
 return expressions

test/unit/expr_execute.test.lua

@@ -0,0 +1,36 @@
+#!/usr/bin/env tarantool
+
+local expressions = require('graphql.expressions')
+local tap = require('tap')
+local test = tap.test('expr_tree')
+
+test:plan(8)
+
+local str = '2 + 2'
+local expr = expressions.new(str)
+test:is(expr.execute, 4)
+
+test:is(expressions.compile_and_execute(str), 4)
+
+str = 'true && ($variable + 7 == field.path_1 && !(2399>23941)) && !false'
+expr = expressions.new(str, {node_1 = {node_2 = 21},
+    field = {path_1 = 28}}, {variable = 21})
+test:is(expr.execute, true)
+
+test:is(expressions.compile_and_execute(str, {node_1 = {node_2 = 21},
+    field = {path_1 = 28}},
+    {variable = 21}), true)
+
+str = 'false || (regexp("abc", $var)) && (is_null(path.ddf))|| not_null(path.ddf)'
+expr = expressions.new(str, {path = {ddf = 'hi_there'}}, {var = 'abc'})
+test:is(expr.execute, true)
+
+test:is(expressions.compile_and_execute(str, {path = {ddf = 'hi_there'}},
+    {var = 'abc'}), true)
+
+str = 'false || (regexp("abc", $var)) && (is_null(path.ddf))|| is_null(path.ddf)'
+expr = expressions.new(str, {path = {ddf = 'hi_there'}}, {var = 'abc'})
+test:is(expr.execute, false)
+
+test:is(expressions.compile_and_execute(str, {path = {ddf = 'hi_there'}},
+    {var = 'abc'}), false)