cel 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82fcb37e45c0553a7c073b58e4c6b7203cc50bd186419724d72f5f1b0217e3f5
-  data.tar.gz: 44170fc7001634abc19860db8dcbc8c05ae8974716ad80dd28c4316dc0cec7f3
+  metadata.gz: 12cebd55174d05db4f154e185872921949f3931817503fccb5dec9f516c3128d
+  data.tar.gz: 8fa9c386f343ecfdda97ce99c37296e15378763ab0308270fdc0e789cb4c9ab0
 SHA512:
-  metadata.gz: 593ec20b7001fe593d6df79928ca8411327251fff2405491eb33642299cf6bc09d255d0088fdb6a1deda77eabccf8bcce229ad5038f68ee932f9c10ef162cdc0
-  data.tar.gz: 55eb21528a3ff994f5fc013ca49ded2b7cb0aaf9d5d434c671fc0cd534ed0119269c1e2bf8b5fe9e44ba1f1e05f51d30f5fd84abd1f44d740898dd971b341ece
+  metadata.gz: a46166c14750ef4fc245d1aca362f103d4340ddce4155c51e2f49e03ea64c5d812dccaf61ac073f9f6207995a2f8090a748fe06bf984159542385416a2e9e83a
+  data.tar.gz: cfa9d65dd070389fca1ed80817a83baee1efe193cab6830bfd0a3278051a8593a673a4de8e19c19db1a450312cad69ccb91ac49e5db2ee02d18d0efb301319c1

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 ## [Unreleased]
 
+## [0.4.0] - 2025-11-18
+
+### Features
+
+`cel-ruby` supports the defined set of [CEL extensions](https://github.com/google/cel-go/blob/master/ext/README.md): math, string, bind and encoders.
+
+```ruby
+Cel::Environment.new.evaluate("math.bitShiftLeft(1, 2) ") #=> returns 4
+```
+
+### Improvements
+
+When the `tzinfo-data` gem is loaded, expressions will support human-friendly timezones, such as "US/Central", for timestamps.
+
 ## [0.3.1] - 2025-08-01
 
 ### Improvements

data/README.md

@@ -131,11 +131,11 @@ env.evaluate("google.protobuf.Duration{seconds: 123}.seconds == 123") #=> true
 `cel-ruby` allows you to define custom functions to be used insde CEL expressions. While we **strongly** recommend usage of `Cel::Function` for defining them (due to the ability of them being used for checking), the only requirement is that the function object responds to `.call`:
 
 ```ruby
-env = environment(foo: Cel::Function(:int, :int, return_type: :int) { |a, b|  a + b})
+env = Cel::Environment.new(declarations: {foo: Cel::Function(:int, :int, return_type: :int) { |a, b|  a + b }})
 env.evaluate("foo(2, 2)") #=> 4
 
 # this is also possible, just not as type-safe
-env2 = environment(foo: -> (a, b) { a + b})
+env2 = Cel::Environment.new(declarations: {foo: ->(a, b) { a + b }})
 env2.evaluate("foo(2, 2)") #=> 4
 ```
 

data/lib/cel/ast/elements.rb

@@ -272,7 +272,7 @@ module Cel
     %i[+ -].each do |op|
       class_eval(<<-OUT, __FILE__, __LINE__ + 1)
         def #{op}@
-          raise EvaluateError, "no such overload" if @type == TYPES[:uint]
+          raise NoOverloadError if @type == TYPES[:uint]
           value = super
           Number.new(@type, value)
         end
@@ -364,6 +364,10 @@ module Cel
         end
       OUT
     end
+
+    def to_s
+      inspect
+    end
   end
 
   class Bytes < Literal
@@ -446,6 +450,10 @@ module Cel
       max
     end
 
+    def to_s
+      "[#{@value.map(&:to_s).join(", ")}]"
+    end
+
     private
 
     def calc_depth(element, acc)
@@ -633,6 +641,10 @@ module Cel
       Protobuf.timestamp_class.from_time(@value)
     end
 
+    def to_s
+      @value.utc.iso8601
+    end
+
     private
 
     def to_local_time(tz = nil)

data/lib/cel/checker.rb

@@ -21,7 +21,7 @@ module Cel
       timestamp: %i[int string timestamp],
     }.freeze
 
