cel 0.1.2 → 0.2.1

data/lib/cel/ast/types.rb

@@ -14,6 +14,8 @@ module Cel
       @type.to_s
     end
 
+    alias_method :to_s, :to_str
+
     def type
       TYPES[:type]
     end
@@ -32,6 +34,10 @@ module Cel
         Bytes.new(value.bytes)
       when :bool
         Bool.new(value)
+      when :timestamp
+        Timestamp.new(value)
+      when :duration
+        Duration.new(value)
       when :any
         value
       else
@@ -52,6 +58,14 @@ module Cel
     def get(idx)
       @type_list[idx]
     end
+
+    def ==(other)
+      other == :list || super
+    end
+
+    def cast(value)
+      List.new(value)
+    end
   end
 
   class MapType < Type
@@ -67,12 +81,45 @@ module Cel
       _, value = @type_map.find { |k, _| k == attrib.to_s }
       value
     end
+
+    def ==(other)
+      other == :map || super
+    end
+
+    def cast(value)
+      Map.new(value)
+    end
   end
 
   # Primitive Cel Types
 
-  PRIMITIVE_TYPES = %i[int uint double bool string bytes list map null_type type].freeze
-  TYPES = PRIMITIVE_TYPES.to_h { |typ| [typ, Type.new(typ)] }
+  PRIMITIVE_TYPES = %i[int uint double bool string bytes list map timestamp duration null_type type].freeze
+  COLTYPES = %i[list map].freeze
+  TYPES = (PRIMITIVE_TYPES - COLTYPES).to_h { |typ| [typ, Type.new(typ)] }
   TYPES[:type] = Type.new(:type)
   TYPES[:any] = Type.new(:any)
+
+  module CollectionTypeFetch
+    def [](*args)
+      col_type, elem_type = args
+
+      return super unless COLTYPES.include?(col_type)
+
+      return super if args.size > 2
+
+      elem_type ||= :any
+
+      type = case col_type
+             when :list
+               ListType.new([])
+             when :map
+               MapType.new({})
+      end
+
+      type.element_type = super(*elem_type)
+      type
+    end
+  end
+
+  TYPES.singleton_class.prepend(CollectionTypeFetch)
 end

data/lib/cel/checker.rb

@@ -31,10 +31,9 @@ module Cel
       Checker.new(@declarations ? @declarations.merge(declarations) : declarations)
     end
 
-    # TODO: add protobuf timestamp and duration
-    LOGICAL_EXPECTED_TYPES = %i[bool int uint double string bytes].freeze
-    ADD_EXPECTED_TYPES = %i[int uint double string bytes list].freeze
-    SUB_EXPECTED_TYPES = %i[int uint double].freeze
+    LOGICAL_EXPECTED_TYPES = %i[bool int uint double string bytes timestamp duration].freeze
+    ADD_EXPECTED_TYPES = %i[int uint double string bytes list duration].freeze
+    SUB_EXPECTED_TYPES = %i[int uint double duration].freeze
     MULTIDIV_EXPECTED_TYPES = %i[int uint double].freeze
     REMAINDER_EXPECTED_TYPES = %i[int uint].freeze
 
@@ -73,26 +72,48 @@ module Cel
       else
 
         case op
-        when "&&", "||", "==", "!=", "<", "<=", ">=", ">"
-          return TYPES[:bool]
+        when "&&", "||", "<", "<=", ">=", ">"
+          return TYPES[:bool] if find_match_all_types(LOGICAL_EXPECTED_TYPES, values) || values.include?(:any)
+        when "!=", "=="
+          return TYPES[:bool] if values.uniq.size == 1 ||
+                                 values.all? { |v| v == :list } ||
+                                 values.all? { |v| v == :map } ||
+                                 values.include?(:any)
         when "in"
-          return TYPES[:bool] if find_match_all_types(%i[list map], values.last)
+          return TYPES[:bool] if find_match_all_types(%i[list map any], values.last)
         when "+"
-          if (type = find_match_all_types(ADD_EXPECTED_TYPES, values))
-            return type
-          end
+          return type if (type = find_match_all_types(ADD_EXPECTED_TYPES, values))
+
+          return TYPES[:timestamp] if %i[timestamp duration].any? { |typ| values.first == typ }
+
+          return values.last if values.first == :any
+
         when "-"
-          if (type = find_match_all_types(SUB_EXPECTED_TYPES, values))
-            return type
+          return type if (type = find_match_all_types(SUB_EXPECTED_TYPES, values))
+
+          case values.first
+          when TYPES[:timestamp]
+            return TYPES[:duration] if values.last == :timestamp
+
+            return TYPES[:timestamp] if values.last == :duration
+
+            return TYPES[:any] if values.last == :any
+
+          when TYPES[:any]
+            return values.last
           end
         when "*", "/"
