cel 0.2.3 → 0.3.0

data/lib/cel/ast/types.rb

@@ -7,11 +7,22 @@ module Cel
     end
 
     def ==(other)
-      other == @type || super
+      (other.is_a?(Symbol) && other == @type) || super
     end
 
     def to_str
-      @type.to_s
+      case @type
+      when :timestamp
+        "google.protobuf.Timestamp"
+      when :duration
+        "google.protobuf.Duration"
+      else
+        @type.to_s
+      end
+    end
+
+    def to_sym
+      @type
     end
 
     alias_method :to_s, :to_str
@@ -21,25 +32,122 @@ module Cel
     end
 
     def cast(value)
-      value = value.value if value.is_a?(Literal)
+      type = nil
+      type = value.type.to_sym if value.is_a?(Literal)
 
       case @type
       when :int
-        Number.new(:int, Integer(value))
+        case type
+        when :int, :uint, :string
+          value = Integer(value.value)
+
+          raise "Type conversion range error" unless (-(MAX_INT - 1)...MAX_INT).cover?(value)
+
+          Number.new(:int, value)
+        when :double
+          value = value.value
+
+          raise "Type conversion range error" unless (-(MAX_FLOAT - 1)...MAX_FLOAT).cover?(value)
+
+          Number.new(:int, Integer(value))
+        when :timestamp
+          Number.new(:int, value.value.to_i)
+        else
+          raise EvaluateError, "Type conversion error"
+        end
       when :uint
-        Number.new(:uint, Integer(value).abs)
+        case type
+        when :int, :uint, :string
+          value = Integer(value.value)
+
+          raise EvaluateError, "Type conversion range error" unless (0...MAX_INT).cover?(value)
+
+          Number.new(:uint, value)
+        when :double
+          value = value.value
+
+          raise EvaluateError, "Type conversion range error" unless (0...MAX_FLOAT).cover?(value)
+
+          Number.new(:uint, Integer(value))
+        else
+          raise EvaluateError, "Type conversion error"
+        end
       when :double
-        Number.new(:double, Float(value))
+        case type
+        when :double, :int, :uint
+          Number.new(:double, Float(value.value))
+        when :string
+          case value
+          when "NaN"
+            raise Error, "unsupported cast operation to #{@type}" unless defined?(Float::NAN)
+
+            Number.new(:double, Float::NAN)
+          else
+            Number.new(:double, Float(value.value))
+          end
+        else
+          raise EvaluateError, "Type conversion error"
+        end
       when :string
-        String.new(String(value))
+        case type
+        when :bytes
+          value = value.string.force_encoding(Encoding::UTF_8)
+
+          raise EvaluateError, "Type conversion invalid UTF-8" unless value.valid_encoding?
+
+          String.new(value)
+        when :timestamp
+          String.new(value.value.iso8601(9).sub(/\.0+Z/, "Z"))
+        when :duration
+          String.new(value.to_s)
+        else
+          String.new(String(value.value))
+        end
       when :bytes
-        Bytes.new(value.bytes)
+        case type
+        when :bytes
+          value
+        when :string
+          Bytes.new(value.value.bytes)
+        else
+          raise EvaluateError, "Type conversion error"
+        end
       when :bool
-        Bool.new(value)
+        case type
+        when :bool
+          value
+        when :string
+          case value.value
+          when "1", "t", "true", "TRUE", "True"
+            Bool.new(true)
+          when "0", "f", "false", "FALSE", "False"
+            Bool.new(false)
+          else
+            raise EvaluateError, "Type conversion error"
+          end
+        else
+          raise EvaluateError, "Type conversion error"
+        end
+      when :null_type
+        Null::INSTANCE
       when :timestamp
-        Timestamp.new(value)
+        case type
+        when :timestamp
+          value
+        when :int, :string
+          Timestamp.new(value.value)
+        else
+          raise EvaluateError, "Type conversion error"
+        end
       when :duration
-        Duration.new(value)
+        case type
+        when :duration
+          value
+        when :string
+          Duration.new(value.value)
+        else
+          raise EvaluateError, "Type conversion error"
+        end
       when :any
         value
       else
@@ -58,11 +166,13 @@ module Cel
     end
 
     def get(idx)
+      return @element_type if @type_list.empty?
+
       @type_list[idx]
     end
 
     def ==(other)
-      other == :list || super
+      (other.is_a?(self.class) && other.element_type == @element_type) || super
     end
 
     def cast(value)
@@ -73,18 +183,22 @@ module Cel
   class MapType < Type
     attr_accessor :element_type
 
