cel 0.2.3 → 0.3.1

data/lib/cel/ast/elements.rb

@@ -4,18 +4,6 @@ require "time"
 require "delegate"
 
 module Cel
-  begin
-    require_relative "elements/protobuf"
-  rescue LoadError
-    module Protobuf
-      module_function
-
-      def method_missing(*) # rubocop:disable Style/MissingRespondToMissing
-        raise Error, "\"google/protobuf\" is required in order to use this feature"
-      end
-    end
-  end
-
   LOGICAL_OPERATORS = %w[<= >= < > == != in].freeze
   MULTI_OPERATORS = %w[* / %].freeze
 
@@ -24,9 +12,10 @@ module Cel
 
     attr_accessor :type
 
-    def initialize(identifier)
+    def initialize(identifier, package = nil)
       @id = identifier
       @type = TYPES[:any]
+      @package = package
       super(@id)
     end
 
@@ -37,59 +26,80 @@ module Cel
     def to_s
       @id.to_s
     end
+
+    alias_method :to_ruby_type, :to_s
+
+    def try_convert_to_proto_type
+      Protobuf.convert_to_proto_type(@id.to_s, @package)
+    end
   end
 
-  class Message < SimpleDelegator
-    attr_reader :type, :struct
+  class Message
+    EMPTY_STRUCT = {}.freeze
 
-    def self.new(type, struct)
-      value = convert_from_type(type, struct)
-      return value if value.is_a?(Null) || value != struct
+    attr_reader :name, :struct, :package, :depth
 
-      super
+    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 initialize(type, struct)
-      @struct = Struct.new(*struct.keys.map(&:to_sym)).new(*struct.values)
-      @type = type.is_a?(Type) ? type : MapType.new(struct.to_h do |k, v|
-                                                      [Literal.to_cel_type(k), Literal.to_cel_type(v)]
-                                                    end)
-      super(@struct)
+    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 field?(key)
-      !@type.get(key).nil?
+    def message_type
+      @message_type ||= proto_type || container
     end
 
-    def self.convert_from_type(type, value)
-      case type
-      when Invoke, Identifier
-        spread_type = type.to_s
-        Protobuf.convert_from_type(spread_type, value)
-      when Type
-        [type, value]
+    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
-        [
-          MapType.new(struct.to_h do |k, v|
-            [Literal.to_cel_type(k), Literal.to_cel_type(v)]
-          end),
-          Struct.new(*struct.keys.map(&:to_sym)).new(*struct.values),
-        ]
+        message_type.to_s
       end
     end
+
+    private
+
+    def container
+      @container ||= Cel.message_container(@name, @struct)
+    end
   end
 
   class Invoke
-    attr_reader :var, :func, :args
+    attr_accessor :var
+
+    attr_reader :func, :args, :depth
 
-    def self.new(func:, var: nil, args: nil)
+    def self.new(func:, var: nil, args: nil, **rest)
       Protobuf.try_invoke_from(var, func, args) || super
     end
 
-    def initialize(func:, var: nil, args: nil)
+    def type
+      TYPES[:any]
+    end
+
+    def initialize(func:, var: nil, args: nil, depth: 1, package: nil)
       @var = var
       @func = func.to_sym
       @args = args
+      @package = package
+      @depth = depth
     end
 
     def ==(other)
@@ -105,7 +115,7 @@ module Cel
 
     def to_s
       if var