-          if (type = find_match_all_types(MULTIDIV_EXPECTED_TYPES, values))
-            return type
-          end
+          return type if (type = find_match_all_types(MULTIDIV_EXPECTED_TYPES, values))
+
+          values.include?(:any)
+          values.find { |typ| typ != :any } || TYPES[:any]
+
         when "%"
-          if (type = find_match_all_types(REMAINDER_EXPECTED_TYPES, values))
-            return type
-          end
+          return type if (type = find_match_all_types(REMAINDER_EXPECTED_TYPES, values))
+
+          values.include?(:any)
+          values.find { |typ| typ != :any } || TYPES[:any]
+
         else
           unsupported_type(operation)
         end
@@ -100,6 +121,17 @@ module Cel
       unsupported_type(operation)
     end
 
+    def infer_variable_type(var)
+      case var
+      when Identifier
+        check_identifier(var)
+      when Invoke
+        check_invoke(var)
+      else
+        var.type
+      end
+    end
+
     def check_invoke(funcall, var_type = nil)
       var = funcall.var
       func = funcall.func
@@ -107,14 +139,7 @@ module Cel
 
       return check_standard_func(funcall) unless var
 
-      var_type ||= case var
-                   when Identifier
-                     check_identifier(var)
-                   when Invoke
-                     check_invoke(var)
-                   else
-                     var.type
-      end
+      var_type ||= infer_variable_type(var)
 
       case var_type
       when MapType
@@ -123,7 +148,7 @@ module Cel
         case func
         when :[]
           attribute = var_type.get(args)
-          unsupported_operation(funcall) unless attribute
+          return TYPES[:any] unless attribute
         when :all, :exists, :exists_one
           check_arity(funcall, args, 2)
           identifier, predicate = args
@@ -137,7 +162,7 @@ module Cel
           return TYPES[:bool]
         else
           attribute = var_type.get(func)
-          unsupported_operation(funcall) unless attribute
+          return TYPES[:any] unless attribute
         end
 
         call(attribute)
@@ -153,6 +178,8 @@ module Cel
 
           unsupported_type(funcall) unless identifier.is_a?(Identifier)
 
+          identifier.type = var_type.element_type
+
           element_checker = merge(identifier.to_sym => var_type.element_type)
 
           unsupported_type(funcall) if element_checker.check(predicate) != :bool
@@ -195,17 +222,38 @@ module Cel
           unsupported_type(funcall)
         end
         unsupported_operation(funcall)
+      when TYPES[:timestamp]
+        case func
+        when :getDate, :getDayOfMonth, :getDayOfWeek, :getDayOfYear, :getFullYear, :getHours,
+             :getMilliseconds, :getMinutes, :getMonth, :getSeconds
+          check_arity(func, args, 0..1)
+          return TYPES[:int] if args.empty? || (args.size.positive? && args[0] == :string)
+        else
+          unsupported_type(funcall)
+        end
+        unsupported_operation(funcall)
+      when TYPES[:duration]
+        case func
+        when :getMilliseconds, :getMinutes, :getHours, :getSeconds
+          check_arity(func, args, 0)
+          return TYPES[:int]
+        else
+          unsupported_type(funcall)
+        end
+        unsupported_operation(funcall)
       else
         TYPES[:any]
       end
     end
 
     CAST_ALLOWED_TYPES = {
-      int: %i[uint double string], # TODO: enum, timestamp
+      int: %i[uint double string timestamp], # TODO: enum
       uint: %i[int double string],
-      string: %i[int uint double bytes], # TODO: timestamp, duration
+      string: %i[int uint double bytes timestamp duration],
       double: %i[int uint string],
       bytes: %i[string],
+      duration: %i[string],
+      timestamp: %i[string],
     }.freeze
 
     def check_standard_func(funcall)
@@ -223,15 +271,18 @@ module Cel
         return TYPES[:bool]
       when :size
         check_arity(func, args, 1)
-        return TYPES[:int] if find_match_all_types(%i[string bytes list map], call(args.first))
-      when :int, :uint, :string, :double, :bytes # :duration, :timestamp
+
+        arg = call(args.first)
+        return TYPES[:int] if find_match_all_types(%i[string bytes list map], arg)
+      when *CAST_ALLOWED_TYPES.keys
         check_arity(func, args, 1)
         allowed_types = CAST_ALLOWED_TYPES[func]
 