+    attr_reader :type_map
+    protected :type_map
+
     def initialize(type_map)
       super(:map)
       @type_map = type_map
-      @element_type = @type_map.empty? ? TYPES[:any] : @type_map.keys.sample.type
+      @element_type = @type_map.empty? ? TYPES[:any] : @type_map.sample.first.type
     end
 
     def get(attrib)
-      _, value = @type_map.find { |k, _| k == attrib.to_s }
+      _, value = @type_map.find { |k, _| k == attrib }
       value
     end
 
     def ==(other)
+      (other.is_a?(self.class) && other.element_type == @element_type && other.type_map == @type_map) || super
       other == :map || super
     end
 
@@ -93,6 +207,12 @@ module Cel
     end
   end
 
+  class AbstractType < Type
+    def initialize(name, *params)
+      super(name)
+      @params = params
+    end
+  end
   # Primitive Cel Types
 
   PRIMITIVE_TYPES = %i[int uint double bool string bytes list map timestamp duration null_type type].freeze
@@ -118,10 +238,26 @@ module Cel
                MapType.new({})
       end
 
-      type.element_type = super(*elem_type)
+      type.element_type = elem_type.is_a?(Type) || (elem_type.is_a?(Class) && elem_type < Protobuf.base_class) ?
+                          elem_type :
+                          super(*elem_type)
       type
     end
   end
 
   TYPES.singleton_class.prepend(CollectionTypeFetch)
+
+  # override == to ensure that cel timestamp/duration types
+  # compare positively with the protobuf counterparts.
+  timestamp_class = TYPES[:timestamp]
+
+  def timestamp_class.==(other)
+    other == Protobuf.timestamp_class || super
+  end
+
+  duration_class = TYPES[:duration]
+
+  def duration_class.==(other)
+    other == Protobuf.duration_class || super
+  end
 end

data/lib/cel/checker.rb

@@ -2,11 +2,35 @@
 
 module Cel
   class Checker
-    def initialize(declarations)
+    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
+
+    BOOLABLE_OPERATORS = %w[&& || == != < <= >= >].freeze
+
+    CAST_ALLOWED_TYPES = {
+      int: %i[int uint double string timestamp], # TODO: enum
+      uint: %i[int uint double string],
+      string: %i[int uint double bytes bool bytes string timestamp duration],
+      double: %i[double int uint string],
+      bytes: %i[bytes string],
+      bool: %i[bool string],
+      duration: %i[string duration],
+      timestamp: %i[int string timestamp],
+    }.freeze
+
+    attr_reader :declarations
+
+    def initialize(environment, declarations = environment.declarations)
+      @environment = environment
       @declarations = declarations
     end
 
     def check(ast)
+      return ast if ast.is_a?(Class) && ast < Protobuf.base_class
+
       case ast
       when Group
         check(ast.value)
@@ -15,7 +39,9 @@ module Cel
       when Operation
         check_operation(ast)
       when Literal
-        ast.type
+        check_literal(ast)
+      when Message
+        check_message(ast)
       when Identifier
         check_identifier(ast)
       when Condition
@@ -28,14 +54,32 @@ module Cel
     private
 
     def merge(declarations)
-      Checker.new(@declarations ? @declarations.merge(declarations) : declarations)
+      Checker.new(@environment, @declarations ? @declarations.merge(declarations) : declarations)
     end
 
-    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
+    def check_literal(literal)
+      case literal
+      when List
+        lit = ListType.new(literal.value)
+        elem_types = literal.value.map(&method(:call))
+
+        if !literal.value.empty? && elem_types.map do |type|
+          type.respond_to?(:to_sym) ? type.to_sym : type
+        end.uniq.size == 1
+          elem = literal.by_max_depth
+          lit.element_type = call(elem)
+        end
+        lit
+      when Map
+        MapType.new(literal.value)
+      else
+        literal.type
+      end
+    end
+
+    def check_message(literal)
+      literal.type
+    end
 
     def check_operation(operation)
       type = infer_operation_type(operation)
@@ -43,8 +87,6 @@ module Cel
       type
     end
 
-    BOOLABLE_OPERATORS = %w[&& || == != < <= >= >].freeze
-
     def infer_operation_type(operation)
       op = operation.op
 
@@ -78,11 +120,18 @@ module Cel
           return TYPES[:bool] if values.uniq.size == 1 ||
                                  values.all? { |v| v == :list } ||
                                  values.all? { |v| v == :map } ||