-        if func == :[]
+        if indexing?
           "#{var}[#{args}]"
         else
           "#{var}.#{func}#{"(#{args.map(&:to_s).join(", ")})" if args}"
@@ -114,12 +124,28 @@ module Cel
         "#{func}#{"(#{args.map(&:to_s).join(", ")})" if args}"
       end
     end
+
+    def try_convert_to_proto_type
+      return unless @var
+
+      proto_type = Protobuf.convert_to_proto_type(@var.to_s, @package)
+
+      return unless proto_type
+
+      return proto_type unless proto_type.const_defined?(@func)
+
+      proto_type.const_get(@func)
+    end
+
+    def indexing?
+      @func == :[]
+    end
   end
 
   class Function
-    attr_reader :types, :type
+    attr_reader :label, :types, :type
 
-    def initialize(*types, return_type: nil, &func)
+    def initialize(*types, label: nil, return_type: nil, &func)
       unless func.nil?
         types = Array.new(func.arity) { TYPES[:any] } if types.empty?
         raise(Error, "number of arg types does not match number of yielded args") unless types.size == func.arity
@@ -131,6 +157,7 @@ module Cel
         return_type.is_a?(Type) ? return_type : TYPES[return_type]
       end
       @func = func
+      @label = label
     end
 
     def call(*args)
@@ -154,17 +181,28 @@ module Cel
     end
 
     def ==(other)
-      other = other.value if other.is_a?(Literal)
-      @value == other || super
+      case other
+      when Literal
+        @type == other.type && @value == other.value
+      else
+        @value == other
+      end
     end
 
     def self.to_cel_type(val)
-      val = Protobuf.convert_from_protobuf(val) if val.is_a?(Google::Protobuf::MessageExts)
+      if val.is_a?(Protobuf.base_class) ||
+         val.is_a?(Struct) # no-protobuf mode
+        val = Protobuf.try_convert_from_wrapper(val)
+
+        return val if val.is_a?(Protobuf.base_class) # still
+      end
 
       case val
-      when Literal, Identifier
+      when Literal, Identifier, Invoke, Operation, Condition, Group, # already cel
+          Protobuf.enum_class # already a usable class a la protobuf
         val
-        # TODO: should support byte streams?
+      when Protobuf.map_class
+        Map.new(val.to_h)
       when ::String
         String.new(val)
       when ::Symbol
@@ -178,9 +216,9 @@ module Cel
       when ::Array
         List.new(val)
       when true, false
-        Bool.new(val)
+        Bool.cast(val)
       when nil
-        Null.new
+        Null::INSTANCE
       when Time
         Timestamp.new(val)
       else
@@ -188,9 +226,7 @@ module Cel
       end
     end
 
-    def to_ruby_type
-      @value
-    end
+    alias_method :to_ruby_type, :value
 
     private
 
@@ -198,21 +234,62 @@ module Cel
   end
 
   class Number < Literal
-    [:+, :-, *MULTI_OPERATORS].each do |op|
+    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)
         def #{op}(other)
-          Number.new(@type, super)
+          value = super
+          check_overflow(value)
+          Number.new(@type, value)
         end
       OUT
     end
 
-    (LOGICAL_OPERATORS - %w[==]).each do |op|
+    def %(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}(other)
-          Bool.new(super)
+        def #{op}@
+          raise EvaluateError, "no such overload" 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
 
   class Bool < Literal
@@ -220,16 +297,27 @@ module Cel
       super(:bool, value)
     end
 
-    (LOGICAL_OPERATORS - %w[==]).each do |op|
+    (LOGICAL_OPERATORS - %w[== != in]).each do |op|
       class_eval(<<-OUT, __FILE__, __LINE__ + 1)
         def #{op}(other)
-          Bool.new(super)
+          return super unless other.is_a?(Bool)
+
+          lhs = @value ? 1 : 0
+          rhs = other.value ? 1 : 0
+          lhs.__send__(__method__, rhs)
         end
       OUT
     end
 
     def !
-      Bool.new(super)
+      Bool.cast(super)
+    end
+
+    TRUE_VALUE = new(true)
+    FALSE_VALUE = new(false)
+
+    def self.cast(val)
+      val ? TRUE_VALUE : FALSE_VALUE
     end
   end
 
@@ -237,6 +325,8 @@ module Cel
     def initialize
       super(:null_type, nil)
     end
+
+    INSTANCE = new.freeze
   end
 
   class String < Literal
@@ -244,18 +334,23 @@ module Cel
       super(:string, value)
     end
 
+    # override base String#%
+    def %(_other)
+      raise NoMethodError, "undefined method '%' for #{self}"
+    end
+
     # CEL string functions
 
     def contains(string)
-      Bool.new(@value.include?(string))
+      Bool.cast(@value.include?(string))
     end
 
     def endsWith(string)
-      Bool.new(@value.end_with?(string))
+      Bool.cast(@value.end_with?(string))
     end
 
     def startsWith(string)
-      Bool.new(@value.start_with?(string))
+      Bool.cast(@value.start_with?(string))
     end
 
     def matches(pattern)
@@ -272,18 +367,23 @@ module Cel
   end
 
   class Bytes < Literal
+    attr_reader :string
+
     def initialize(value)
       super(:bytes, value)
+      @string = value.pack("C*")
     end
 
     def to_ary
       [self]
     end
 
+    alias_method :to_ruby_type, :string
+
     (LOGICAL_OPERATORS - %w[==]).each do |op|
       class_eval(<<-OUT, __FILE__, __LINE__ + 1)
         def #{op}(other)
-          Bool.new(super)
+          other.is_a?(Cel::Bytes) ? Bool.cast(@string.__send__(__method__, other.string)) : super
         end
       OUT
     end
@@ -291,18 +391,34 @@ module Cel
     %i[+ -].each do |op|
       class_eval(<<-OUT, __FILE__, __LINE__ + 1)
         def #{op}(other)
-          String.new(@type, super)
+          Bytes.new(@value + other.value)
         end
       OUT
     end
   end
 
   class List < Literal
-    def initialize(value)
+    attr_reader :depth
+
+    def initialize(value, depth: 1)
       value = value.map do |v|
         Literal.to_cel_type(v)
       end
-      super(ListType.new(value), value)
+      super(TYPES[:list], value)
+      @depth = depth
+    end
+
+    def [](key)
+      case key
+      when Number
+        if key.type == :double
+          val = key.value
+
+          raise InvalidArgumentError, key unless (val % 1).zero?
+        end
+      end
+
+      super
     end
 
     def to_ary
@@ -312,65 +428,142 @@ module Cel
     def to_ruby_type
       value.map(&:to_ruby_type)
     end
+
+    %i[+ -].each do |op|
+      class_eval(<<-OUT, __FILE__, __LINE__ + 1)
+        def #{op}(other)
+          List.new(@value.send(__method__, other.value))
+        end
+      OUT
+    end
+
+    def by_max_depth
+      max = @value.max { |a1, a2| calc_depth(a1, 0) <=> calc_depth(a2, 0) }
+
+      # return the last value if all options have the same depth
+      return @value.last if (max == @value.first) && (calc_depth(max, 0) == calc_depth(@value.last, 0))
+
+      max
+    end
+
+    private
+
+    def calc_depth(element, acc)
+      case element
+      when List
+        element.value.map { |el| calc_depth(el, acc + 1) }.max || (acc + 1)
+      when Map
+        element.value.map { |(_, el)| calc_depth(el, acc + 1) }.max || (acc + 1)
+      else
+        acc
+      end
+    end
   end
 
   class Map < Literal
-    def initialize(value)
-      value = value.to_h do |k, v|
+    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(MapType.new(value), value)
-      check
+      super(TYPES[:map], value)
+      @depth = depth
     end
 
     def ==(other)
-      super || (
-        other.respond_to?(:to_hash) &&
-        @value.zip(other).all? { |(x1, y1), (x2, y2)| x1 == x2 && y1 == y2 }
-      )
+      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
 
-    def to_ary
-      [self]
+    (LOGICAL_OPERATORS - %w[== != in]).each do |op|
+      class_eval(<<-OUT, __FILE__, __LINE__ + 1)
+        def #{op}(*)
+          raise NoMethodError
+        end
+      OUT
+    end
+
+    def key?(key)
+      @value.any? { |k, _v| k == key }
+    end
+
+    alias_method :include?, :key?
+
+    def [](key)
+      values = @value.filter_map { |k, v| v if k == key }
+
+      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) }
+      value.to_h { |args| args.map(&:to_ruby_type) }
     end
 
     def respond_to_missing?(meth, *args)