-        return TYPES[func] if find_match_all_types(allowed_types, call(args.first))
+        arg = call(args.first)
+        return TYPES[func] if find_match_all_types(allowed_types, arg)
       when :matches
         check_arity(func, args, 2)
-        return TYPES[:bool] if find_match_all_types(%i[string], args.map { |arg| call(arg) })
+        return TYPES[:bool] if find_match_all_types(%i[string], args.map(&method(:call)))
       when :dyn
         check_arity(func, args, 1)
         arg_type = call(args.first)
@@ -241,14 +292,37 @@ module Cel
         end
         return arg_type
       else
+        return check_custom_func(@declarations[func], funcall) if @declarations.key?(func)
+
         unsupported_type(funcall)
       end
 
       unsupported_operation(funcall)
     end
 
+    def check_custom_func(func, funcall)
+      args = funcall.args
+
+      unless func.is_a?(Cel::Function)
+        raise CheckError, "#{func} must respond to #call" unless func.respond_to?(:call)
+
+        func = Cel::Function(&func)
+      end
+
+      unless func.types.empty?
+        unsupported_type(funcall) unless func.types.zip(args.map(&method(:call)))
+                                             .all? do |expected_type, type|
+                                               expected_type == :any || expected_type == type
+                                             end
+
+        return func.type
+      end
+
+      unsupported_operation(funcall)
+    end
+
     def check_identifier(identifier)
-      return unless identifier.type == :any
+      return identifier.type unless identifier.type == :any
 
       return TYPES[:type] if Cel::PRIMITIVE_TYPES.include?(identifier.to_sym)
 
@@ -262,6 +336,10 @@ module Cel
     end
 
     def check_condition(condition)
+      if_type = call(condition.if)
+
+      raise CheckError, "`#{condition.if}` must evaluate to a bool" unless if_type == :bool
+
       then_type = call(condition.then)
       else_type = call(condition.else)
 
@@ -286,7 +364,7 @@ module Cel
       case typ
       when Symbol
         TYPES[typ] or
-          raise CheckError, "#{typ} is not aa valid type"
+          raise CheckError, "#{typ} is not a valid type"
       else
         typ
       end
@@ -303,11 +381,11 @@ module Cel
         end
       end
 
-      TYPES[type]
+      type && types.is_a?(Type) ? types : TYPES[type]
     end
 
     def check_arity(func, args, arity)
-      return if args.size == arity
+      return if arity === args.size # rubocop:disable Style/CaseEquality
 
       raise CheckError, "`#{func}` invoked with wrong number of arguments (should be #{arity})"
     end

data/lib/cel/context.rb

@@ -2,13 +2,18 @@
 
 module Cel
   class Context
-    def initialize(bindings)
+    attr_reader :declarations
+
+    def initialize(declarations, bindings)
+      @declarations = declarations
       @bindings = bindings.dup
 
       return unless @bindings
 
       @bindings.each do |k, v|
-        @bindings[k] = to_cel_type(v)
+        val = to_cel_type(v)
+        val = TYPES[@declarations[k]].cast(val) if @declarations && @declarations.key?(k)
+        @bindings[k] = val
       end
     end
 
@@ -24,7 +29,7 @@ module Cel
     end
 
     def merge(bindings)
-      Context.new(@bindings ? @bindings.merge(bindings) : bindings)
+      Context.new(@declarations, @bindings ? @bindings.merge(bindings) : bindings)
     end
 
     private

