cel 0.2.3 → 0.3.1

data/lib/cel/program.rb

@@ -2,8 +2,16 @@
 
 module Cel
   class Program
-    def initialize(context)
+    attr_reader :context
+
+    def initialize(context, environment)
       @context = context
+      @environment = environment
+      @convert_to_cel = true
+    end
+
+    def with_extra_context(context)
+      self.class.new(@context.merge(context), @environment)
     end
 
     def evaluate(ast)
@@ -15,7 +23,7 @@ module Cel
       when Operation
         evaluate_operation(ast)
       when Message
-        ast.struct
+        evaluate_message(ast)
       when Literal
         evaluate_literal(ast)
       when Identifier
@@ -27,13 +35,36 @@ module Cel
 
     alias_method :call, :evaluate
 
+    def disable_cel_conversion
+      convert_to_cel = @convert_to_cel
+      begin
+        @convert_to_cel = false
+        yield(convert_to_cel)
+      ensure
+        @convert_to_cel = convert_to_cel
+      end
+    end
+
     private
 
+    def try_evaluate_lookup(key)
+      Protobuf.convert_to_proto_type(key, @package) || begin
+        Literal.to_cel_type(evaluate_identifier(key))
+      rescue EvaluateError # rubocop:disable Lint/SuppressedException
+      end
+    end
+
     def evaluate_identifier(identifier)
       if Cel::PRIMITIVE_TYPES.include?(identifier.to_sym)
         TYPES[identifier.to_sym]
       else
-        @context.lookup(identifier)
+        val, func = @context.lookup(identifier)
+
+        if func
+          evaluate_invoke(Cel::Invoke.new(var: val, func: func))
+        else
+          Literal.to_cel_type(val)
+        end
       end
     end
 
@@ -46,30 +77,113 @@ module Cel
       end
     end
 
-    def evaluate_operation(operation)
-      op = operation.op
-
-      values = operation.operands.map do |operand|
-        ev_operand = call(operand)
+    def evaluate_message(val)
+      disable_cel_conversion do |should_have_converted|
+        values = val.struct.transform_values do |value|
+          v = call(value)
+          v = v.to_ruby_type if v.respond_to?(:to_ruby_type)
+          v
+        end
+        value = Protobuf.convert_to_proto(val.message_type, values)
 
-        # return ev_operand if op == "||" && ev_operand == true
+        return value unless should_have_converted
 
-        ev_operand
+        Literal.to_cel_type(value)
       end
+    end
+
+    def evaluate_operation(operation)
+      op = operation.op
+
+      operands = operation.operands
 
       if operation.unary? &&
          op != "!" # https://bugs.ruby-lang.org/issues/18246
         # unary operations
-        Literal.to_cel_type(values.first.__send__(:"#{op}@"))
-      elsif op == "&&"
-        Bool.new(values.all? { |x| true == x.value }) # rubocop:disable Style/YodaCondition
-      elsif op == "||"
-        Bool.new(values.any? { |x| true == x.value }) # rubocop:disable Style/YodaCondition
-      elsif op == "in"
-        element, collection = values
-        Bool.new(collection.include?(element))
+        operand = operands.first
+        op_value = call(operand)
+        value = Literal.to_cel_type(op_value.__send__(:"#{op}@"))
+        value.check_overflow unless operand.is_a?(Literal)
+        return value
+      end
+
+      case op
+      when "&&"
+        error = nil
+        last_op = nil
+
+        operands.each do |x|
+          op_value = call(x)
+
+          raise NoMatchingOverloadError, op unless op_value.type == TYPES[:bool]
+
+          result = true == op_value.value # rubocop:disable Style/YodaCondition
+
+          if error
+            # save for later processing
+            last_op = result
+            next
+          end
+
+          return Bool.cast(false) unless result
+        rescue StandardError => e
+          error = e
+        end
+
+        # if an error happened, but it was succeeded by an operation evaluating to true,
+        # then the latter wins
+        raise error if error && (last_op.nil? || last_op == true)
+
+        Bool.cast(last_op.nil? || last_op)
+      when "||"
+        error = nil
+        last_op = nil
+
+        operands.each do |x|
+          op_value = call(x)
+
+          raise NoMatchingOverloadError, op unless op_value.type == TYPES[:bool]
+
+          result = true == op_value.value # rubocop:disable Style/YodaCondition
+
+          if error
+            # save for later processing
+            last_op = result
+            next
+          end
+
+          return Bool.cast(true) if result
+        rescue StandardError => e
+          error = e
+        end
+
+        # if an error happened, but it was succeeded by an operation evaluating to true,
+        # then the latter wins
+        raise error if error && (last_op.nil? || last_op == false)
+
+        Bool.cast(last_op.nil? ? false : last_op)
+      when "in"
+        collection, element = operands.reverse_each.map(&method(:call))
+        Bool.cast(collection.include?(element))
+      when "!"
+        op_value, = operands.map(&method(:call))
+
+        raise InvalidArgumentError, op_value unless op_value.type == TYPES[:bool]
+
+        Bool.cast(!op_value.value)
+      when "=="
+        operands = operands.map(&method(:call))
+
+        # ensure that the op is called on the cel-side override
+        lhs, rhs = operands.sort_by do |t|
+          t.is_a?(Class) && t < Protobuf.base_class ? 1 : 0
+        end
+
+        val = lhs.public_send(op, rhs)
+
+        Literal.to_cel_type(val)
       else
