cel 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bcb8e069501a6c9cfdf6af67f83701111d67130d04a9208a05482d14ac1c519a
-  data.tar.gz: 0af115f5924dd63f926227fd916c2fe3f2b25bb6a68e682df1c9f5be36b1be6f
+  metadata.gz: 82fcb37e45c0553a7c073b58e4c6b7203cc50bd186419724d72f5f1b0217e3f5
+  data.tar.gz: 44170fc7001634abc19860db8dcbc8c05ae8974716ad80dd28c4316dc0cec7f3
 SHA512:
-  metadata.gz: d78064a96c11a026f1b6f16a3ebdfed6f3f528170975ab9c26b1e7438c7805419830418f32e7b6557bafeace936c35f1dc18f695a1294862780c2aff9e0bc335
-  data.tar.gz: 9897a6ed3a7708cefaf1b6bd24f86802b1c50709cbbb9bab1fd843e31e3dc1f1f049f4770afa0c34ed89c91b30442a95738b30eb52d91e64d99f1dbc880e0de9
+  metadata.gz: 593ec20b7001fe593d6df79928ca8411327251fff2405491eb33642299cf6bc09d255d0088fdb6a1deda77eabccf8bcce229ad5038f68ee932f9c10ef162cdc0
+  data.tar.gz: 55eb21528a3ff994f5fc013ca49ded2b7cb0aaf9d5d434c671fc0cd534ed0119269c1e2bf8b5fe9e44ba1f1e05f51d30f5fd84abd1f44d740898dd971b341ece

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 ## [Unreleased]
 
+## [0.3.1] - 2025-08-01
+
+### Improvements
+
+* Support for depth protection, using the defaults from the spec (ex: recursion depth of 32, nesting depth of 32), and supporting API to override them (ex: `Cel::Environment.new(max_recursion_depth: 42))`).
+* lazy-evaluating bindings to avoid upfront costly transformations of ruby objects into cel objects which are ultimately not used in expressions.
+
+### Bugfixes
+
+* `has()` macro correctly works for mapsl
+
 ## [0.3.0] - 2025-06-12
 
 ### Features

data/README.md

