cel 0.3.0 → 0.4.0

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
@@ -45,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/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)