cel 0.3.1 → 0.4.1

data/lib/cel/ast/types.rb

@@ -2,12 +2,18 @@
 
 module Cel
   class Type
+    include CelMethods
+
     def initialize(type)
       @type = type
     end
 
-    def ==(other)
-      (other.is_a?(Symbol) && other == @type) || super
+    define_cel_method(:==) do |other|
+      (other.is_a?(Symbol) && other == @type) || super(other)
+    end
+
+    define_cel_method(:"!=") do |other|
+      !cel_send(:==, other)
     end
 
     def to_str
@@ -154,6 +160,29 @@ module Cel
         raise Error, "unsupported cast operation to #{@type}"
       end
     end
+
+    def convert(primitive_value)
+      case @type
+      when :int, :uint, :double
+        Number.new(@type, primitive_value)
+      when :string
+        String.new(primitive_value)
+      when :bytes
+        Bytes.new(primitive_value)
+      when :bool
+        Bool.new(primitive_value)
+      when :null_type
+        Null::INSTANCE
+      when :timestamp
+        Timestamp.new(primitive_value)
+      when :duration
+        Duration.new(primitive_value)
+      when :any
+        Literal.to_cel_type(primitive_value)
+      else
+        raise EvaluateError, "Type conversion error"
+      end
+    end
   end
 
   class ListType < Type
@@ -176,7 +205,11 @@ module Cel
     end
 
     def cast(value)
-      value.is_a?(List) ? value : List.new(value)
+      value.is_a?(List) ? value : convert(value)
+    end
+
+    def convert(primitive_value)
+      List.new(primitive_value)
     end
   end
 
@@ -203,15 +236,27 @@ module Cel
     end
 
     def cast(value)
-      value.is_a?(Map) ? value : Map.new(value)
+      value.is_a?(Map) ? value : convert(value)
+    end
+
+    def convert(primitive_value)
+      Map.new(primitive_value)
     end
   end
 
   class AbstractType < Type
+    attr_reader :params
+    protected :params
     def initialize(name, *params)
       super(name)
       @params = params
     end
+
+    define_cel_method(:==) do |other|
+      return super(other) unless other.is_a?(AbstractType)
+
+      other.type && @type && other.params == @params
+    end
   end
   # Primitive Cel Types
 

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

@@ -3,6 +3,8 @@
 module Cel
   class Error < StandardError; end
 
+  class NoCelMethodError < Error; end
+
   class ParseError < Error; end
 
   class MaxRecursionDepthExceededError < ParseError; end
@@ -48,5 +50,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