data/lib/cel/encoder.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Cel
+  module Encoder
+    module_function
+
+    def encode(expr)
+      case expr
+      when Group
+        ["group", encode(expr.value)]
+      when Invoke
+        enc = [
+          "inv",
+          (encode(expr.var) if expr.var),
+          expr.func.to_s,
+          *(if expr.args
+              expr.func == :[] ? [encode(expr.args)] : expr.args.map(&method(:encode))
+            end),
+        ]
+        enc.compact!
+        enc
+      when Operation
+        [
+          "op",
+          expr.op.to_s,
+          *expr.operands.map(&method(:encode)),
+        ]
+      when Condition
+        [
+          "cond",
+          encode(expr.if),
+          encode(expr.then),
+          encode(expr.else),
+        ]
+      when Identifier
+        [
+          "id",
+          expr.type.to_s,
+          expr.id.to_s,
+        ]
+      when List
+        ["lit",
+         expr.type.to_s,
+         *expr.value.map(&method(:encode))]
+      when Map
+        ["lit",
+         expr.type.to_s,
+         *expr.value.map { |kv| kv.map(&method(:encode)) }]
+      when Number, Bool, String, Bytes
+        ["lit", expr.type.to_s, expr.value]
+      when Null
+        %w[lit null]
+      when Type
+        ["lit", "type", expr.to_s]
+      end
+    end
+
+    def decode(enc)
+      case enc
+      in ["group", stmt]
+        Group.new(decode(stmt))
+      in ["inv", var, ::String => func, *args]
+        args = if func == "[]" && args.size == 1
+          decode(args.first)
+        elsif args.empty?
+          nil
+        else
+          args.map(&method(:decode))
+        end
+        Invoke.new(func: func, var: decode(var), args: args)
+      in ["inv", ::String => func, *args]
+        args = nil if args.empty?
+        Invoke.new(func: func, args: args.map(&method(:decode)))
+      in ["op", ::String => op, *args]
+        Operation.new(op, args.map(&method(:decode)))
+      in ["cond", f, th, el]
+        Condition.new(decode(f), decode(th), decode(el))
+      in ["id", ::String => type, ::String => val]
+        id = Identifier.new(val)
+        id.type = TYPES[type.to_sym]
+        id
+      in ["lit", "list", *items]
+        list = List.new(items.map(&method(:decode)))
+        list
+      in ["lit", "map", items]
+        Map.new(items.map(&method(:decode)).each_slice(2))
+      in ["lit", /\Aint|uint|double\z/ => type, Integer => val]
+        Number.new(type.to_sym, val)
+      in ["lit", "bool", val]
+        Bool.new(val)
+      in ["lit", "string", val]
+        String.new(val)
+      in ["lit", "bytes", val]
+        Bytes.new(val)
+      in ["lit", "null"]
+        Null.new
+      in ["lit", "type", type]
+        TYPES[type.to_sym]
+      end
+    end
+  end
+end

data/lib/cel/environment.rb

@@ -14,19 +14,31 @@ module Cel
       ast
     end
 
+    def encode(expr)
+      Encoder.encode(compile(expr))
+    end
+
+    def decode(encoded_expr)
+      ast = Encoder.decode(encoded_expr)
+      @checker.check(ast)
+      ast
+    end
+
     def check(expr)
       ast = @parser.parse(expr)
       @checker.check(ast)
     end
 
     def program(expr)
-      expr = compile(expr) if expr.is_a?(::String)
-      Runner.new(expr)
+      expr = @parser.parse(expr) if expr.is_a?(::String)
+      @checker.check(expr)
+      Runner.new(@declarations, expr)
     end
 
     def evaluate(expr, bindings = nil)
-      context = Context.new(bindings)
-      expr = compile(expr) if expr.is_a?(::String)
+      context = Context.new(@declarations, bindings)
+      expr = @parser.parse(expr) if expr.is_a?(::String)
+      @checker.check(expr)
       Program.new(context).evaluate(expr)
     end
 
@@ -36,12 +48,13 @@ module Cel
   end
 
   class Runner
-    def initialize(ast)
+    def initialize(declarations, ast)
+      @declarations = declarations
       @ast = ast
     end
 
     def evaluate(bindings = nil)
-      context = Context.new(bindings)
+      context = Context.new(@declarations, bindings)
       Program.new(context).evaluate(@ast)
     end
   end

data/lib/cel/parser.rb

@@ -63,9 +63,18 @@ def parse(str)
   tokenize(str)
   do_parse
 rescue Racc::ParseError => err
-  ex = Cel::ParseError.new(err.message)
-  ex.set_backtrace(err.backtrace)
-  raise ex
+  raise parse_error(err)
+end
+
+def parse_error(error)
+  parse_error = case error.message
+  when /parse error on value "([^"]+)" \(tRESERVED\)/
+    Cel::ParseError.new("invalid usage of the reserved word \"#{$1}\"")
+  else
+    Cel::ParseError.new(error.message)
+  end
+  parse_error.set_backtrace(error.backtrace)
+  parse_error
 end
 
 def tokenize(str)
@@ -83,10 +92,6 @@ def tokenize(str)
       # skip comment lines
     when scanner.scan(NUMBER_REGEX)
       @q << convert_to_number(scanner)