-        op_value, *values = values
+        op_value, *values = operands.map(&method(:call))
         val = op_value.public_send(op, *values)
 
         Literal.to_cel_type(val)
@@ -77,52 +191,138 @@ module Cel
     end
 
     def evaluate_invoke(invoke, var = invoke.var)
+      return evaluate_standard_func(invoke) unless var
+
       func = invoke.func
       args = invoke.args
 
-      return evaluate_standard_func(invoke) unless var
+      var =
+        case var
+        when Identifier
+          if (proto_type = var.try_convert_to_proto_type)
+            return evaluate_invoke(invoke, proto_type)
+          end
 
-      var = case var
-            when Identifier
-              evaluate_identifier(var)
-            when Invoke
-              evaluate_invoke(var)
-            else
-              var
-      end
+          # try stuff like a.b.c
+          return evaluate_identifier(invoke.to_s) if args.nil?
+
+          evaluate_identifier(var)
+
+        when Invoke
+          if args.nil?
+            # try stuff like a.b.c before trying a.b then c
+            val = try_evaluate_lookup(invoke.to_s)
+
+            return val if val
+          end
+
+          evaluate_invoke(var)
+        else
+          call(var)
+        end || var
 
       case var
       when String
         raise EvaluateError, "#{invoke} is not supported" unless String.method_defined?(func, false)
 
         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.
-        raise NoSuchFieldError.new(var, func) unless var.field?(func)
+      when Map
+        return Macro.__send__(func, var, *args, program: self) if !Module.respond_to?(func) && Macro.respond_to?(func)
 
-        var.public_send(func)
-      when Map, List
-        return Macro.__send__(func, var, *args, context: @context) if Macro.respond_to?(func)
+        # If e evaluates to a map, then e.f is equivalent to e['f'] (where f is
+        # still being used as a meta-variable, e.g. the expression x.foo is equivalent
+        # to the expression x['foo'] when x evaluates to a map).
+
+        if args
+          var.public_send(func, *args)
+        else
+          begin
+            var.public_send(func)
+          rescue NoMethodError
+            raise NoSuchKeyError.new(var, func)
+          end
+        end
+      when List
+        return Macro.__send__(func, var, *args, program: self) if !Module.respond_to?(func) && Macro.respond_to?(func)
 
         # If e evaluates to a map, then e.f is equivalent to e['f'] (where f is
         # still being used as a meta-variable, e.g. the expression x.foo is equivalent
         # to the expression x['foo'] when x evaluates to a map).
 
         args ?
-        var.public_send(func, *args) :
+        var.public_send(func, *Array(args).map(&method(:call))) :
         var.public_send(func)
       when Timestamp, Duration
         raise EvaluateError, "#{invoke} is not supported" unless var.class.method_defined?(func, false)
 
