cel 0.6.1 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d6d9641e7b6b5cd40bda6d81519f89e9b5bd8e7d8d595306291e6d470ed3aa3c
-  data.tar.gz: 55490419080cc9eba65d907a99001deb7b3fbed08f1fc815e3dba293969162b8
+  metadata.gz: cba7782a9640b53263c12796cdcbf6b65d67265f6017f706cf8ae90c248e77fd
+  data.tar.gz: e7174cae9eab76f1d1fd9bbad8feaa9246dce94e2005b3262b1ba5df283b3d24
 SHA512:
-  metadata.gz: 222160a59e461b0b0b6166fc839edb760b8b696a935c0471cae0f3437d1049215777a613cf9840e4fbd2c85c91fc80798e142de963ad0523eff9e586c9a53bd2
-  data.tar.gz: 6abacc2f4aa0be7f74af0f44fec56bbfb57ccb770f60bb0072aa5334ed9381c7bb75447f948cf85278b40f42714f44139e9a3b6cfc6634e116ba6e821ea54961
+  metadata.gz: 3900c8e0bc26da2a9687f8b25411d308ddc9a4bdecad3aebc3ef751e2645d2fd6027a837eff52863bcdf2751e740fbe2035a4ff55ba5b71acc7c4ef6d7227cc9
+  data.tar.gz: faec09b8bc335bf26bb110a6ba1e36c12e4b60623d6faf3e4546e4fd91a0881d20011e003c4cc2fb41301f42a8658521d436412d66536e568f159ee23b45a850

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 ## [Unreleased]
 