-    attr_reader :declarations
+    attr_reader :environment, :declarations
 
     def initialize(environment, declarations = environment.declarations)
       @environment = environment
@@ -51,6 +51,40 @@ module Cel
 
     alias_method :call, :check
 
+    def find_match_all_types(expected, types)
+      # at least an expected type must match all values
+      type = expected.find do |expected_type|
+        case types
+        when Array
+          types.all? { |typ| typ == expected_type }
+        else
+          types == expected_type
+        end
+      end
+
+      type && types.is_a?(Type) ? types : TYPES[type]
+    end
+
+    def check_arity(func, args, arity, op = :===)
+      return if arity.__send__(op, args.size)
+
+      raise CheckError, "`#{func}` invoked with wrong number of arguments (should be #{arity})"
+    end
+
+    def check_arity_any(func, args)
+      return if args.size.positive?
+
+      raise CheckError, "`#{func}` invoked with no arguments"
+    end
+
+    def unsupported_type(op)
+      raise CheckError, "no matching overload: #{op}"
+    end
+
+    def unsupported_operation(op)
+      raise CheckError, "unsupported operation (#{op})"
+    end
+
     private
 
     def merge(declarations)
@@ -194,6 +228,10 @@ module Cel
 
       return check_standard_func(funcall) unless var
 
+      if var.is_a?(Identifier) && Cel::EXTENSIONS.include?(var.to_sym)
+        return Cel::EXTENSIONS[var.to_sym].__check(funcall, checker: self)
+      end
+
       var_type ||= infer_variable_type(var)
 
       case var_type
@@ -283,6 +321,8 @@ module Cel
           var_type.element_type = element_checker.check(predicate)
           var_type
         else
+          return Cel::EXTENSIONS[:strings].__check(funcall, checker: self) if Cel::EXTENSIONS.key?(:strings)
+
           unsupported_operation(funcall)
         end
       when TYPES[:string]
@@ -295,6 +335,8 @@ module Cel
           # TODO: verify if string can be transformed into a regex
           return TYPES[:bool] if find_match_all_types(%i[string], call(args.first))
         else
+          return Cel::EXTENSIONS[:strings].__check(funcall, checker: self) if Cel::EXTENSIONS.key?(:strings)
+
           unsupported_type(funcall)
         end
         unsupported_operation(funcall)
@@ -373,7 +415,7 @@ module Cel
 
         arg = call(args.first)
 
-        return TYPES[func] if find_match_all_types(allowed_types, arg)
+        return TYPES[func] if find_match_all_types(allowed_types, arg) || arg == TYPES[:any]
       when :matches
         check_arity(func, args, 2)
         return TYPES[:bool] if find_match_all_types(%i[string], args.map(&method(:call)))
@@ -424,7 +466,9 @@ module Cel
     def check_identifier(identifier)
       return identifier.type unless identifier.type == :any
 
-      return TYPES[:type] if Cel::PRIMITIVE_TYPES.include?(identifier.to_sym)
+      id_sym = identifier.to_sym
+
+      return TYPES[:type] if Cel::PRIMITIVE_TYPES.include?(id_sym)
 
       proto_type = identifier.try_convert_to_proto_type
 
@@ -472,33 +516,5 @@ module Cel
         typ
       end
     end
-
-    def find_match_all_types(expected, types)
-      # at least an expected type must match all values
-      type = expected.find do |expected_type|
-        case types
-        when Array
-          types.all? { |typ| typ == expected_type }
-        else
-          types == expected_type
-        end
-      end
-
-      type && types.is_a?(Type) ? types : TYPES[type]
-    end
-
-    def check_arity(func, args, arity)
-      return if arity === args.size # rubocop:disable Style/CaseEquality
-
-      raise CheckError, "`#{func}` invoked with wrong number of arguments (should be #{arity})"
-    end
-
-    def unsupported_type(op)
-      raise CheckError, "no matching overload: #{op}"
-    end
-
-    def unsupported_operation(op)
-      raise CheckError, "unsupported operation (#{op})"
-    end
   end
 end