+        # eliminate protobuf API from the lookup
+        raise NoMatchingOverloadError.new(var, func) if Protobuf.base_class.instance_methods.include?(func)
+
+        # If e evaluates to a message and f is not declared in this message, the
+        # runtime error no_such_field is raised.
+        raise NoSuchFieldError.new(var, func) unless var.respond_to?(func)
+
         var.public_send(func, *args)
+      when Literal
+        # eliminate ruby API from the lookup
+        raise NoMatchingOverloadError.new(var, func) if Literal.instance_methods.include?(func)
+
+        # If e evaluates to a message and f is not declared in this message, the
+        # runtime error no_such_field is raised.
+        raise NoSuchFieldError.new(var, func) unless var.respond_to?(func)
+
+        var.public_send(func)
+      when Protobuf.base_class
+        # eliminate protobuf API from the lookup
+        raise NoMatchingOverloadError.new(var, func) if Protobuf.base_class.instance_methods.include?(func)
+
+        # If e evaluates to a message and f is not declared in this message, the
+        # runtime error no_such_field is raised.
+        raise NoSuchFieldError.new(var, func) unless var.respond_to?(func)
+
+        value = Protobuf.lookup(var, func)
+
+        Literal.to_cel_type(value)
       else
+        if var.is_a?(Module) && var.const_defined?(func)
+          # this block assumes a message based call on a protobuf message, either to a
+          # subclass/namespace (Foo.Bar), or an enum (Foo.BAR)
+          # protobuf accessing enum module
+          enum = var.const_get(func)
+
+          if args.nil?
+            case enum
+            when Integer
+              # enum lookup
+              return Protobuf.convert_to_enum(enum, var)
+            else
+              return enum
+            end
+          else
+            arg = call(args.first)
+            value = case arg
+                    when Number
+                      Protobuf.convert_to_enum(arg.value, enum)
+                    when String
+                      resolved_arg = enum.resolve(arg.to_sym)
+                      raise EvaluateError, "#{arg} is invalid" unless resolved_arg
+
+                      Protobuf.convert_to_enum(resolved_arg, enum)
+            end
+          end
+          return Literal.to_cel_type(value)
+        end
+
         raise EvaluateError, "#{invoke} is not supported"
       end
     end
 
     def evaluate_condition(condition)
-      call(condition.if).value ? call(condition.then) : call(condition.else)
+      if_value = call(condition.if)
+
+      raise InvalidArgument, condition.if unless if_value.type == TYPES[:bool]
+
+      if_value.value ? call(condition.then) : call(condition.else)
     end
 
     def evaluate_standard_func(funcall)
@@ -131,25 +331,39 @@ module Cel
 
       case func
       when :type
-        val = call(args.first)
-        return val.type if val.respond_to?(:type)
+        operand = args.first
+        val = call(operand)
+        case val
+        when Protobuf.enum_class
+          val.enum_type
+        else
+          if val.respond_to?(:type)
+            val.type
+          else
+            val.class
+          end
+        end
 
-        val.class
       # MACROS
-      when :has
-        Macro.__send__(func, *args)
-      when :size
-        Cel::Number.new(:int, Macro.__send__(func, *args))
-      when :matches
-        Macro.__send__(func, *args.map(&method(:call)))
-      when :int, :uint, :string, :double, :bytes, :duration, :timestamp
+      when :has, :matches, :size
+        Macro.__send__(func, *args, program: self)
+      when :int, :uint, :string, :double, :bytes, :duration, :timestamp, :bool
         type = TYPES[func]
-        type.cast(call(args.first))
+        op_value = call(args.first)
+        type.cast(op_value)
       when :dyn
         call(args.first)
       else
         return evaluate_custom_func(@context.declarations[func], funcall) if @context.declarations.key?(func)
 
+        # enum conversion
+        proto_type = Protobuf.convert_to_proto_type(func.to_s, @environment.package)
+
+        if proto_type && proto_type.respond_to?(:resolve)
+          op_value = call(args.first)
+          return Protobuf.convert_to_enum(op_value.value)
+        end
+
         raise EvaluateError, "#{funcall} is not supported"
       end
     end

data/lib/cel/version.rb

@@ -2,6 +2,6 @@
 
 module Cel
   module Ruby