+## [0.6.2] - 2026-09-23
+
+### Features
+
+* Support the lists extension functions, as listed [here](https://deepwiki.com/google/cel-go/9.2-standard-extensions):
+  * slice, flatten, sort, sortBy, distinct, reverse, range
+
+### Improvements
+
+* Expression checker can now type-check Map expressions.
+* Improve type expression for maps, where instead of the element type being the first matched, it'll infer whether all elements of the map are of the same type, and if not, fallback to any.
+
+### Bugfixes
+
+* Fix issue when using map bindings via dot keys in macro expressions.
+* Fix macro evaluation when variable used in expression was an accessor (instead of an identifier).
+* timestamps: require RFC 3339 compliant strings on initialization (instead of all that ruby `Time.parse` accepts).
+
 ## [0.6.1] - 2026-07-27
 
 * parser: enabled support for declaring CEL messages inside a CEL list.

data/README.md

@@ -197,6 +197,7 @@ env.evaluate("ext.random()") #=> 42
 
 * math extensions
 * string extensions
+* list extensions
 * bindings extensions
 * block extensions
 * encoders extensions

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

@@ -4,15 +4,30 @@ require "time"
 
 module Cel
   class Timestamp < Literal
+    # Ruby 4.1 grows a core Time.rfc3339; below that DateTime.rfc3339 is the only stdlib RFC 3339
+    # parser. Gate on the version rather than respond_to?(:rfc3339) alone: ActiveSupport defines
+    # its own, laxer Time.rfc3339 on every ruby - it rolls invalid dates over, turning
+    # "2022-02-30T00:00:00Z" into March 2nd - so probing for the method would silently hand
+    # parsing to ActiveSupport, and only when it happened to be loaded first.
+    CORE_RFC3339 = RUBY_VERSION >= "4.1.0" && Time.respond_to?(:rfc3339)
+    private_constant :CORE_RFC3339
+
+    require "date" unless CORE_RFC3339
+
     TIMESTAMP_RANGE = (Time.parse("0001-01-01T00:00:00Z")..Time.parse("9999-12-31T23:59:59.999999999Z"))
 
     def initialize(value)
       value = case value
-              when ::String then Time.parse(value)
+              when ::String then parse_rfc3339(value)
               when Numeric then Time.at(value)
               else value
       end
 
+      # CEL timestamps are absolute instants carrying no timezone, so normalize to UTC: that is
+      # what the string conversion and the offset-less accessors (getHours & co.) assume. Anything
+      # that is not a time falls through to the range check below, which rejects it.
+      value = value.getutc if value.is_a?(::Time)
+
       raise EvaluateError, "out of range" unless TIMESTAMP_RANGE.include?(value)
 
       super(:timestamp, value.round(9))
@@ -92,6 +107,25 @@ module Cel
 
     private
 
+    # The CEL spec defines timestamp() over RFC 3339 date-times, which always carry an explicit
+    # offset. Time.parse would instead accept anything remotely date-like and silently resolve
+    # offset-less input in the server-local timezone.
+    if CORE_RFC3339
+      def parse_rfc3339(value)
+        Time.rfc3339(value)
+      rescue ArgumentError
+        raise EvaluateError, "invalid timestamp #{value.inspect} (must be an RFC 3339 date-time)"
+      end
+    else
+      # Date::ITALY, the default calendar reform, reads pre-1582 date-times as Julian ones,
+      # shifting them off the proleptic Gregorian calendar Time uses.
+      def parse_rfc3339(value)
+        DateTime.rfc3339(value, Date::GREGORIAN).to_time
+      rescue ArgumentError # Date::Error
+        raise EvaluateError, "invalid timestamp #{value.inspect} (must be an RFC 3339 date-time)"
+      end
+    end
+
     def to_local_time(tz = nil)
       time = @value
       if tz

data/lib/cel/ast/types.rb

@@ -214,25 +214,78 @@ module Cel
   end
 
   class MapType < Type
+    # The map's value type (`V` in `map(K, V)`). Named `element_type` for
+    # symmetry with ListType and because `TYPES[:map, V]` has always set the
+    # declared value type here.
     attr_accessor :element_type
 
+    # The map's key type (`K` in `map(K, V)`).
+    attr_accessor :key_type
+
+    # For a struct-like map literal — every key a constant — the per-key value
+    # types, as `{ <bare key> => Cel::Type }`. `nil` when at least one key is
+    # not a constant, so a caller can tell "no fixed key set" apart from "an
+    # empty one". Purely additional information: `==` compares `map(K, V)`, so
+    # two maps with the same K/V stay equal whatever their fields are.
+    attr_accessor :field_types
+
     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.sample.first.type
+      @key_type = MapType.uniform_type(@type_map.map { |k, _| MapType.node_type(k) })
+      @element_type = MapType.uniform_type(@type_map.map { |_, v| MapType.node_type(v) })
+      @field_types = nil
+    end
+
+    # The single type shared by `types`, or `any` when they disagree (or when
+    # there are none) — the same widening ListType applies to a heterogeneous
+    # list literal.
+    def self.uniform_type(types)
+      types = types.compact
+      return TYPES[:any] if types.empty?
+
+      first_type = types.first
+      types.all? { |type| type == first_type } ? first_type : TYPES[:any]
+    end
+
+    # A map-literal key is a constant or a bare identifier (see `Map#check`);
+    # an identifier key is a field name, i.e. a string.
+    #
+    # TODO: correct this in the parser instead. A bare identifier key is a
+    # field name, so the parser should emit a string node for it rather than an
+    # `Identifier` typed `any` that has to be patched up here.
+    def self.node_type(node)
+      return TYPES[:string] if node.is_a?(Identifier) && node.type == :any
+
+      node.respond_to?(:type) ? node.type : TYPES[:any]
     end
 
     def get(attrib)
+      attrib = attrib.to_s if attrib.is_a?(::Symbol)
       _, 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
+      return true if other.is_a?(::Symbol) && other == :map
+      return super unless other.is_a?(MapType)
+
+      MapType.compatible?(@key_type, other.key_type) &&
+        MapType.compatible?(@element_type, other.element_type)
+    end
+
+    # `any` is CEL's `dyn`: it stands in for an unknown type, so it is
+    # compatible with every other one. A map whose keys or values could not be
+    # narrowed (an empty literal, a heterogeneous one, `TYPES[:map]`) therefore
+    # matches any map, and only two *narrowed* parameters can disagree.
+    def self.compatible?(left, right)
+      return true if left.nil? || right.nil?
+      return true if left.to_sym == :any || right.to_sym == :any
+
+      left == right
     end
 
     def cast(value)

data/lib/cel/checker.rb

@@ -100,6 +100,23 @@ module Cel
       Checker.new(@environment, @declarations ? @declarations.merge(declarations) : declarations)
     end
 
+    def infer_variable_type(var)
+      case var
+      when Identifier
+        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
+    end
+
     private
 
     def check_literal(literal)
@@ -116,12 +133,47 @@ module Cel
         end
         lit
       when Map
-        MapType.new(literal.value)
+        # Check each value expression, so that a type error inside the map literal raises here
+        # instead of surfacing at evaluation time. Keys are not checked: map-literal keys are
+        # constants or identifiers fixed at parse time, not expressions resolved against
+        # declarations (see Map#check).
+        # literal.value is an array of [key, value] pairs here, not a Hash
+        value_types = literal.value.map { |_key, value| call(value) }
+
+        lit = MapType.new(literal.value)
+        # MapType's constructor can only read the types the AST nodes already
+        # carry, and an Invoke/Condition value node carries none until it is
+        # checked. Now that every value expression has been, replace the
+        # constructor's guess with the checked types — the same refinement
+        # the List branch above does with `element_type`.
+        lit.element_type = MapType.uniform_type(value_types)
+        lit.field_types = field_types_for(literal.value, value_types)
+        lit
       else
         literal.type
       end
     end
 
+    # The per-key value types of a struct-like map literal, or nil when at
+    # least one key is not a constant (`{someVar: 1}`), in which case the map
+    # has no statically known key set.
+    def field_types_for(pairs, value_types)
+      fields = {}
+
+      pairs.each_with_index do |(key, _value), index|
+        bare_key =
+          case key
+          when Identifier then key.to_s
+          when Literal then key.value
+          else return nil
+          end
+
+        fields[bare_key] = value_types[index]
+      end
+
+      fields
+    end
+
     def check_message(literal)
       literal.type
     end
@@ -215,23 +267,6 @@ module Cel
       unsupported_type(operation)
     end
 
-    def infer_variable_type(var)
-      case var
-      when Identifier
-        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
-    end
-
     def check_invoke(funcall, var_type = nil)
       var = funcall.var
       func = funcall.func
@@ -240,7 +275,9 @@ module Cel
       return check_standard_func(funcall) unless var
 
       if var.is_a?(Identifier) && @environment.extensions.include?(var.to_sym)
-        return @environment.extensions[var.to_sym].__check(funcall, checker: self)
+        type = @environment.extensions[var.to_sym].__check(funcall, checker: self)
+        unsupported_operation(funcall) unless type
+        return type
       end
 
       var_type ||= infer_variable_type(var)
@@ -265,7 +302,8 @@ module Cel
 
           unsupported_type(funcall) unless identifier.is_a?(Identifier)
 
-          element_checker = merge(identifier.to_sym => var_type.element_type)
+          # A comprehension over a map iterates its KEYS.
+          element_checker = merge(identifier.to_sym => var_type.key_type)
 
           unsupported_type(funcall) if element_checker.check(predicate) != :bool
 
@@ -332,11 +370,10 @@ module Cel
           var_type.element_type = element_checker.check(predicate)
           var_type
         else
-          if @environment.extensions.key?(:strings)
-            return @environment.extensions[:strings].__check(funcall, checker: self)
-          end
+          type = @environment.extensions[:strings]&.__check(funcall, checker: self) ||
+                 @environment.extensions[:lists]&.__check(funcall, checker: self)
 
-          unsupported_operation(funcall)
+          type || unsupported_operation(funcall)
         end
       when TYPES[:string]
         case func
@@ -349,7 +386,9 @@ module Cel
           return TYPES[:bool] if find_match_all_types(%i[string], call(args.first))
         else
           if @environment.extensions.key?(:strings)
-            return @environment.extensions[:strings].__check(funcall, checker: self)
+            type = @environment.extensions[:strings].__check(funcall, checker: self)
+            unsupported_operation(funcall) unless type
+            return type
           end
 
           unsupported_type(funcall)

data/lib/cel/context.rb

@@ -111,7 +111,10 @@ module Cel
     end
 
     def merge(bindings)
-      bindings = bindings.to_h { |k, v| NORMALIZE_KEYS[k, v] }
+      # NORMALIZE_KEYS returns a flat array of keys and values ([k1, v1, k2, v2, ...]),
+      # which must be regrouped into pairs: a map value with more than one key expands
+      # into more than one binding.
+      bindings = bindings.flat_map { |k, v| NORMALIZE_KEYS[k, v].each_slice(2).to_a }.to_h
       if (old_bindings = @bindings)
         if @environment.container
           old_bindings = old_bindings.dup

data/lib/cel/extensions/bind.rb

@@ -13,13 +13,13 @@ module Cel
         func = funcall.func
         args = funcall.args
 
-        return checker.unsupported_operation(funcall) unless func == :bind
+        return unless func == :bind
 
         checker.check_arity(func, args, 3)
 
         id, type, expr = args
 
-        return checker.unsupported_operation(funcall) unless id.is_a?(Identifier)
+        return unless id.is_a?(Identifier)
 
         type = checker.call(type)
 

data/lib/cel/extensions/encoders.rb

@@ -18,14 +18,12 @@ module Cel
           when :encode
             checker.check_arity(func, args, 1)
             arg = checker.call(args.first)
-            return TYPES[:string] if checker.find_match_all_types(%i[bytes], arg)
+            TYPES[:string] if checker.find_match_all_types(%i[bytes], arg)
           when :decode
             checker.check_arity(func, args, 1)
             arg = checker.call(args.first)
-            return TYPES[:bytes] if checker.find_match_all_types(%i[string], arg)
+            TYPES[:bytes] if checker.find_match_all_types(%i[string], arg)
           end
-
-          checker.unsupported_operation(funcall)
         end
 
         def encode(str, program:)

data/lib/cel/extensions/list.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+module Cel
+  module Extensions
+    module List
+      module_function
+
+      def implicit?
+        false
+      end
+
+      def __check(funcall, checker:, var_type: nil)
+        var = funcall.var
+        func = funcall.func
+        args = funcall.args
+
+        var_type ||= checker.infer_variable_type(var)
+
+        case func
+        when :distinct, :reverse
+          checker.check_arity(funcall, args, 0)
+          var_type
+        when :flatten
+          checker.check_arity(funcall, args, 1, :>=)
+          if (arg = args.first) && arg.type != TYPES[:int]
+            checker.unsupported_type(funcall)
+          end
+          TYPES[:list]
+        when :range
+          checker.check_arity(funcall, args, 1)
+          if (arg = args.first) && arg.type != TYPES[:int]
+            checker.unsupported_type(funcall)
+          end
+          var_type
+        when :sort
+          checker.check_arity(funcall, args, 0)
+          checker.unsupported_type(funcall) if %i[list].include?(var_type.element_type)
+          var_type
+        when :sortBy
+          checker.check_arity(funcall, args, 2)
+          identifier, predicate = args
+
+          checker.nsupported_type(funcall) unless identifier.is_a?(Identifier)
+
+          identifier.type = var_type.element_type
+
+          element_checker = checker.merge(identifier.to_sym => var_type.element_type)
+
+          checker.unsupported_type(funcall) if element_checker.check(predicate) != var_type.element_type
+          var_type
+        when :slice
+          checker.check_arity(funcall, args, 2)
+          var_type if checker.find_match_all_types(%i[int], args.map(&checker.method(:call)))
+        end
+      end
+
+      def quote(str, program:)
+        value = program.call(str).value
+
+        # this should use String#dump, but this also replaces printable UTF8 characters
+
+        # replace quotes
+        value = value.gsub(/[\\'"\t\r\a\b\v\f\n]/) { |m| m.dump[1..-2] }
+
+        # replace invalid utf-8 chars
+        value = value.encode(Encoding::UTF_8, invalid: :replace)
+
+        # adding leading quotes if not quoted already
+        value = "\"#{value}\"" unless value.start_with?("\"") && value.end_with?("\"")
+
+        Cel::String.new(value)
+      end
+
+      def range(num, program:)
+        num = program.call(num)
+
+        raise InvalidArgumentError, num unless num.between?(0, 1_000_000)
+
+        Cel::List.new(num.times)
+      end
+    end
+  end
+
+  class List
+    define_cel_method(:distinct) do
+      List.new(@value.uniq)
+    end
+
+    define_cel_method(:flatten) do |*args|
+      depth = args.first || 1
+
+      raise InvalidArgumentError, depth if depth.negative?
+
+      flatten_proc = proc do |dth, el|
+        case el
+        when List
+          case dth
+          when 0
+            el
+          when nil
+            el.value.map do |el2|
+              flatten_proc.call(dth, el2)
+            end
+          else
+            el.value.map do |el2|
+              flatten_proc.call(dth - 1, el2)
+            end
+          end
+        else
+          el
+        end
+      end
+
+      # Array#flatten does not know how to flatten lists; we'll need to turn
+      # lists into arrays so we can call Array#flatten.
+      flattenable_value = @value.map(&flatten_proc.curry.call(depth))
+
+      List.new(flattenable_value.flatten(depth))
+    end
+
+    define_cel_method(:reverse) do
+      List.new(@value.reverse)
+    end
+
+    define_cel_method(:sort) do
+      if @value.size == 1
+        # #sort call below won't enter the block otherwise, but cel requires
+        # validation of the unique element
+        el1 = @value.first
+        raise InvalidArgumentError, el1 if el1.is_a?(List)
+      end
+
+      sorted_value = @value.sort do |el1, el2|
+        raise InvalidArgumentError, el1 if el1.is_a?(List)
+        raise InvalidArgumentError, el2 if el2.is_a?(List)
+
+        el1 <=> el2
+      end
+      List.new(sorted_value)
+    end
+
+    define_cel_method(:slice) do |a, b|
+      raise InvalidArgumentError, a if a.negative?
+      raise InvalidArgumentError, b if b > @value.size
+
+      List.new(@value.slice(a, b - a))
+    end
+  end
+
+  class Bool
+    def <=>(other)
+      return 0 unless other.is_a?(Bool) && @value != other.value
+
+      case @value
+      when false
+        # then other is true
+        -1
+      when true
+        # then other is false
+        1
+      end
+    end
+  end
+
+  class Bytes
+    def <=>(other)
+      return 0 unless other.is_a?(Bytes)
+
+      @value <=> other.value
+    end
+  end
+
+  module Macro
+    def sortBy(collection, *identifiers, predicate, program:) # rubocop:disable Naming/MethodName
+      identifiers = identifiers.map(&:to_sym)
+
+      sorted_collection = collection.zip(
+        with_context(collection, identifiers).map do |context|
+          program.with_extra_context(context).evaluate(predicate)
+        end
+      ).sort do |(_, pred1), (_, pred2)|
+        pred1 <=> pred2
+      end.map(&:first)
+
+      List.new(sorted_collection)
+    end
+  end
+end

data/lib/cel/extensions/math.rb

@@ -17,31 +17,29 @@ module Cel
         when :round, :trunc, :floor, :ceil
           checker.check_arity(func, args, 1)
           arg = checker.call(args.first)
-          return TYPES[:double] if checker.find_match_all_types(%i[double], arg)
+          TYPES[:double] if checker.find_match_all_types(%i[double], arg)
         when :isInf, :isNaN, :isFinite
           checker.check_arity(func, args, 1)
           arg = checker.call(args.first)
-          return TYPES[:bool] if checker.find_match_all_types(%i[double], arg)
+          TYPES[:bool] if checker.find_match_all_types(%i[double], arg)
         when :bitNot
           checker.check_arity(func, args, 1)
           arg = checker.call(args.first)
-          return TYPES[:int] if checker.find_match_all_types(%i[int uint], arg)
+          TYPES[:int] if checker.find_match_all_types(%i[int uint], arg)
         when :bitOr, :bitAnd, :bitXor
           checker.check_arity(func, args, 2)
           args = args.map(&checker.method(:call))
 
-          type = checker.find_match_all_types(%i[int uint], args)
-          return type if type
+          checker.find_match_all_types(%i[int uint], args)
         when :sign, :abs
           checker.check_arity(func, args, 1)
           arg = checker.call(args.first)
-          type = checker.find_match_all_types(%i[double int uint], arg)
-          return if type
+          checker.find_match_all_types(%i[double int uint], arg)
         when :least, :greatest
           checker.check_arity_any(func, args)
           args = args.map(&checker.method(:call))
 
-          return TYPES[:any] if args.all? do |arg|
+          TYPES[:any] if args.all? do |arg|
             case arg
             when TYPES[:any], TYPES[:int], TYPES[:uint], TYPES[:double],
                  TYPES[:list, :int], TYPES[:list, :uint], TYPES[:list, :double], TYPES[:list, :any]
@@ -54,13 +52,9 @@ module Cel
           checker.check_arity(func, args, 2)
           num, amount_of_bits = args.map(&checker.method(:call))
 
-          return num if checker.find_match_all_types(%i[int uint],
-                                                     num) && checker.find_match_all_types(%i[int], amount_of_bits)
-        else
-          checker.unsupported_operation(funcall)
+          num if checker.find_match_all_types(%i[int uint], num) &&
+                 checker.find_match_all_types(%i[int], amount_of_bits)
         end
-
-        checker.unsupported_operation(funcall)
       end
 
       def abs(num, program:)
@@ -143,7 +137,7 @@ module Cel
         arg = args.first
 
         case arg
-        when List
+        when Cel::List
           least(*arg.value, program: program)
         else
           arg
@@ -158,7 +152,7 @@ module Cel
         arg = args.first
 
         case arg
-        when List
+        when Cel::List
           greatest(*arg.value, program: program)
         else
           arg

data/lib/cel/extensions/string.rb

@@ -18,7 +18,7 @@ module Cel
         when :quote
           checker.check_arity(func, args, 1)
           arg = checker.call(args.first)
-          return TYPES[:string] if checker.find_match_all_types(%i[string], arg)
+          TYPES[:string] if checker.find_match_all_types(%i[string], arg)
         when :indexOf, :lastIndexOf
           if checker.call(var) == TYPES[:string]
             checker.check_arity(func, args, 2, :>=)
@@ -28,7 +28,7 @@ module Cel
               return TYPES[:int] if pos.nil?
 
               pos = checker.call(pos)
-              return TYPES[:int] if checker.find_match_all_types(%i[int], pos)
+              TYPES[:int] if checker.find_match_all_types(%i[int], pos)
 
             end
           end
@@ -41,7 +41,7 @@ module Cel
               return TYPES[:list, :string] if pos.nil?
 
               pos = checker.call(pos)
-              return TYPES[:list, :string] if checker.find_match_all_types(%i[int], pos)
+              TYPES[:list, :string] if checker.find_match_all_types(%i[int], pos)
 
             end
           end
@@ -54,36 +54,36 @@ module Cel
               return TYPES[:string] if pos.nil?
 
               pos = checker.call(pos)
-              return TYPES[:string] if checker.find_match_all_types(%i[int], pos)
+              TYPES[:string] if checker.find_match_all_types(%i[int], pos)
 
             end
           end
         when :trim, :lowerAscii, :upperAscii, :reverse
           if checker.call(var) == TYPES[:string]
             checker.check_arity(func, args, 0)
-            return TYPES[:string]
+            TYPES[:string]
           end
         when :format
           if checker.call(var) == TYPES[:string]
             checker.check_arity(func, args, 1)
             arg = checker.call(args.first)
-            return TYPES[:string] if checker.find_match_all_types(%i[list], arg)
+            TYPES[:string] if checker.find_match_all_types(%i[list], arg)
           end
         when :charAt
           if checker.call(var) == TYPES[:string]
             checker.check_arity(func, args, 1)
             arg = checker.call(args.first)
-            return TYPES[:string] if checker.find_match_all_types(%i[int], arg)
+            TYPES[:string] if checker.find_match_all_types(%i[int], arg)
           end
         when :replace
           if checker.call(var) == TYPES[:string]
             checker.check_arity(func, args, 2..3, :include?)
             p, r, limit = args.map(&checker.method(:call))
             if limit
-              return TYPES[:string] if checker.find_match_all_types(%i[string], [p, r]) &&
-                                       checker.find_match_all_types(%i[int], limit)
+              TYPES[:string] if checker.find_match_all_types(%i[string], [p, r]) &&
+                                checker.find_match_all_types(%i[int], limit)
             elsif checker.find_match_all_types(%i[string], [p, r])
-              return TYPES[:string]
+              TYPES[:string]
             end
           end
         when :join
@@ -91,12 +91,11 @@ module Cel
             checker.check_arity(func, args, 1, :>=)
             arg = checker.call(args.first)
             return TYPES[:string] unless arg
-            return TYPES[:string] if checker.find_match_all_types(%i[string], arg)
+
+            TYPES[:string] if checker.find_match_all_types(%i[string], arg)
 
           end
         end
-
-        checker.unsupported_operation(funcall)
       end
 
       def quote(str, program:)

data/lib/cel/extensions.rb

@@ -5,6 +5,7 @@ require_relative "extensions/string"
 require_relative "extensions/bind"
 require_relative "extensions/encoders"
 require_relative "extensions/network"
+require_relative "extensions/list"
 
 module Cel
   EXTENSIONS = {
@@ -14,5 +15,6 @@ module Cel
     cel: Extensions::Bind,
     net: Extensions::Network,
     ip: Extensions::Network::IP,
+    lists: Extensions::List,
   }.freeze
 end

data/lib/cel/macro.rb

@@ -2,7 +2,7 @@
 
 module Cel
   module Macro
-    module_function
+    extend self
 
     # If e evaluates to a protocol buffers version 2 message and f is a defined field:
     #     If f is a repeated field or map field, has(e.f) indicates whether the field is non-empty.
@@ -64,7 +64,10 @@ module Cel
     end
 
     def matches(string, pattern, program: nil)
-      pattern = program.evaluate(pattern) if program
+      if program
+        string = program.evaluate(string)
+        pattern = program.evaluate(pattern)
+      end
       pattern = Regexp.new(pattern)
       Bool.cast(pattern.match?(string))
     end
@@ -128,6 +131,8 @@ module Cel
       List.new(return_value)
     end
 
+    private
+
     def with_context(collection, identifiers)
       case collection
       when Map

data/lib/cel/version.rb

@@ -2,6 +2,6 @@
 
 module Cel
   module Ruby
-    VERSION = "0.6.1"
+    VERSION = "0.6.2"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cel
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.6.2
 platform: ruby
 authors:
 - Tiago Cardoso
@@ -108,6 +108,7 @@ files:
 - lib/cel/extensions.rb
 - lib/cel/extensions/bind.rb
 - lib/cel/extensions/encoders.rb
+- lib/cel/extensions/list.rb
 - lib/cel/extensions/math.rb
 - lib/cel/extensions/network.rb
 - lib/cel/extensions/string.rb
@@ -137,7 +138,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Pure Ruby implementation of Google Common Expression Language, https://opensource.google/projects/cel.
 test_files: []