data/lib/cel/context.rb

@@ -2,7 +2,7 @@
 
 module Cel
   class Context
-    attr_reader :declarations
+    attr_reader :declarations, :bindings
 
     def initialize(declarations, bindings)
       @declarations = declarations

data/lib/cel/environment.rb

@@ -53,8 +53,8 @@ module Cel
     end
 
     def check(expr)
-      ast = @parser.parse(expr)
-      @checker.check(ast)
+      expr = @parser.parse(expr) if expr.is_a?(::String)
+      @checker.check(expr)
     end
 
     def program(expr)
@@ -91,6 +91,19 @@ module Cel
       [declarations, bindings]
     end
 
+    def with(declarations:, disable_check: @disable_check)
+      prev_declarations = @declarations
+      prev_disable_check = @disable_check
+
+      @declarations = declarations.merge(declarations)
+      @disable_check = disable_check
+
+      yield
+    ensure
+      @declarations = prev_declarations
+      @disable_check = prev_disable_check
+    end
+
     private
 
     def validate(ast, structs); end

data/lib/cel/errors.rb

@@ -48,5 +48,14 @@ module Cel
     end
   end
 
+  class NoOverloadError < EvaluateError
+    attr_reader :code
+
+    def initialize
+      super("No such overload")
+      @code = :no_overload
+    end
+  end
+
   class BindingError < EvaluateError; end
 end

data/lib/cel/extensions/bind.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Cel
+  module Extensions
+    module Bind
+      module_function
+
+      def __check(funcall, checker:)
+        func = funcall.func
+        args = funcall.args
+
+        return checker.unsupported_operation(funcall) unless func == :bind
+
+        checker.check_arity(func, args, 3)
+
+        id, type, expr = args
+
+        return checker.unsupported_operation(funcall) unless id.is_a?(Identifier)
+
+        type = checker.call(type)
+
+        checker.environment.with(declarations: { id => type }) do
+          checker.environment.check(expr)
+        end
+      end
+
+      def bind(var, val, expr, program:)
+        program.environment.with(declarations: { var.to_sym => val.type }, disable_check: false) do
+          bindings = program.context.bindings.merge({ var.to_sym => val })
+          program.environment.evaluate(expr, bindings)
+        end
+      end
+    end
+  end
+end

data/lib/cel/extensions/encoders.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Cel
+  module Extensions
+    module Encoders
+      module Base64
+        module_function
+
+        def __check(funcall, checker:)
+          func = funcall.func
+          args = funcall.args
+
+          case func
+          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)
+          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)
+          end
+
+          checker.unsupported_operation(funcall)
+        end
+
+        def encode(str, program:)
+          value = program.call(str).value
+
+          Cel::String.new([value.pack("C*")].pack("m0"))
+        end
+
+        def decode(str, program:)
+          value = program.call(str).value
+
+          Cel::Bytes.new(value.unpack1("m").unpack("C*"))
+        end
+      end
+    end
+  end
+end