-      super || (@value && @value.keys.any? { |k| k.to_s == meth.to_s })
+      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
 
-      key = @value.keys.find { |k| k.to_s == meth.to_s } or return super
+      meth_s = meth.to_s
+      values = @value.filter_map { |k, v| v if k == meth_s }
+
+      return super if values.empty?
 
-      @value[key]
+      values.first
     end
 
     private
 
-    ALLOWED_TYPES = %i[int uint bool string].map { |typ| TYPES[typ] }.freeze
-
     # 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.each_key.all? { |key| key.is_a?(Identifier) || ALLOWED_TYPES.include?(key.type) }
+      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
 
   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
-      super(:timestamp, value)
+
+      raise EvaluateError, "out of range" unless TIMESTAMP_RANGE.include?(value)
+
+      super(:timestamp, value.round(9))
     end
 
     def +(other)
@@ -389,7 +582,7 @@ module Cel
     LOGICAL_OPERATORS.each do |op|
       class_eval(<<-OUT, __FILE__, __LINE__ + 1)
         def #{op}(other)
-          other.is_a?(Cel::Literal) ? Bool.new(super) : super
+          other.is_a?(Cel::Literal) ? Bool.cast(super) : super
         end
       OUT
     end
@@ -397,7 +590,7 @@ module Cel
     # Cel Functions
 
     def getDate(tz = nil)
-      to_local_time(tz).day
+      Number.new(:int, to_local_time(tz).day)
     end
 
     def getDayOfMonth(tz = nil)
@@ -405,35 +598,39 @@ module Cel
     end
 
     def getDayOfWeek(tz = nil)
-      to_local_time(tz).wday
+      Number.new(:int, to_local_time(tz).wday)
     end
 
     def getDayOfYear(tz = nil)
-      to_local_time(tz).yday - 1
+      Number.new(:int, to_local_time(tz).yday - 1)
     end
 
     def getMonth(tz = nil)
-      to_local_time(tz).month - 1
+      Number.new(:int, to_local_time(tz).month - 1)
     end
 
     def getFullYear(tz = nil)
-      to_local_time(tz).year
+      Number.new(:int, to_local_time(tz).year)
     end
 
     def getHours(tz = nil)
-      to_local_time(tz).hour
+      Number.new(:int, to_local_time(tz).hour)
     end
 
     def getMinutes(tz = nil)