+                                 # comparison with null is allowed for legacy reasons
+                                 # https://github.com/google/cel-spec/issues/361
+                                 values.one? { |v| v == :null_type } ||
                                  values.include?(:any)
         when "in"
           return TYPES[:bool] if find_match_all_types(%i[list map any], values.last)
         when "+"
-          return type if (type = find_match_all_types(ADD_EXPECTED_TYPES, values))
+          if (type = find_match_all_types(ADD_EXPECTED_TYPES, values))
+            return type unless type == :list
+
+            return values.find { |v| v.element_type != :any } || type
+          end
 
           return TYPES[:timestamp] if %i[timestamp duration].any? { |typ| values.first == typ }
 
@@ -127,6 +176,12 @@ module Cel
         check_identifier(var)
       when Invoke
         check_invoke(var)
+      when Literal
+        check_literal(var)
+      when Group
+        check(var.value)
+      when Protobuf.base_class
+        var.class
       else
         var.type
       end
@@ -147,9 +202,15 @@ module Cel
         # to maps. For maps, selection is interpreted as the field being a string key.
         case func
         when :[]
+          if args.is_a?(Invoke)
+            args = call(args)
+            return TYPES[:any] if args == TYPES[:any]
+          end
           attribute = var_type.get(args)
           return TYPES[:any] unless attribute
-        when :all, :exists, :exists_one
+        when :exists, :all
+          return TYPES[:bool]
+        when :exists_one
           check_arity(funcall, args, 2)
           identifier, predicate = args
 
@@ -169,10 +230,25 @@ module Cel
       when ListType
         case func
         when :[]
+          if args.is_a?(Invoke)
+            args = call(args)
+            return TYPES[:any] if args == TYPES[:any]
+          end
+
+          if args.is_a?(Type)
+            unsupported_operation(funcall) unless args == TYPES[:int]
+
+            return var_type.element_type
+          end
+
           attribute = var_type.get(args)
+
           unsupported_operation(funcall) unless attribute
+
           call(attribute)
-        when :all, :exists, :exists_one
+        when :exists, :all
+          TYPES[:bool]
+        when :exists_one
           check_arity(funcall, args, 2)
           identifier, predicate = args
 
@@ -227,7 +303,8 @@ module Cel
         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)
+          # TODO: verify if it's a valid tz
+          return TYPES[:int] if args.empty? || (args.size.positive? && call(args.first) == :string)
         else
           unsupported_type(funcall)
         end
@@ -241,25 +318,41 @@ module Cel
           unsupported_type(funcall)
         end
         unsupported_operation(funcall)
+      when Class
+        # Protobuf property
+        if var_type.respond_to?(:descriptor)
+          return Protobuf.convert_to_cel_type(
+            var_type.descriptor.lookup(func.to_s),
+            @environment.package
+          )
+        end
+
+        TYPES[:any]
+      when Module
+        # Protobuf enum access
+        return TYPES[:int] if var_type.const_defined?(func)
+
+        TYPES[:any]
       else
         TYPES[:any]
       end
     end
 
-    CAST_ALLOWED_TYPES = {
-      int: %i[uint double string timestamp], # TODO: enum
-      uint: %i[int double string],
-      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)
       func = funcall.func
       args = funcall.args
 
+      # check if protobuf conversion
+      if (proto_type = Protobuf.convert_to_proto_type(func.to_s, @environment.package))
+        # TODO: fixit
+        raise "unsupported" unless proto_type.respond_to?(:resolve)
+
+        check_arity(func, args, 1)
+
+        arg = call(args.first)
+        return proto_type.descriptor.name if find_match_all_types(%i[int], arg)
+      end
+
       case func
       when :type
         check_arity(func, args, 1)
@@ -279,16 +372,23 @@ module Cel
         allowed_types = CAST_ALLOWED_TYPES[func]
 
         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(&method(:call)))
       when :dyn
         check_arity(func, args, 1)
-        arg_type = call(args.first)
+        arg_type = begin
+          call(args.first)
+        rescue StandardError
+          TYPES[:any]
+        end
         case arg_type
         when ListType, MapType
           arg_type.element_type = TYPES[:any]
+        else
+          return TYPES[:any]
         end
         return arg_type
       else
@@ -326,6 +426,11 @@ module Cel
 
       return TYPES[:type] if Cel::PRIMITIVE_TYPES.include?(identifier.to_sym)
 
+      proto_type = identifier.try_convert_to_proto_type
+
+      # protobuf enum
+      return proto_type if proto_type
+
       id_type = infer_dec_type(identifier.id)
 
       return TYPES[:any] unless id_type