data/lib/cel/extensions/math.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+module Cel
+  module Extensions
+    module Math
+      module_function
+
+      def __check(funcall, checker:)
+        func = funcall.func
+        args = funcall.args
+
+        case func
+        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)
+        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)
+        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)
+        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
+        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
+        when :least, :greatest
+          checker.check_arity_any(func, args)
+          args = args.map(&checker.method(:call))
+
+          return 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]
+              true
+            else
+              false
+            end
+          end
+        when :bitShiftRight, :bitShiftLeft
+          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)
+        end
+
+        checker.unsupported_operation(funcall)
+      end
+
+      def abs(num, program:)
+        num = program.call(num)
+
+        raise EvaluateError, "out of range" unless num.value.between?(-MAX_INT + 1, MAX_INT - 1)
+
+        Number.new(num.type, num.value.abs)
+      end
+
+      def round(num, program:)
+        num = program.call(num)
+
+        Number.new(:double, num.value.round)
+      end
+
+      def trunc(num, program:)
+        num = program.call(num)
+
+        Number.new(:double, num.value.truncate)
+      end
+
+      def floor(num, program:)
+        num = program.call(num)
+
+        Number.new(:double, num.value.floor)
+      end
+
+      def ceil(num, program:)
+        num = program.call(num)
+
+        Number.new(:double, num.value.ceil)
+      end
+
+      def bitNot(num, program:)
+        val = program.call(num).value
+
+        case num.type
+        when TYPES[:int]
+          Number.new(:int, ~val)
+        when TYPES[:uint]
+          Number.new(:uint, ((2**64) - 1) - val)
+        end
+      end
+
+      def bitOr(lhs, rhs, program:)
+        lhs = program.call(lhs)
+        rhs = program.call(rhs)
+        Number.new(lhs.type, lhs | rhs)
+      end
+
+      def bitAnd(lhs, rhs, program:)
+        lhs = program.call(lhs)
+        rhs = program.call(rhs)
+        Number.new(lhs.type, lhs & rhs)
+      end
+
+      def bitXor(lhs, rhs, program:)
+        lhs = program.call(lhs)
+        rhs = program.call(rhs)
+        Number.new(lhs.type, lhs ^ rhs)
+      end
+
+      def sign(num, program:)
+        num = program.call(num)
+        value = num.value
+
+        Number.new(num.type, if value.negative?
+          -1
+        else
+          value.positive? ? 1 : 0
+        end)
+      end
+
+      def least(*args, program:)
+        args = args.map(&program.method(:call))
+
+        return args.min if args.size > 1
+
+        arg = args.first
+
+        case arg
+        when List
+          least(*arg.value, program: program)
+        else
+          arg
+        end
+      end
+
+      def greatest(*args, program:)
+        args = args.map(&program.method(:call))
+
+        return args.max if args.size > 1
+
+        arg = args.first
+
+        case arg
+        when List
+          greatest(*arg.value, program: program)
+        else
+          arg
+        end
+      end
+
+      def bitShiftRight(num, amount_of_bits, program:)
+        num = program.call(num)
+        amount_of_bits = program.call(amount_of_bits).value
+
+        raise EvaluateError, "math.#{__method__}() negative offset: #{amount_of_bits}" if amount_of_bits.negative?
+
+        # When the second parameter is 64 or greater, 0 will always be returned
+        return Number.new(num.type, 0) if amount_of_bits >= 64
+
+        value = num.value.negative? ? ((2**64) - 1) & num.value : num.value
+
+        Number.new(num.type, value >> amount_of_bits)
+      end
+
+      def bitShiftLeft(num, amount_of_bits, program:)
+        num = program.call(num)
+        amount_of_bits = program.call(amount_of_bits).value
+
+        raise EvaluateError, "math.#{__method__}() negative offset: #{amount_of_bits}" if amount_of_bits.negative?
+
+        # When the second parameter is 64 or greater, 0 will always be returned
+        return Number.new(num.type, 0) if amount_of_bits >= 64
+
+        Number.new(num.type, num.value << amount_of_bits)
+      end
+
+      def isInf(num, program:)
+        val = program.call(num).value
+
+        Bool.cast(val.infinite?)
+      end
+
+      def isNaN(num, program:)
+        val = program.call(num).value
+
+        Bool.cast(val.nan?)
+      rescue FloatDomainError
+        Bool.cast(true)
+      end
+
+      def isFinite(num, program:)
+        val = program.call(num).value
+
+        Bool.cast(!val.infinite? && !val.nan?)
+      end
+    end
+  end
+end