-      to_local_time(tz).min
+      Number.new(:int, to_local_time(tz).min)
     end
 
     def getSeconds(tz = nil)
-      to_local_time(tz).sec
+      Number.new(:int, to_local_time(tz).sec)
     end
 
     def getMilliseconds(tz = nil)
-      to_local_time(tz).nsec / 1_000_000
+      Number.new(:int, to_local_time(tz).nsec / 1_000_000)
+    end
+
+    def to_ruby_type
+      Protobuf.timestamp_class.from_time(@value)
     end
 
     private
@@ -441,7 +638,12 @@ module Cel
     def to_local_time(tz = nil)
       time = @value
       if tz
-        tz = TZInfo::Timezone.get(tz) unless tz.match?(/\A[+-]\d{2,}:\d{2,}\z/)
+        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
@@ -450,26 +652,54 @@ module Cel
 
   class Duration < Literal
     def initialize(value)
-      value = case value
-              when ::String
-                init_from_string(value)
-              when Hash
-                seconds, nanos = value.values_at(:seconds, :nanos)
-                seconds ||= 0
-                nanos ||= 0
-                seconds + (nanos / 1_000_000_000.0)
-              else
-                value
-      end
+      value =
+        case value
+        when ::String
+          init_from_string(value)
+        when Hash
+          seconds, nanos = value.values_at(:seconds, :nanos)
+          seconds ||= 0
+          nanos ||= 0
+          seconds + (nanos / 1_000_000_000.0)
+        else
+          value
+        end
+
+      raise EvaluateError, "out of range" unless (value * 1_000_000_000).between?(-MAX_INT, MAX_INT)
+
       super(:duration, value)
     end
 
+    def to_s
+      seconds = getSeconds
+      millis = getMilliseconds
+      millis.positive? ? "#{seconds}s#{millis}m" : "#{seconds}s"
+    end
+
+    def +(other)
+      case other
+      when Cel::Duration
+        Cel::Duration.new(@value + other.value)
+      when Cel::Timestamp
+        Cel::Timestamp.new(other.value + @value)
+      end
+    end
+
+    def -(other)
+      case other
+      when Cel::Duration
+        Cel::Duration.new(@value - other.value)
+      else
+        raise Error, "invalid operand #{other} for `-`"
+      end
+    end
+
     LOGICAL_OPERATORS.each do |op|
       class_eval(<<-OUT, __FILE__, __LINE__ + 1)
         def #{op}(other)
           case other
           when Cel::Literal
-            Bool.new(super)
+            Bool.cast(super)
           when Numeric
             @value == other
 
@@ -483,19 +713,23 @@ module Cel
     # Cel Functions
 
     def getHours
-      (getMinutes / 60).to_i
+      Cel::Number.new(:int, (getMinutes / 60).to_i)
     end
 
     def getMinutes
-      (getSeconds / 60).to_i
+      Cel::Number.new(:int, (getSeconds / 60).to_i)
     end
 
     def getSeconds
-      @value.divmod(1).first
+      Cel::Number.new(:int, @value.divmod(1).first)
     end
 
     def getMilliseconds
-      (@value.divmod(1).last * 1000).round
+      Cel::Number.new(:int, (@value.divmod(1).last * 1000).round)
+    end
+
+    def to_ruby_type
+      Protobuf.duration_class.new(seconds: getSeconds.value, nanos: getMilliseconds.value * 1_000_000_000.0)
     end
 
     private
@@ -521,7 +755,9 @@ module Cel
           raise EvaluateError, "#{units} is unsupported"
         end
       end
-      seconds + (nanos / 1_000_000_000.0)
+      duration = seconds + (nanos / 1_000_000_000.0)
+      duration = -duration if value.start_with?("-")
+      duration
     end
   end
 
@@ -532,20 +768,25 @@ module Cel
       @value = value
     end
 
+    def type
+      TYPES[:any]
+    end
+
     def ==(other)
       other.is_a?(Group) && @value == other.value
     end
   end
 
   class Operation
-    attr_reader :op, :operands
+    attr_reader :op, :operands, :depth
 
     attr_accessor :type
 
-    def initialize(op, operands)
+    def initialize(op, operands, depth: 1)
       @op = op
       @operands = operands
       @type = TYPES[:any]
+      @depth = depth
     end
 
     def ==(other)
@@ -573,12 +814,17 @@ module Cel
   end
 
   class Condition
-    attr_reader :if, :then, :else
+    attr_reader :if, :then, :else, :depth
 
-    def initialize(if_, then_, else_)
+    def initialize(if_, then_, else_, depth: 1)
       @if = if_
       @then = then_
       @else = else_
+      @depth = depth
+    end
+
+    def type
+      TYPES[:any]
     end
 
     def ==(other)