cel 0.4.0 → 0.4.1

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

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Cel
+  class Map < Literal
+    ALLOWED_TYPES = %i[int uint bool string].map { |typ| TYPES[typ] }.freeze
+
+    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)
+      @depth = depth
+    end
+
+    def ==(other)
+      case other
+      when Map
+        @value.all? do |args|
+          other.value.include?(args)
+        end
+      when Array
+        # calls to != will downgrade maps to arrays
+        @value.all? do |args|
+          other.include?(args)
+        end
+      else
+        super
+      end
+    end
+
+    (LOGICAL_OPERATORS - %w[== != in]).each do |op|
+      @cel_methods.delete(op.to_sym)
+
+      class_eval(<<-OUT, __FILE__, __LINE__ + 1)
+        def #{op}(*)
+          raise NoMethodError
+        end
+      OUT
+    end
+
+    def key?(key)
+      ukey =
+        case key
+        when Symbol
+          key.to_s
+        when String
+          key.delete_prefix('"').delete_suffix('"')
+        else
+          key
+        end
+
+      @value.any? do |k, _v|
+        k == ukey
+      end
+    end
+
+    alias_method :include?, :key?
+
+    define_cel_method(:[]) do |key|
+      ukey =
+        case key
+        when Symbol
+          key.to_s
+        when String
+          key.delete_prefix('"').delete_suffix('"')
+        else
+          key
+        end
+
+      values = @value.filter_map do |k, v|
+        v if k == ukey
+      end
+
+      raise NoSuchKeyError.new(self, key) if values.empty?
+
+      raise EvaluateError, "Failed with repeated key" if values.size > 1
+
+      values.first
+    end
+
+    def to_ruby_type
+      value.to_h { |args| args.map(&:to_ruby_type) }
+    end
+
+    def respond_to_missing?(meth, *args)
+      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
+
+      meth_s = meth.to_s
+      values = @value.filter_map { |k, v| v if k == meth_s }
+
+      return super if values.empty?
+
+      values.first
+    end
+
+    private
+
+    # For a map, the entry keys are sub-expressions that must evaluate to values
+    # of an allowed type (int, uint, bool, or string)
+    def check
+      return if @value.all? do |key, _|
+        key.is_a?(Identifier) || ALLOWED_TYPES.include?(key.type)
+      end
+
+      raise CheckError, "#{self} is invalid (keys must be of an allowed type (int, uint, bool, or string)"
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Cel
+  class Message
+    EMPTY_STRUCT = {}.freeze
+
+    attr_reader :name, :struct, :package, :depth
+
+    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
+      @type ||= if proto_type
+        Protobuf.convert_to_cel_type(proto_type, @package) || proto_type
+      else
+        Protobuf.try_convert_from_wrapper_type(@name.to_s)
+      end
+    end
+
+    def message_type
+      @message_type ||= proto_type || container
+    end
+
+    def proto_type
+      @proto_type ||= Protobuf.convert_to_proto_type(@name.to_s, @package)
+    end
+
+    def ==(other)
+      other.is_a?(Cel::Message) && other.name == @name && other.struct == @struct
+    end
+
+    def to_s
+      if proto_type
+        proto_type.descriptor.name
+      else
+        message_type.to_s
+      end
+    end
+
+    private
+
+    def container
+      @container ||= Cel.message_container(@name, @struct)
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Cel
+  class Null < Literal
+    def initialize
+      super(:null_type, nil)
+    end
+
+    INSTANCE = new.freeze
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Cel
+  class Number < Literal
+    def ==(other)
+      case other
+      when Number
+        @value == other.value
+      else
+        super
+      end
+    end
+
+    ([:+, :-, *(MULTI_OPERATORS - %w[%])] - %i[%]).each do |op|
+      class_eval(<<-OUT, __FILE__, __LINE__ + 1)
+        define_cel_method(:#{op}) do |other|
+          value = super(other)
+          check_overflow(value)
+          Number.new(@type, value)
+        end
+      OUT
+    end
+
+    (LOGICAL_OPERATORS - %w[== != in]).each do |op|
+      class_eval(<<-OUT, __FILE__, __LINE__ + 1)
+        define_cel_method(:#{op}) do |other|
+          super(other)
+        end
+      OUT
+    end
+
+    define_cel_method(:%) do |other|
+      raise EvaluateError, "no matching overload" if @type == :double && other.type == :double
+
+      value = if negative?
+        if other.negative?
+          -(abs % other.abs)
+        else
+          -(abs % other)
+        end
+      else
+        @value % other.abs
+      end
+      check_overflow(value)
+      Number.new(@type, value)
+    end
+
+    %i[+ -].each do |op|
+      class_eval(<<-OUT, __FILE__, __LINE__ + 1)
+        def #{op}@
+          raise NoOverloadError if @type == TYPES[:uint]
+          value = super
+          Number.new(@type, value)
+        end
+      OUT
+    end
+
+    def check_overflow(value = @value)
+      case @type
+      when TYPES[:double]
+        return if value.nan? || value.infinite?
+        raise EvaluateError, "return error for overflow" unless (-(MAX_FLOAT - 1)...MAX_FLOAT).cover?(value)
+      when TYPES[:uint]
+        raise EvaluateError, "return error for overflow" unless (0...MAX_INT).cover?(value)
+      else
+        raise EvaluateError, "return error for overflow" unless (-(MAX_INT - 1)...MAX_INT).cover?(value)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Cel
+  class Operation
+    attr_reader :op, :operands, :depth
+
+    attr_accessor :type
+
+    def initialize(op, operands, depth: 1)
+      @op = op
+      @operands = operands
+      @type = TYPES[:any]
+      @depth = depth
+    end
+
+    def ==(other)
+      case other
+      when Array
+        other.size == @operands.size + 1 &&
+          other.first == @op &&
+          other.slice(1..-1).zip(@operands).all? { |x1, x2| x1 == x2 }
+      when Operation
+        @op == other.op && @type == other.type && @operands == other.operands
+      else
+        super
+      end
+    end
+
+    def unary?
+      @operands.size == 1
+    end
+
+    def to_s
+      return "#{@op}#{@operands.first}" if @operands.size == 1
+
+      @operands.join(" #{@op} ")
+    end
+  end
+end

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

@@ -400,6 +400,10 @@ module Cel
     end
 
     module CelComparisonMode
+      # TODO: this does not isolate the scope of methods callable under cel.
+      # we'll need a different version of the CelMethods mixin for this.
+      alias_method :cel_send, :public_send
+
       def ==(other)
         super || begin
           return false unless other.is_a?(Protobuf.base_class)

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Cel
+  class String < Literal
+    def initialize(value)
+      super(:string, value)
+    end
+
+    # override base String#%
+    @cel_methods.delete(:%)
+
+    def %(_other)
+      raise NoMethodError, "undefined method '%' for #{self}"
+    end
+
+    (LOGICAL_OPERATORS - %w[== != in]).each do |op|
+      class_eval(<<-OUT, __FILE__, __LINE__ + 1)
+        define_cel_method(:#{op}) do |other|
+          super(other)
+        end
+      OUT
+    end
+
+    # CEL string functions
+
+    define_cel_method(:contains) do |string|
+      Bool.cast(@value.include?(string))
+    end
+
+    define_cel_method(:endsWith) do |string|
+      Bool.cast(@value.end_with?(string))
+    end
+
+    define_cel_method(:startsWith) do |string|
+      Bool.cast(@value.start_with?(string))
+    end
+
+    define_cel_method(:matches) do |pattern|
+      Macro.matches(self, pattern)
+    end
+
+    %i[+ -].each do |op|
+      class_eval(<<-OUT, __FILE__, __LINE__ + 1)
+        define_cel_method(:#{op}) do |other|
+          String.new(super(other))
+        end
+      OUT
+    end
+
+    def to_s
+      inspect
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Cel
+  class Timestamp < Literal
+    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 Numeric then Time.at(value)
+              else value
+      end
+
+      raise EvaluateError, "out of range" unless TIMESTAMP_RANGE.include?(value)
+
+      super(:timestamp, value.round(9))
+    end
+
+    define_cel_method(:+) do |other|
+      Timestamp.new(@value + other.to_f)
+    end
+
+    define_cel_method(:-) do |other|
+      case other
+      when Timestamp
+        Duration.new(@value - other.value)
+      when Duration
+        Timestamp.new(@value - other.to_f)
+      end
+    end
+
+    LOGICAL_OPERATORS.each do |op|
+      class_eval(<<-OUT, __FILE__, __LINE__ + 1)
+        define_cel_method(:#{op}) do |other|
+          val = super(other)
+          other.is_a?(Cel::Literal) ? Bool.cast(val) : val
+        end
+      OUT
+    end
+
+    # Cel Functions
+
+    define_cel_method(:getDate) do |tz = nil|
+      Number.new(:int, to_local_time(tz).day)
+    end
+
+    define_cel_method(:getDayOfMonth) do |tz = nil|
+      getDate(tz) - 1
+    end
+
+    define_cel_method(:getDayOfWeek) do |tz = nil|
+      Number.new(:int, to_local_time(tz).wday)
+    end
+
+    define_cel_method(:getDayOfYear) do |tz = nil|
+      Number.new(:int, to_local_time(tz).yday - 1)
+    end
+
+    define_cel_method(:getMonth) do |tz = nil|
+      Number.new(:int, to_local_time(tz).month - 1)
+    end
+
+    define_cel_method(:getFullYear) do |tz = nil|
+      Number.new(:int, to_local_time(tz).year)
+    end
+
+    define_cel_method(:getHours) do |tz = nil|
+      Number.new(:int, to_local_time(tz).hour)
+    end
+
+    define_cel_method(:getMinutes) do |tz = nil|
+      Number.new(:int, to_local_time(tz).min)
+    end
+
+    define_cel_method(:getSeconds) do |tz = nil|
+      Number.new(:int, to_local_time(tz).sec)
+    end
+
+    define_cel_method(:getMilliseconds) do |tz = nil|
+      Number.new(:int, to_local_time(tz).nsec / 1_000_000)
+    end
+
+    def to_ruby_type
+      Protobuf.timestamp_class.from_time(@value)
+    end
+
+    def to_s
+      @value.utc.iso8601
+    end
+
+    private
+
+    def to_local_time(tz = nil)
+      time = @value
+      if tz
+        tz = tz.value
+        if tz.match?(/\A[+-]?\d{2,}:\d{2,}\z/)
+          tz.prepend("+") unless tz.start_with?("+", "-")
+        else
+          tz = TZInfo::Timezone.get(tz)
+        end
+        time = time.getlocal(tz)
+      end
+      time
+    end
+  end
+end