@@ -32,7 +32,7 @@ The usage pattern follows the pattern defined by [cel-go](https://github.com/goo
 require "cel"
 
 # set the environment
-env = Cel::Environment.new(name: :string, group: :string)
+env = Cel::Environment.new(declarations: { name: :string, group: :string })
 
 # 1.1 parse
 begin
@@ -67,20 +67,52 @@ end
 puts return_value #=> true
 ```
 
-### types
+### Environment
 
-`cel-ruby` supports declaring the types of variables in the environment, which allows for expression checking:
+`Cel::Environment` is the entrypoint for parsing, checking and evaluating CEL expressions, as well as customizing/constraining any of these functions. For that matter, it can be initialized with the following keyword arguments:
+
+* `:declarations`: a hash of the expected variables names-to-cel-types, which are used to validate the expression and data bindings. When variables aren't declared, they assume the `any` type.
+* `:container`: used to declare the package of protobuf messages only declared by name used in the expression (i.e. `cel.expr.conformance.proto3`).
+* `:disable_check`: (defaults to `false`) enables/disables expression check phase (except when `env.check(expr)` is explicitly called).
+* `max_recursion_depth`: (defaults to `32`) max number of parsable recursive/repeating rules, as per what the spec states.
+* `max_nesting_depth`: (defaults to `12`) max number of parsable nested rules, as per what the spec states.
+
+#### declarations
+
+`cel-ruby` supports declaring the types of variables in the environment, which enhances expression type checking:
 
 ```ruby
+# without declarations
+env = Cel::Environment.new
+env.check("[first_name] + middle_names + [last_name]") #=> any
+
+# with declarations
 env = Cel::Environment.new(
-  first_name: :string, # shortcut for Cel::Types[:string]
-  middle_names: Cel::Types[:list, :string], # list of strings
-  last_name: :string
+  declarations: {
+    first_name: :string, # shortcut for Cel::Types[:string]
+    middle_names: Cel::TYPES[:list, :string], # list of strings
+    last_name: :string
+  }
 )
+env.check("[first_name] + middle_names + [last_name]") #=> list(string)
+
+# you can use Cel::TYPES to access any type of primitive type, i.e. Cel::TYPES[:bytes]
+```
+
+#### :container
+
+This can be used to simplify writing CEL expressions with long protobuf package declarations:
 
-# you can use Cel::Types to access any type of primitive type, i.e. Cel::Types[:bytes]
+```ruby
+env = Cel::Environment.new
+env.evaluate("my.company.private.protobufs.Account{id: 2}.id)")
+# or
+env = Cel::Environment.new(container: "my.company.private.protobufs.")
+env.evaluate("Account{id: 2}.id)")
 ```
 
+**Note**: the `google.protobuf` packaged is already supported OOTB.
+
 ### protobuf
 
 If `google/protobuf` is available in the environment, `cel-ruby` will also be able to integrate with protobuf declarations in CEL expressions.

data/lib/cel/ast/elements/protobuf.rb

@@ -8,6 +8,25 @@ require "google/protobuf/well_known_types"
 
 module Cel
   module Protobuf
+    PROTOBUF_VALUES = Set.new(
+      ["Any", "google.protobuf.Any",
+       "ListValue", "google.protobuf.ListValue",
+       "Struct", "google.protobuf.Struct",
+       "Value", "google.protobuf.Value",
+       "BoolValue", "google.protobuf.BoolValue",
+       "BytesValue", "google.protobuf.BytesValue",
+       "DoubleValue", "google.protobuf.DoubleValue",
+       "FloatValue", "google.protobuf.FloatValue",
+       "Int32Value", "google.protobuf.Int32Value",
+       "Int64Value", "google.protobuf.Int64Value",
+       "Uint32Value", "google.protobuf.Uint32Value",
+       "Uint64Value", "google.protobuf.Uint64Value",
+       "NullValue", "google.protobuf.NullValue",
+       "StringValue", "google.protobuf.StringValue",
+       "Timestamp", "google.protobuf.Timestamp",
+       "Duration", "google.protobuf.Duration"]
+    )
+
     module_function
 
     def base_class
@@ -294,34 +313,18 @@ module Cel
     end
 
     def try_invoke_from(var, func, args)
-      case var
-      when "Any", "google.protobuf.Any",
-        "ListValue", "google.protobuf.ListValue",
-        "Struct", "google.protobuf.Struct",
-        "Value", "google.protobuf.Value",
-        "BoolValue", "google.protobuf.BoolValue",
-        "BytesValue", "google.protobuf.BytesValue",
-        "DoubleValue", "google.protobuf.DoubleValue",
-        "FloatValue", "google.protobuf.FloatValue",
-        "Int32Value", "google.protobuf.Int32Value",
-        "Int64Value", "google.protobuf.Int64Value",
-        "Uint32Value", "google.protobuf.Uint32Value",
-        "Uint64Value", "google.protobuf.Uint64Value",
-        "NullValue", "google.protobuf.NullValue",
-        "StringValue", "google.protobuf.StringValue",
-        "Timestamp", "google.protobuf.Timestamp",
-        "Duration", "google.protobuf.Duration"
-        protoclass = var.split(".").last
-        protoclass = Google::Protobuf.const_get(protoclass)
-
-        value = if args.nil? && protoclass.constants.include?(func.to_sym)
-          protoclass.const_get(func)
-        else
-          protoclass.__send__(func, *args)
-        end
+      return unless var.respond_to?(:to_str) && PROTOBUF_VALUES.include?(var.to_str)
 
-        Literal.to_cel_type(value)
+      protoclass = var.split(".").last
+      protoclass = Google::Protobuf.const_get(protoclass)
+
+      value = if args.nil? && protoclass.constants.include?(func.to_sym)
+        protoclass.const_get(func)
+      else
+        protoclass.__send__(func, *args)
       end
+
+      Literal.to_cel_type(value)
     end
 
     # finds value for +attribute+ declared in the +proto+.

data/lib/cel/ast/elements.rb

@@ -37,12 +37,13 @@ module Cel
   class Message
     EMPTY_STRUCT = {}.freeze
 
-    attr_reader :name, :struct, :package
+    attr_reader :name, :struct, :package, :depth
 
-    def initialize(name, struct, package: nil)
+    def initialize(name, struct, package: nil, depth: 1)
       @struct = struct ? struct.transform_keys(&:to_sym) : EMPTY_STRUCT
       @name = name
       @package = package
+      @depth = depth
     end
 
     def type
@@ -83,7 +84,7 @@ module Cel
   class Invoke
     attr_accessor :var
 
-    attr_reader :func, :args
+    attr_reader :func, :args, :depth
 
     def self.new(func:, var: nil, args: nil, **rest)
       Protobuf.try_invoke_from(var, func, args) || super
@@ -93,11 +94,12 @@ module Cel
       TYPES[:any]
     end
 
-    def initialize(func:, var: nil, args: nil, package: nil)
+    def initialize(func:, var: nil, args: nil, depth: 1, package: nil)
       @var = var
       @func = func.to_sym
       @args = args
       @package = package
+      @depth = depth
     end
 
     def ==(other)
@@ -113,7 +115,7 @@ module Cel
 
     def to_s
       if var
-        if func == :[]
+        if indexing?
           "#{var}[#{args}]"
         else
           "#{var}.#{func}#{"(#{args.map(&:to_s).join(", ")})" if args}"
@@ -134,6 +136,10 @@ module Cel
 
       proto_type.const_get(@func)
     end
+
+    def indexing?
+      @func == :[]
+    end
   end
 
   class Function
@@ -392,11 +398,14 @@ module Cel
   end
 
   class List < Literal
-    def initialize(value)
+    attr_reader :depth
+
+    def initialize(value, depth: 1)
       value = value.map do |v|
         Literal.to_cel_type(v)
       end
       super(TYPES[:list], value)
+      @depth = depth
     end
 
     def [](key)
@@ -429,22 +438,22 @@ module Cel
     end
 
     def by_max_depth
-      max = @value.max { |a1, a2| depth(a1, 0) <=> depth(a2, 0) }
+      max = @value.max { |a1, a2| calc_depth(a1, 0) <=> calc_depth(a2, 0) }
 
       # return the last value if all options have the same depth
-      return @value.last if (max == @value.first) && (depth(max, 0) == depth(@value.last, 0))
+      return @value.last if (max == @value.first) && (calc_depth(max, 0) == calc_depth(@value.last, 0))
 
       max
     end
 
     private
 
-    def depth(element, acc)
+    def calc_depth(element, acc)
       case element
       when List
-        element.value.map { |el| depth(el, acc + 1) }.max || (acc + 1)
+        element.value.map { |el| calc_depth(el, acc + 1) }.max || (acc + 1)
       when Map
-        element.value.map { |(_, el)| depth(el, acc + 1) }.max || (acc + 1)
+        element.value.map { |(_, el)| calc_depth(el, acc + 1) }.max || (acc + 1)
       else
         acc
       end
@@ -453,13 +462,16 @@ module Cel
 
   class Map < Literal
     ALLOWED_TYPES = %i[int uint bool string].map { |typ| TYPES[typ] }.freeze
-    def initialize(value)
+
+    attr_reader :depth
+
+    def initialize(value, depth: 1)
       # store array internally to support repeated keys
       value = value.map do |k, v|
         [Literal.to_cel_type(k), Literal.to_cel_type(v)]
       end
       super(TYPES[:map], value)
-      check
+      @depth = depth
     end
 
     def ==(other)
@@ -507,13 +519,19 @@ module Cel
     end
 
     def respond_to_missing?(meth, *args)
-      super || (@value && @value.any? { |k, _| k.to_s == meth.to_s })
+      return true if super
+      return false unless @value
+
+      meth_s = meth.to_s
+
+      @value.any? { |k, _| k == meth_s }
     end
 
     def method_missing(meth, *args)
       return super unless @value
 
-      values = @value.filter_map { |k, v| v if k.to_s == meth.to_s }
+      meth_s = meth.to_s
+      values = @value.filter_map { |k, v| v if k == meth_s }
 
       return super if values.empty?
 
@@ -760,14 +778,15 @@ module Cel
   end
 
   class Operation
-    attr_reader :op, :operands
+    attr_reader :op, :operands, :depth
 
     attr_accessor :type
 
-    def initialize(op, operands)
+    def initialize(op, operands, depth: 1)
       @op = op
       @operands = operands
       @type = TYPES[:any]
+      @depth = depth
     end
 
     def ==(other)
@@ -795,12 +814,13 @@ module Cel
   end
 
   class Condition
-    attr_reader :if, :then, :else
+    attr_reader :if, :then, :else, :depth
 
-    def initialize(if_, then_, else_)
+    def initialize(if_, then_, else_, depth: 1)
       @if = if_
       @then = then_
       @else = else_
+      @depth = depth
     end
 
     def type

data/lib/cel/ast/types.rb

@@ -176,7 +176,7 @@ module Cel
     end
 
     def cast(value)
-      List.new(value)
+      value.is_a?(List) ? value : List.new(value)
     end
   end
 
@@ -203,7 +203,7 @@ module Cel
     end
 
     def cast(value)
-      Map.new(value)
+      value.is_a?(Map) ? value : Map.new(value)
     end
   end
 

data/lib/cel/context.rb

@@ -7,23 +7,6 @@ module Cel
     def initialize(declarations, bindings)
       @declarations = declarations
       @bindings = bindings.dup
-
-      return unless @bindings
-
-      @bindings.each do |k, v|
-        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
 
     def lookup(identifier)
@@ -39,6 +22,7 @@ module Cel
         fetched = false
         (0...lookup_keys.size).reverse_each do |idx|
           key = lookup_keys[0..idx].join(".").to_sym
+          is_binding = val == @bindings
 
           val = if val.respond_to?(:key?)
             # hash
@@ -56,7 +40,8 @@ module Cel
             end
           end
 
-          lookup_keys = lookup_keys[idx + 1..]
+          val = @bindings[key] = to_cel_primitive(key, val) if is_binding
+          lookup_keys = lookup_keys[(idx + 1)..]
           fetched = true
           break
         end
@@ -86,5 +71,19 @@ module Cel
     def to_cel_type(v)
       Literal.to_cel_type(v)
     end
+
+    def to_cel_primitive(k, v)
+      if @declarations && (type = @declarations[k])
+        type = TYPES[type] if type.is_a?(Symbol)
+
+        if type.is_a?(Class) && type < Protobuf.base_class
+          Protobuf.convert_to_proto(type, v)
+        else
+          type.cast(to_cel_type(v))
+        end
+      else
+        to_cel_type(v)
+      end
+    end
   end
 end

data/lib/cel/environment.rb

@@ -4,7 +4,12 @@ module Cel
   class Environment
     attr_reader :declarations, :package
 
-    def initialize(declarations: nil, container: nil, disable_check: false)
+    def initialize(
+      declarations: nil,
+      container: nil,
+      disable_check: false,
+      **kwargs
+    )
       @disable_check = disable_check
       @declarations = declarations
       @container = container
@@ -28,7 +33,7 @@ module Cel
         @package = Object.const_get(proto_module_name) if Object.const_defined?(proto_module_name)
       end
 
-      @parser = Parser.new(package)
+      @parser = Parser.new(package, **kwargs)
     end
 
     def compile(expr)

data/lib/cel/errors.rb

@@ -5,6 +5,9 @@ module Cel
 
   class ParseError < Error; end
 
+  class MaxRecursionDepthExceededError < ParseError; end
+  class MaxNestingDepthExceededError < ParseError; end
+
   class CheckError < Error; end
 
   class EvaluateError < Error; end

data/lib/cel/macro.rb

@@ -13,12 +13,13 @@ module Cel
     #     If f is some other singular field, has(e.f) indicates whether the field's value is its default
     #       value (zero for numeric fields, false for booleans, empty for strings and bytes).
     def has(invoke, program:)
-      var = invoke.var
       func = invoke.func
+      var = program.disable_cel_conversion do
+        program.evaluate(invoke.var)
+      end
 
       case var
-      when Message
-        var = program.evaluate(var)
+      when Protobuf.base_class
         # If e evaluates to a message and f is not a declared field for the message,
         # has(e.f) raises a no_such_field error.
         raise NoSuchFieldError.new(var, func) unless var.respond_to?(func)

data/lib/cel/parser.rb

@@ -89,7 +89,14 @@ var void while
 
 IDENTIFIER_REGEX = /[_a-zA-Z][_a-zA-Z0-9]*/
 
-def initialize(package = nil)
+def initialize(
+  package = nil,
+  max_recursion_depth: 32,
+  max_nesting_depth: 12,
+  expression_size_limit: 2048
+)
+  @max_recursion_depth = max_recursion_depth
+  @max_nesting_depth = max_nesting_depth
   @package = package
 end
 
@@ -243,12 +250,49 @@ def literal_null
   Cel::Null::INSTANCE
 end
 
-def new_map(val)
-  Cel::Map.new(val)
+def new_map(elements)
+  depth = 1
+
+  if elements.size > @max_recursion_depth
+    raise MaxRecursionDepthExceededError, "max number of map elements exceeded"
+  end
+
+  depth = elements.filter_map do |_, elem|
+    next unless elem.is_a?(Cel::Map)
+
+    d = depth + elem.depth
+
+    if d > @max_nesting_depth
+      raise MaxNestingDepthExceededError, "max nesting of map literals exceeded"
+    end
+
+    d
+  end.max || depth
+
+  Cel::Map.new(elements, depth: depth)
 end
 
 def new_list(val)
-  Cel::List.new(Array(val))
+  elements = Array(val)
+  depth = 1
+
+  if elements.size > @max_recursion_depth
+    raise MaxRecursionDepthExceededError, "max number of elements for list literals exceeded"
+  end
+
+  depth = elements.filter_map do |elem|
+    next unless elem.is_a?(Cel::List)
+
+    d = depth + elem.depth
+
+    if d > @max_nesting_depth
+      raise MaxNestingDepthExceededError, "max nesting of list literals exceeded"
+    end
+
+    d
+  end.max || depth
+
+  Cel::List.new(elements, depth: depth)
 end
 
 def new_identifier(id)
@@ -256,19 +300,159 @@ def new_identifier(id)
 end
 
 def new_message(type, struct)
-  Cel::Message.new(type, struct, package: @package)
+  depth = 1
+  if struct
+    if struct.size > @max_recursion_depth
+      raise MaxRecursionDepthExceededError, "max number of message elements exceeded"
+    end
+
+    depth = struct.filter_map do |_, elem|
+      next unless elem.is_a?(Cel::Message)
+
+      d = depth + elem.depth
+
+      if d > @max_nesting_depth
+        raise MaxNestingDepthExceededError, "max nesting of map literals exceeded"
+      end
+
+      d
+    end.max || depth
+  end
+
+  Cel::Message.new(type, struct, package: @package, depth: depth)
 end
 
 def global_call(function, args = nil)
-  Cel::Invoke.new(func: function, var: nil, args: args, package: @package)
+  depth = 1
+
+  if args && args.size > @max_recursion_depth
+    raise MaxRecursionDepthExceededError, "max number of function call arguments exceeded"
+  end
+
+  depth = args.filter_map do |arg|
+    next unless arg.is_a?(Cel::Invoke)
+
+    d = depth + arg.depth
+
+    if d > @max_nesting_depth
+      raise MaxNestingDepthExceededError, "max nesting of function calls exceeded"
+    end
+
+    d
+  end.max || depth
+
+  Cel::Invoke.new(func: function, var: nil, args: args, package: @package, depth: depth)
 end
 
-def receiver_call(function, target, args = nil)
-  Cel::Invoke.new(func: function, var: target, args: args, package: @package)
+def indexing_call(target, args)
+  depth = 1
+
+  if target.is_a?(Cel::Invoke)
+    depth += target.depth if target.indexing?
+
+    if depth > @max_nesting_depth
+      raise MaxNestingDepthExceededError, "max nesting of indexing operators exceeded"
+    end
+  end
+
+  receiver_call(:[], target, args, package: @package, depth: depth)
 end
 
-def operation(op, operands)
-  Cel::Operation.new(op, operands)
+def selector_call(function, target)
+  depth = 1
+
+  # if selector operator
+  if target.is_a?(Cel::Invoke) && !target.var.nil?
+    depth += target.depth
+
+    if depth > @max_nesting_depth
+      raise MaxNestingDepthExceededError, "max nesting of selection operators exceeded"
+    end
+  end
+
+  receiver_call(function, target, package: @package, depth: depth)
+end
+
+def receiver_call(function, target, args = nil, **kwargs)
+  Cel::Invoke.new(func: function, var: target, args: args, package: @package, **kwargs)
+end
+
+def logical_operation(op, operands)
+  lhs, rhs = operands
+
+  if lhs.is_a?(Cel::Operation) && lhs.op == op
+    # concat them
+    operands = [*lhs.operands, rhs]
+  end
+
+  if operands.size - 1 > @max_recursion_depth
+    raise Cel::MaxRecursionDepthExceededError, "max recursion depth exceeded for #{op} operation"
+  end
+
+  operation(op, operands)
+end
+
+def math_operation(op, operands)
+  # 32 binary arithmetic operators of the same precedence in a row
+  lhs, _ = operands
+  depth = 1
+
+  if lhs.is_a?(Cel::Operation)
+    case op
+    when "*", "/", "%"
+      case lhs.op
+      when  "*", "/", "%"
+        depth = lhs.depth + 1
+      end
+    when "+", "+"
+      case lhs.op
+      when  "+", "+"
+        depth = lhs.depth + 1
+      end
+    end
+  end
+
+  if depth > @max_recursion_depth
+    raise MaxRecursionDepthExceededError, "max number of arithmetic operators with the same precedence exceeded"
+  end
+
+  operation(op, operands, depth: depth)
+end
+
+def unary_operation(op, operand)
+  depth = 1
+
+  if operand.is_a?(Cel::Operation) && operand.op == op && operand.unary?
+    depth = depth + operand.depth
+
+    if depth > @max_recursion_depth
+      raise MaxRecursionDepthExceededError, "max number of an unary operator exceeded"
+    end
+  end
+
+  operation(op, [operand], depth: depth)
+end
+
+def operation(op, operands, **kwargs)
+  Cel::Operation.new(op, operands, **kwargs)
+end
+
+def ternary_condition(if_op, *ops)
+  depth = 1
+
+  depth = ops.filter_map do |op|
+    next unless op.is_a?(Cel::Condition)
+
+    d = depth + op.depth
+
+    if d > @max_recursion_depth
+      raise MaxRecursionDepthExceededError, "max number of consecutive ternary operators exceeded"
+    end
+
+    d
+  end.max || depth
+
+  Cel::Condition.new(if_op, *ops, depth: depth)
 end
 
 # Checks whether the given identifier token is a reserved word or not. Throws
@@ -276,7 +460,7 @@ end
 def validated_id!(identifier)
   return identifier unless RESERVED.include?(identifier)
 
-  raise Cel::ParseError.new("invalid usage of the reserved word \"#{identifier}\"")
+  raise Cel::ParseError, "invalid usage of the reserved word \"#{identifier}\""
 end
 
 ...end parser.ry/module_eval...
@@ -646,7 +830,7 @@ Racc_debug_parser = false
 
 module_eval(<<'.,.,', 'parser.ry', 17)
   def _reduce_4(val, _values, result)
-     result = Cel::Condition.new(val[0], val[2], val[4])
+     result = ternary_condition(val[0], val[2], val[4])
     result
   end
 .,.,
@@ -655,7 +839,7 @@ module_eval(<<'.,.,', 'parser.ry', 17)
 
 module_eval(<<'.,.,', 'parser.ry', 20)
   def _reduce_6(val, _values, result)
-     result = operation(val[1], [val[0], val[2]])
+     result = logical_operation(val[1], [val[0], val[2]])
     result
   end
 .,.,
@@ -664,7 +848,7 @@ module_eval(<<'.,.,', 'parser.ry', 20)
 
 module_eval(<<'.,.,', 'parser.ry', 23)
   def _reduce_8(val, _values, result)
-     result = operation(val[1], [val[0], val[2]])
+     result = logical_operation(val[1], [val[0], val[2]])
     result
   end
 .,.,
@@ -682,14 +866,14 @@ module_eval(<<'.,.,', 'parser.ry', 26)
 
 module_eval(<<'.,.,', 'parser.ry', 29)
   def _reduce_12(val, _values, result)
-     result = operation(val[1], [val[0], val[2]])
+     result = math_operation(val[1], [val[0], val[2]])
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'parser.ry', 30)
   def _reduce_13(val, _values, result)
-     result = operation(val[1], [val[0], val[2]])
+     result = math_operation(val[1], [val[0], val[2]])
     result
   end
 .,.,
@@ -698,7 +882,7 @@ module_eval(<<'.,.,', 'parser.ry', 30)
 
 module_eval(<<'.,.,', 'parser.ry', 33)
   def _reduce_15(val, _values, result)
-     result = operation(val[1], [val[0], val[2]])
+     result = math_operation(val[1], [val[0], val[2]])
     result
   end
 .,.,
@@ -709,21 +893,21 @@ module_eval(<<'.,.,', 'parser.ry', 33)
 
 module_eval(<<'.,.,', 'parser.ry', 38)
   def _reduce_18(val, _values, result)
-     result = operation("!", [val[1]])
+     result = unary_operation("!", val[1])
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'parser.ry', 39)
   def _reduce_19(val, _values, result)
-     result = operation("-", [val[1]])
+     result = unary_operation("-", val[1])
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'parser.ry', 41)
   def _reduce_20(val, _values, result)
-     result = operation("!", [val[1]])
+     result = unary_operation("!", val[1])
     result
   end
 .,.,
@@ -732,7 +916,7 @@ module_eval(<<'.,.,', 'parser.ry', 41)
 
 module_eval(<<'.,.,', 'parser.ry', 44)
   def _reduce_22(val, _values, result)
-     result = operation("-", [val[1]])
+     result = unary_operation("-", val[1])
     result
   end
 .,.,
@@ -743,7 +927,7 @@ module_eval(<<'.,.,', 'parser.ry', 44)
 
 module_eval(<<'.,.,', 'parser.ry', 48)
   def _reduce_25(val, _values, result)
-     result = receiver_call("[]", val[0], val[2])
+     result = indexing_call(val[0], val[2])
     result
   end
 .,.,
@@ -757,7 +941,7 @@ module_eval(<<'.,.,', 'parser.ry', 49)
 
 module_eval(<<'.,.,', 'parser.ry', 50)
   def _reduce_27(val, _values, result)
-     result = receiver_call(val[2], val[0])
+     result = selector_call(val[2], val[0])
     result
   end
 .,.,

data/lib/cel/program.rb

@@ -35,6 +35,16 @@ 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)
@@ -68,21 +78,18 @@ module Cel
     end
 
     def evaluate_message(val)
-      convert_to_cel = @convert_to_cel
-
-      @convert_to_cel = false
-      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)
+      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 value unless convert_to_cel
+        return value unless should_have_converted
 
-      Literal.to_cel_type(value)
-    ensure
-      @convert_to_cel = convert_to_cel
+        Literal.to_cel_type(value)
+      end
     end
 
     def evaluate_operation(operation)

data/lib/cel/version.rb

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

data/lib/cel.rb

@@ -115,7 +115,7 @@ rescue LoadError => e
       BASE_CLASS = Class.new(Object)
 
       def base_class
-        BASE_CLASS
+        Struct
       end
 
       def enum_class

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: cel
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Tiago Cardoso
 bindir: bin
 cert_chain: []
-date: 2025-06-12 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -57,8 +57,8 @@ email:
 executables: []
 extensions: []
 extra_rdoc_files:
-- LICENSE.txt
 - CHANGELOG.md
+- LICENSE.txt
 - README.md
 files:
 - CHANGELOG.md
@@ -99,7 +99,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Pure Ruby implementation of Google Common Expression Language, https://opensource.google/projects/cel.
 test_files: []