-    VERSION = "0.2.3"
+    VERSION = "0.3.1"
   end
 end

data/lib/cel.rb

@@ -4,6 +4,7 @@ require "bigdecimal"
 require "cel/version"
 require "cel/errors"
 require "cel/ast/types"
+require "cel/ast/elements"
 require "cel/parser"
 require "cel/macro"
 require "cel/context"
@@ -12,8 +13,227 @@ require "cel/checker"
 require "cel/program"
 require "cel/environment"
 
+begin
+  require "tzinfo"
+rescue LoadError # rubocop:disable Lint/SuppressedException
+end
+
+begin
+  require "cel/ast/elements/protobuf"
+rescue LoadError => e
+  puts e
+  module Cel
+    class << self
+      # returns a struct class containing the attributes that one would
+      # have expected from the protobuf stub equivalent.
+      def message_container(name, struct)
+        mod = Cel.package_to_module_name(name.to_s)
+
+        if Object.const_defined?(mod)
+          Object.const_get(mod)
+        else
+          struct_keys = container_struct_keys(mod, struct)
+          struct_class = container_struct(mod, struct_keys)
+
+          klass = Object
+
+          *namespaces, mod = mod.split("::")
+
+          namespaces.each do |nm|
+            klass = if klass.const_defined?(nm)
+              klass.const_get(nm)
+            else
+              klass.const_set(nm, Module.new)
+            end
+          end
+
+          klass.const_set(mod, struct_class)
+        end
+      end
+
+      def container_struct(mod, struct_keys)
+        ::Struct.new(*struct_keys, keyword_init: true) do
+          case mod
+          when "Google::Protobuf::BytesValue",
+              "Google::Protobuf::Int32Value",
+              "Google::Protobuf::Int64Value",
+              "Google::Protobuf::UInt32Value",
+              "Google::Protobuf::UInt64Value",
+              "Google::Protobuf::DoubleValue",
+              "Google::Protobuf::FloatValue"
+
+            def initialize(*, **)
+              super
+              self.value ||= 0
+            end
+          when "Google::Protobuf::StringValue"
+            def initialize(*, **)
+              super
+              self.value ||= ""
+            end
+          end
+        end
+      end
+
+      def container_struct_keys(mod, struct)
+        keys = struct.nil? ? [] : struct.keys
+
+        # handle wrapper types
+        case mod
+        when "Google::Protobuf::Any"
+          keys.push(:type_url, :value)
+        when "Google::Protobuf::ListValue"
+          keys << :values
+        when "Google::Protobuf::Struct"
+          keys << :fields
+        when "Google::Protobuf::Value"
+          keys.push(:bool_value, :number_value, :int64_value, :uint64_value, :double_value, :string_value,
+                    :bytes_value, :enum_value, :object_value, :struct_value, :map_value, :list_value, :type_value)
+        when "Google::Protobuf::BytesValue",
+            "Google::Protobuf::Int32Value",
+            "Google::Protobuf::Int64Value",
+            "Google::Protobuf::UInt32Value",
+            "Google::Protobuf::UInt64Value",
+            "Google::Protobuf::DoubleValue",
+            "Google::Protobuf::FloatValue",
+            "Google::Protobuf::BoolValue",
+            "Google::Protobuf::NullValue",
+            "Google::Protobuf::StringValue"
+          keys << :value
+        when "Google::Protobuf::Timestamp",
+             "Google::Protobuf::Duration"
+          keys.push(:seconds, :nanos)
+        end
+
+        keys.uniq
+      end
+    end
+
+    module Protobuf
+      module_function
+
+      BASE_CLASS = Class.new(Object)
+
+      def base_class
+        Struct
+      end
+
+      def enum_class
+        BASE_CLASS
+      end
+
+      def map_class
+        BASE_CLASS
+      end
+
+      def timestamp_class
+        BASE_CLASS
+      end
+
+      def duration_class
+        BASE_CLASS
+      end
+
+      def convert_to_proto(message_type, values)
+        message_type.new(**values)
+      end
+
+      def convert_to_proto_type(*); end
+
+      def try_invoke_from(var, func, args)
+        case var
+        when "NullValue", "google.protobuf.NullValue"
+
+          Cel::Null.new if func == "NULL_VALUE" && args.nil?
+
+        end
+      end
+
+      def try_convert_from_wrapper(struct)
+        case struct.class.name
+        when "ListValue", "Google::Protobuf::ListValue"
+          struct.values
+        when "Struct", "Google::Protobuf::Struct"
+          struct.fields
+        when "Value", "Google::Protobuf::Value"
+          _, value = struct.each_pair.find { |_, v| !v.nil? }
+
+          try_convert_from_wrapper(value)
+        when "BytesValue", "Google::Protobuf::BytesValue"
+          Cel::Bytes.new(struct.value.bytes)
+        when "Int32Value", "Google::Protobuf::Int32Value",
+            "Int64Value", "Google::Protobuf::Int64Value"
+          Cel::Number.new(:int, struct.value)
+        when "UInt32Value", "Google::Protobuf::UInt32Value",
+            "UInt64Value", "Google::Protobuf::UInt64Value"
+          Cel::Number.new(:uint, struct.value)
+        when "DoubleValue", "Google::Protobuf::DoubleValue",
+            "FloatValue", "Google::Protobuf::FloatValue"
+          Cel::Number.new(:double, struct.value)
+        when "BoolValue", "Google::Protobuf::BoolValue",
+            "NullValue", "Google::Protobuf::NullValue",
+            "StringValue", "Google::Protobuf::StringValue"
+          struct.value
+        when "Google::Protobuf::Timestamp"
+          value = (struct.seconds || 0) +
+                  ((struct.nanos || 0) / 1_000_000)
+          Cel::Timestamp.new(value)
+        when "Google::Protobuf::Duration"
+          value = (struct.seconds || 0) +
+                  ((struct.nanos || 0) / 1_000_000)
+          Cel::Duration.new(value)
+        else
+          struct
+        end
+      end
+
+      def try_convert_from_wrapper_type(type)
+        case type
+        when "Any", "google.protobuf.Any",
+             "Value", "google.protobuf.Value"
+          TYPES[:any]
+        when "ListValue", "google.protobuf.ListValue"
+          TYPES[:list]
+        when "BytesValue", "google.protobuf.BytesValue"
+          TYPES[:bytes]
+        when "Int32Value", "google.protobuf.Int32Value",
+            "Int64Value", "google.protobuf.Int64Value"
+          TYPES[:int]
+        when "UInt32Value", "google.protobuf.UInt32Value",
+            "UInt64Value", "google.protobuf.UInt64Value"
+          TYPES[:uint]
+        when "DoubleValue", "google.protobuf.DoubleValue",
+            "FloatValue", "google.protobuf.FloatValue"
+          TYPES[:double]
+        when "BoolValue", "google.protobuf.BoolValue"
+          TYPES[:bool]
+        when "NullValue", "google.protobuf.NullValue"
+          TYPES[:null]
+        when "StringValue", "google.protobuf.StringValue"
+          TYPES[:string]
+        when "google.protobuf.Timestamp"
+          TYPES[:timestamp]
+        when "google.protobuf.Duration"
+          TYPES[:duration]
+        else
+          TYPES[:map]
+        end
+      end
+
+      def method_missing(*) # rubocop:disable Style/MissingRespondToMissing
+        raise Cel::Error, "\"google/protobuf\" is required in order to use this feature"
+      end
+    end
+  end
+end
+
 module Cel
-  def self.to_numeric(anything)
+  MAX_INT = (2**63)
+  MAX_FLOAT = (2**63)
+
+  module_function
+
+  def to_numeric(anything)
     num = BigDecimal(anything.to_s)
     if num.frac.zero?
       num.to_i
@@ -21,4 +241,15 @@ module Cel
       num.to_f
     end
   end
+
+  def package_to_module_name(type)
+    namespace, type_msg = type.split("/", 2)
+    type_msg ||= namespace # sometimes there's no namespace
+
+    return unless /[[:upper:]]/.match?(type_msg)
+
+    type_msg.split(".").map do |typ|
+      /[[:upper:]]/.match?(typ[0]) ? typ : typ.capitalize
+    end.join("::")
+  end
 end