-    when scanner.scan(/true|false/)
-      @q << [:tBOOL, scanner.matched == "true"]
-    when scanner.scan(/null/)
-      @q << [:tNULL, nil]
     when scanner.scan(/[bB]?[rR]?#{STRING_LIT_REGEX}/) # string
       # s = scanner.matched.yield_self {|s| s[1, s.length - 2] }
       #                  .gsub(DBL_QUOTE_STR_ESCAPE_SEQUENCES_RE) do |match|
@@ -115,7 +120,13 @@ def tokenize(str)
       end
     when scanner.scan(IDENTIFIER_REGEX)
       word = scanner.matched
-      if RESERVED.include?(word)
+      if word == "null"
+        @q << [:tNULL, nil]
+      elsif word == "true"
+        @q << [:tBOOL, true]
+      elsif word == "false"
+        @q << [:tBOOL, false]
+      elsif RESERVED.include?(word)
         @q << [:tRESERVED, scanner.matched]
       elsif word == "in"
         @q << [OPERATORS[scanner.matched], scanner.matched]
@@ -470,7 +481,7 @@ racc_reduce_table = [
   1, 49, :_reduce_42,
   0, 45, :_reduce_43,
   1, 45, :_reduce_none,
-  5, 51, :_reduce_none,
+  5, 51, :_reduce_45,
   3, 51, :_reduce_46,
   5, 50, :_reduce_47,
   3, 50, :_reduce_48,
@@ -738,7 +749,7 @@ module_eval(<<'.,.,', 'parser.ry', 54)
 
 module_eval(<<'.,.,', 'parser.ry', 55)
   def _reduce_30(val, _values, result)
-    result = Cel::Invoke.new(func: val[0], args: [val[2]].flatten(1))
+     result = Cel::Invoke.new(func: val[0], args: [val[2]].flatten(1))
     result
   end
 .,.,
@@ -774,7 +785,7 @@ module_eval(<<'.,.,', 'parser.ry', 58)
 
 module_eval(<<'.,.,', 'parser.ry', 65)
   def _reduce_38(val, _values, result)
-     result = nil
+     result = []
     result
   end
 .,.,
@@ -811,7 +822,12 @@ module_eval(<<'.,.,', 'parser.ry', 73)
 
 # reduce 44 omitted
 
-# reduce 45 omitted
+module_eval(<<'.,.,', 'parser.ry', 76)
+  def _reduce_45(val, _values, result)
+     result = val[0].merge(Cel::Identifier.new(val[2]) => val[4])
+    result
+  end
+.,.,
 
 module_eval(<<'.,.,', 'parser.ry', 77)
   def _reduce_46(val, _values, result)

data/lib/cel/program.rb

@@ -40,7 +40,7 @@ module Cel
     def evaluate_literal(val)
       case val
       when List
-        List.new(val.value.map { |y| call(y) })
+        List.new(val.value.map(&method(:call)))
       else
         val
       end
@@ -93,7 +93,7 @@ module Cel
       when String
         raise EvaluateError, "#{invoke} is not supported" unless String.method_defined?(func, false)
 
-        var.public_send(func, *args)
+        var.public_send(func, *args.map(&method(:call)))
       when Message
         # If e evaluates to a message and f is not declared in this message, the
         # runtime error no_such_field is raised.
@@ -110,6 +110,10 @@ module Cel
         args ?
         var.public_send(func, *args) :
         var.public_send(func)
+      when Timestamp, Duration
+        raise EvaluateError, "#{invoke} is not supported" unless var.class.method_defined?(func, false)
+
+        var.public_send(func, *args)
       else
         raise EvaluateError, "#{invoke} is not supported"
       end
@@ -130,18 +134,28 @@ module Cel
 
         val.class
       # MACROS
-      when :has, :size
-        Macro.__send__(func, *args)
+      when :has
+        Bool.new(Macro.__send__(func, *args))
+      when :size
+        Cel::Number.new(:int, Macro.__send__(func, *args))
       when :matches
-        Macro.__send__(func, *args.map { |arg| call(arg) })
-      when :int, :uint, :string, :double, :bytes # :duration, :timestamp
+        Bool.new(Macro.__send__(func, *args.map(&method(:call))))
+      when :int, :uint, :string, :double, :bytes, :duration, :timestamp
         type = TYPES[func]
         type.cast(call(args.first))
       when :dyn
         call(args.first)
       else
+        return evaluate_custom_func(@context.declarations[func], funcall) if @context.declarations.key?(func)
+
         raise EvaluateError, "#{funcall} is not supported"
       end
     end
+
+    def evaluate_custom_func(func, funcall)
+      args = funcall.args
+
+      func.call(*args.map(&method(:call)).map(&:to_ruby_type))
+    end
   end
 end

data/lib/cel/version.rb

@@ -2,6 +2,6 @@
 
 module Cel
   module Ruby
-    VERSION = "0.1.2"
+    VERSION = "0.2.1"
   end
 end