@@ -341,11 +446,9 @@ module Cel
       raise CheckError, "`#{condition.if}` must evaluate to a bool" unless if_type == :bool
 
       then_type = call(condition.then)
-      else_type = call(condition.else)
-
-      return then_type if then_type == else_type
+      call(condition.else)
 
-      TYPES[:any]
+      then_type
     end
 
     def infer_dec_type(id)
@@ -391,7 +494,7 @@ module Cel
     end
 
     def unsupported_type(op)
-      raise NoMatchingOverloadError, op
+      raise CheckError, "no matching overload: #{op}"
     end
 
     def unsupported_operation(op)

data/lib/cel/context.rb

@@ -11,8 +11,17 @@ module Cel
       return unless @bindings
 
       @bindings.each do |k, v|
-        val = to_cel_type(v)
-        val = TYPES[@declarations[k]].cast(val) if @declarations && @declarations.key?(k)
+        if @declarations && (type = @declarations[k])
+          type = TYPES[type] if type.is_a?(Symbol)
+
+          val = if type.is_a?(Class) && type < Protobuf.base_class
+            Protobuf.convert_to_proto(type, v)
+          else
+            type.cast(to_cel_type(v))
+          end
+        else
+          val = to_cel_type(v)
+        end
         @bindings[k] = val
       end
     end
@@ -20,12 +29,52 @@ module Cel
     def lookup(identifier)
       raise EvaluateError, "no value in context for #{identifier}" unless @bindings
 
-      id = identifier.id
-      val = @bindings.dig(*id.split(".").map(&:to_sym))
+      id = identifier.to_s
+
+      lookup_keys = id.split(".")
+
+      val = @bindings
+
+      loop do
+        fetched = false
+        (0...lookup_keys.size).reverse_each do |idx|
+          key = lookup_keys[0..idx].join(".").to_sym
+
+          val = if val.respond_to?(:key?)
+            # hash
+            next unless val.key?(key)
+
+            val[key]
+          else
+            next unless val.respond_to?(key)
+
+            case val
+            when Protobuf.base_class
+              Protobuf.lookup(val, key)
+            else
+              val.__send__(key)
+            end
+          end
+
+          lookup_keys = lookup_keys[idx + 1..]
+          fetched = true
+          break
+        end
+
+        break unless fetched
+
+        break if lookup_keys.empty?
+      end
+
+      raise EvaluateError, "no value in context for #{id}" if val == @bindings
+
+      # lookup_keys.each do |key|
+      #   raise EvaluateError, "no value in context for #{id}" unless val.key?(key)
 
-      raise EvaluateError, "no value in context for #{identifier}" unless val
+      #   val = val[key]
+      # end
 
-      val
+      [val, lookup_keys.empty? ? nil : lookup_keys.join(".")]
     end
 
     def merge(bindings)

data/lib/cel/encoder.rb

@@ -38,20 +38,30 @@ module Cel
           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 List, Map
+        [
+          "lit",
+          expr.type.to_s,
+          *encode(expr.value),
+        ]
+      when Message
+        [
+          "message",
+          expr.name.to_s,
+          encode(expr.struct),
+        ]
       when Number, Bool, String, Bytes
         ["lit", expr.type.to_s, expr.value]
       when Null
         %w[lit null]
       when Type
         ["lit", "type", expr.to_s]
+      when Array
+        expr.map(&method(:encode))
+      when Hash
+        expr.to_h { |*kv| kv.map(&method(:encode)) }
+      else
+        expr
       end
     end
 
@@ -80,22 +90,30 @@ module Cel
         id.type = TYPES[type.to_sym]
         id
       in ["lit", "list", *items]
-        list = List.new(items.map(&method(:decode)))
-        list
+        List.new(items.map(&method(:decode)))
+
       in ["lit", "map", items]
-        Map.new(items.map(&method(:decode)).each_slice(2))
+        Map.new(decode(items))
       in ["lit", /\Aint|uint|double\z/ => type, Integer => val]
         Number.new(type.to_sym, val)
       in ["lit", "bool", val]
-        Bool.new(val)
+        Bool.cast(val)
       in ["lit", "string", val]
         String.new(val)
       in ["lit", "bytes", val]
         Bytes.new(val)
       in ["lit", "null"]
-        Null.new
+        Null::INSTANCE
       in ["lit", "type", type]
         TYPES[type.to_sym]
+      in ["message", name, struct]
+        Cel::Message.new(name, decode(struct))
+      in **items
+        items.to_h { |*kv| kv.map(&method(:decode)) }
+      in *items
+        items.map(&method(:decode)).each_slice(2)
+      else
+        enc
       end
     end
   end