data/lib/cel/extensions/string.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+module Cel
+  module Extensions
+    module String
+      module_function
+
+      def __check(funcall, checker:)
+        var = funcall.var
+        func = funcall.func
+        args = funcall.args
+
+        case func
+        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)
+        when :indexOf, :lastIndexOf
+          if checker.call(var) == TYPES[:string]
+            checker.check_arity(func, args, 2, :>=)
+            arg, pos = args
+            arg = checker.call(arg)
+            if checker.find_match_all_types(%i[string], arg)
+              return TYPES[:int] if pos.nil?
+
+              pos = checker.call(pos)
+              return TYPES[:int] if checker.find_match_all_types(%i[int], pos)
+
+            end
+          end
+        when :split
+          if checker.call(var) == TYPES[:string]
+            checker.check_arity(func, args, 2, :>=)
+            arg, pos = args
+            arg = checker.call(arg)
+            if checker.find_match_all_types(%i[string], arg)
+              return TYPES[:list, :string] if pos.nil?
+
+              pos = checker.call(pos)
+              return TYPES[:list, :string] if checker.find_match_all_types(%i[int], pos)
+
+            end
+          end
+        when :substring
+          if checker.call(var) == TYPES[:string]
+            checker.check_arity(func, args, 2, :>=)
+            arg, pos = args
+            arg = checker.call(arg)
+            if checker.find_match_all_types(%i[int], arg)
+              return TYPES[:string] if pos.nil?
+
+              pos = checker.call(pos)
+              return 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]
+          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)
+          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)
+          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)
+            elsif checker.find_match_all_types(%i[string], [p, r])
+              return TYPES[:string]
+            end
+          end
+        when :join
+          if checker.call(var) == TYPES[:list, :string] || checker.call(var) == TYPES[:list, :any]
+            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)
+
+          end
+        end
+
+        checker.unsupported_operation(funcall)
+      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
+    end
+  end
+
+  class String
+    def charAt(idx)
+      raise EvaluateError, "index out of range: #{idx}" unless idx.between?(0, @value.size)
+
+      String.new(@value[idx] || "")
+    end
+
+    def indexOf(substr, *args)
+      idx, = args
+
+      raise EvaluateError, "index out of range: #{idx}" if idx && !idx.between?(0, @value.size)
+
+      Number.new(:int, @value.index(substr, *args) || -1)
+    end
+
+    def lastIndexOf(substr, *args)
+      idx, = args
+
+      raise EvaluateError, "index out of range: #{idx}" if idx && !idx.between?(0, @value.size)
+
+      Number.new(:int, @value.rindex(substr, *args) || -1)
+    end
+
+    def lowerAscii
+      String.new(@value.downcase(:ascii))
+    end
+
+    def upperAscii
+      String.new(@value.upcase(:ascii))
+    end
+
+    UNICODE_WHITESPACE = /[ \t\r\n\u000C\u000D\u0020\u0085\u00A0\u1680\u2000-\u200A\u2028-\u2029\u202F\u205F\u3000]+/
+
+    def trim
+      # why this? because String#split only takes null, horizontal tab, line feed, vertical tab, form feed,
+      # carriage return, space into account. We need the unicode definition of whitespace.
+      value = @value.gsub(/\A#{UNICODE_WHITESPACE}/o, "")
+                    .gsub(/#{UNICODE_WHITESPACE}\z/o, "")
+
+      String.new(value.strip)
+    end
+
+    def reverse
+      String.new(@value.reverse)
+    end
+
+    def split(pattern, *args)
+      raise NoOverloadError unless pattern.is_a?(String) && args.size.between?(0, 1)
+
+      limit, = args
+
+      raise NoOverloadError if limit && !limit.is_a?(Number)
+
+      return List.new([]) if limit && limit.zero?
+
+      List.new(@value.split(pattern, *args))
+    end
+
+    def substring(*args)
+      raise NoOverloadError unless args.size.between?(1, 2)
+
+      start_idx, end_idx = *args
+      end_idx ||= @value.size
+
+      raise EvaluateError, "index out of range: #{start_idx}" unless start_idx.between?(0, @value.size)
+
+      raise EvaluateError, "index out of range: #{end_idx}" if end_idx >= @value.size + 1
+
+      raise EvaluateError, "end index can't be higher than start index" if end_idx < start_idx
+
+      String.new(@value[start_idx..(end_idx - 1)])
+    end
+
+    def replace(pattern, replacement, *args)
+      raise NoOverloadError unless args.size.between?(0, 1)
+
+      limit, = args
+
+      raise NoOverloadError unless pattern.is_a?(String) && replacement.is_a?(String)
+
+      pattern = pattern.value
+      replacement = replacement.value
+
+      value = if limit
+        raise NoOverloadError unless limit.is_a?(Number)
+
+        @value.gsub(pattern) do |m|
+          if limit.zero?
+            m
+          else
+            limit -= 1
+            replacement
+          end
+        end
+      else
+        @value.gsub(pattern, replacement)
+      end
+
+      String.new(value)
+    end
+
+    def format(mappings)
+      String.new(format(@value, *mappings))
+    end
+  end
+
+  class List
+    def join(*)
+      String.new(super)
+    end
+  end
+end

data/lib/cel/extensions.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "cel/extensions/math"
+require "cel/extensions/string"
+require "cel/extensions/bind"
+require "cel/extensions/encoders"
+
+module Cel
+  EXTENSIONS = {
+    math: Extensions::Math,
+    strings: Extensions::String,
+    base64: Extensions::Encoders::Base64,
+    cel: Extensions::Bind,
+  }.freeze
+end

data/lib/cel/parser.rb

@@ -404,9 +404,9 @@ def math_operation(op, operands)
       when  "*", "/", "%"
         depth = lhs.depth + 1
       end
-    when "+", "+"
+    when "+"
       case lhs.op
-      when  "+", "+"
+      when  "+"
         depth = lhs.depth + 1
       end
     end

data/lib/cel/program.rb

@@ -2,7 +2,7 @@
 
 module Cel
   class Program
-    attr_reader :context
+    attr_reader :environment, :context
 
     def initialize(context, environment)
       @context = context
@@ -55,7 +55,11 @@ module Cel
     end
 
     def evaluate_identifier(identifier)
-      if Cel::PRIMITIVE_TYPES.include?(identifier.to_sym)
+      id_sym = identifier.to_sym
+
+      if Cel::EXTENSIONS.key?(id_sym)
+        Cel::EXTENSIONS[id_sym]
+      elsif Cel::PRIMITIVE_TYPES.include?(id_sym)
         TYPES[identifier.to_sym]
       else
         val, func = @context.lookup(identifier)
@@ -283,8 +287,10 @@ module Cel
         value = Protobuf.lookup(var, func)
 
         Literal.to_cel_type(value)
-      else
-        if var.is_a?(Module) && var.const_defined?(func)
+      when Module
+        if var.respond_to?(func) && !Module.respond_to?(func)
+          return var.__send__(func, *args, program: self)
+        elsif var.const_defined?(func) && !Module.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
@@ -313,6 +319,8 @@ module Cel
           return Literal.to_cel_type(value)
         end
 
+        raise EvaluateError, "#{invoke} is not supported"
+      else
         raise EvaluateError, "#{invoke} is not supported"
       end
     end

data/lib/cel/version.rb

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

data/lib/cel.rb

@@ -5,6 +5,7 @@ require "cel/version"
 require "cel/errors"
 require "cel/ast/types"
 require "cel/ast/elements"
+require "cel/extensions"
 require "cel/parser"
 require "cel/macro"
 require "cel/context"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cel
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Tiago Cardoso
@@ -51,6 +51,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: tzinfo-data
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Pure Ruby implementation of Google Common Expression Language, https://opensource.google/projects/cel.
 email:
 - cardoso_tiago@hotmail.com
@@ -73,6 +87,11 @@ files:
 - lib/cel/encoder.rb
 - lib/cel/environment.rb
 - lib/cel/errors.rb
+- lib/cel/extensions.rb
+- lib/cel/extensions/bind.rb
+- lib/cel/extensions/encoders.rb
+- lib/cel/extensions/math.rb
+- lib/cel/extensions/string.rb
 - lib/cel/macro.rb
 - lib/cel/parser.rb
 - lib/cel/program.rb
@@ -99,7 +118,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Pure Ruby implementation of Google Common Expression Language, https://opensource.google/projects/cel.
 test_files: []