graphql: implement c-style expressions parser

Needed for tarantool#13

Author: Hollow111

graphql/core/init.lua

@@ -7,5 +7,6 @@ graphql.types = require(path .. '.types')
 graphql.schema = require(path .. '.schema')
 graphql.validate = require(path .. '.validate')
 graphql.execute = require(path .. '.execute')
+graphql.expressions = require(path .. '.expressions')
 
 return graphql

graphql/expressions.lua

@@ -0,0 +1,217 @@
+local lpeg = require('lulpeg')
+local P, R, S, V = lpeg.P, lpeg.R, lpeg.S, lpeg.V
+local C = lpeg.C
+
+-- Some special symbols.
+local space_symbol = S(' \t\r\n')
+local eof = P(-1)
+local some_spaces = space_symbol ^ 0
+
+--
+-- Possible identifier patterns:
+--   1) Number.
+local digit = R('09')
+local integer = (S('-+') ^ -1) * (digit ^ 1)
+local decimal = integer * '.' * (digit ^ 1)
+local number_pat = decimal + integer
+--   2) Boolean.
+local bool_pat = P('false') + P('true')
+--   3) String.
+local string_pat = P'\"' * C((P'\\"' + 1 - S'\"') ^ 0) * P'"'
+--   4) Variable.
+local variable_name = ('_' + R('az', 'AZ')) *
+                      (('_' + R('09', 'az', 'AZ')) ^ 0)
+--   5) Object's field path.
+local field = ('_' + R('az', 'AZ')) * ('_' + R('09', 'az', 'AZ')) ^ 0
+local field_path = field * ('.' * field) ^ 0
+
+--
+-- Possible logical function patterns:
+--   1) is_null.
+local is_null = P('is_null')
+--   2) not_null.
+local not_null = P('not_null')
+--   3) regexp.
+local regexp = P('regexp')
+
+--
+-- Possible unary operator patterns:
+--   1) Logical negation.
+local negation = P('!')
+
+-- Possible binary operator patterns:
+--   1) Logical and.
+local logic_and = P('&&')
+--   2) logical or.
+local logic_or = P('||')
+--   3) +
+local addition = P('+')
+--   4) -
+local subtraction = P('-')
+--   5) ==
+local eq = P('==')
+--   6) !=
+local not_eq = P('!=')
+--   7) >
+local gt = P('>')
+--   8) >=
+local ge = P('>=')
+--   9) <
+local lt = P('<')
+--   10) <=
+local le = P('<=')
+
+--
+-- AST nodes generating functions.
+--
+local function identical(arg)
+    return arg
+end
+
+local function root_expr_node(expr)
+    return {
+        kind = 'root_expression',
+        entity = expr
+    }
+end
+
+local function bin_op_node(...)
+    local args = {...}
+    if select('#', ...) == 1 then
+        return identical(args[1])
+    end
+    local operators, nodes = {}, {}
+    for i, v in ipairs(args) do
+        if i % 2 == 0 then
+            table.insert(operators, v)
+        else
+            table.insert(nodes, v)
+        end
+    end
+    return {
+        kind = 'binary_operations',
+        operators = operators,
+        nodes = nodes
+    }
+--    return {
+--        kind = 'binary_operation',
+--        op = binary_operator,
+--        node_1 = operand_1,
+--        node_2 = operand_2
+--    }
+end
+
+local function unary_op_node(unary_operator, operand_1)
+    return {
+        kind = 'unary_operation',
+        op = unary_operator,
+        node = operand_1
+    }
+end
+
+local function func_node(name, ...)
+    local args = {...}
+    return {
+        kind = 'function',
+        name = name,
+        args = args
+    }
+end
+
+local function op_name(string)
+    return string
+end
+
+local function number_node(value)
+    return {
+        kind = 'const',
+        data_class = 'number',
+        value = value
+    }
+end
+
+local function string_node(value)
+    return {
+        kind = 'const',
+        data_class = 'string',
+        value = value
+    }
+end
+
+local function bool_node(value)
+    return {
+        kind = 'const',
+        data_class = 'bool',
+        value = value
+    }
+end
+
+local function variable_node(name)
+    return {
+        kind = 'variable',
+        name = name
+    }
+end
+
+local function path_node(path)
+    return {
+        kind = 'object_field',
+        path = path
+    }
+end
+
+-- Patterns returning corresponding nodes.
+local _number = number_pat / number_node
+local _bool = bool_pat / bool_node
+local _string = string_pat / string_node
+local _variable = '$' * C(variable_name) / variable_node
+local _field_path = field_path / path_node
+
+local _logic_or = logic_or / op_name
+local _logic_and = logic_and / op_name
+local _comparison_op = (eq + not_eq + ge + gt + le + lt) / op_name
+local _arithmetic_op = (addition + subtraction) / op_name
+local _unary_op = negation / op_name
+local _functions = (is_null + not_null + regexp) / identical
+
+--
+-- Grammar rules for C-style expressions positioned ascending in
+-- terms of priority.
+--
+local expression_grammar = P {
+    'init_expr',
+    init_expr = V('expr') * eof / root_expr_node,
+    expr = some_spaces * V('log_expr_or') * some_spaces / identical,
+
+    log_expr_or = V('log_expr_and') * (some_spaces * _logic_or *
+                  some_spaces * V('log_expr_and')) ^ 0 / bin_op_node,
+    log_expr_and = V('comparison') * (some_spaces * _logic_and *
+                   some_spaces * V('comparison')) ^ 0 / bin_op_node,
+    comparison = V('arithmetic_expr') * (some_spaces * _comparison_op *
+                 some_spaces * V('arithmetic_expr')) ^ 0 / bin_op_node,
+    arithmetic_expr = V('unary_expr') * (some_spaces * _arithmetic_op *
+                      some_spaces * V('unary_expr')) ^ 0 / bin_op_node,
+
+    unary_expr = (_unary_op * V('first_prio') / unary_op_node) +
+            (V('first_prio') / identical),
+    first_prio = (V('_function') + V('identifier') + '(' * some_spaces *
+            V('expr') * some_spaces * ')') / identical,
+    _function = _functions * '(' * some_spaces * (V('identifier') *
+            some_spaces * ',' * some_spaces) ^ 0 * V('identifier')
+            * some_spaces * ')' / func_node,
+    identifier = (_bool + _number + _string + _variable + _field_path) /
+            identical
+}
+
+--
+--
+--
+
+
+--
+-- Parsing function.
+--
+return function(str)
+    assert(type(str) == 'string', 'parser expects a string')
+    return expression_grammar:match(str) or error('syntax error', 2)
+end