cel 0.3.1 → 0.4.1

data/lib/cel/ast/elements.rb

@@ -1,834 +1,24 @@
 # frozen_string_literal: true
 
-require "time"
-require "delegate"
-
 module Cel
   LOGICAL_OPERATORS = %w[<= >= < > == != in].freeze
   MULTI_OPERATORS = %w[* / %].freeze
-
-  class Identifier < SimpleDelegator
-    attr_reader :id
-
-    attr_accessor :type
-
-    def initialize(identifier, package = nil)
-      @id = identifier
-      @type = TYPES[:any]
-      @package = package
-      super(@id)
-    end
-
-    def ==(other)
-      super || other.to_s == @id.to_s
-    end
-
-    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
-    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
-
-  class Invoke
-    attr_accessor :var
-
-    attr_reader :func, :args, :depth
-
-    def self.new(func:, var: nil, args: nil, **rest)
-      Protobuf.try_invoke_from(var, func, args) || super
-    end
-
-    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)
-      case other
-      when Invoke
-        @var == other.var && @func == other.func && @args == other.args
-      when Array
-        [@var, @func, @args].compact == other
-      else
-        super
-      end
-    end
-
-    def to_s
-      if var
-        if indexing?
-          "#{var}[#{args}]"
-        else
-          "#{var}.#{func}#{"(#{args.map(&:to_s).join(", ")})" if args}"
-        end
-      else
-        "#{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 :label, :types, :type
-
-    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
-      end
-      @types = types.map { |typ| typ.is_a?(Type) ? typ : TYPES[typ] }
-      @type = if return_type.nil?
-        TYPES[:any]
-      else
-        return_type.is_a?(Type) ? return_type : TYPES[return_type]
-      end
-      @func = func
-      @label = label
-    end
-
-    def call(*args)
-      Literal.to_cel_type(@func.call(*args))
-    end
-  end
-
-  mod = self
-  mod.define_singleton_method(:Function) do |*args, **kwargs, &blk|
-    mod::Function.new(*args, **kwargs, &blk)
-  end
-
-  class Literal < SimpleDelegator
-    attr_reader :type, :value
-
-    def initialize(type, value)
-      @type = type.is_a?(Type) ? type : TYPES[type]
-      @value = value
-      super(value)
-      check
-    end
-
-    def ==(other)
-      case other
-      when Literal
-        @type == other.type && @value == other.value
-      else
-        @value == other
-      end
-    end
-
-    def self.to_cel_type(val)
-      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, Invoke, Operation, Condition, Group, # already cel
-          Protobuf.enum_class # already a usable class a la protobuf
-        val
-      when Protobuf.map_class
-        Map.new(val.to_h)
-      when ::String
-        String.new(val)
-      when ::Symbol
-        Identifier.new(val)
-      when ::Integer
-        Number.new(:int, val)
-      when ::Float, ::BigDecimal
-        Number.new(:double, val)
-      when ::Hash
-        Map.new(val)
-      when ::Array
-        List.new(val)
-      when true, false
-        Bool.cast(val)
-      when nil
-        Null::INSTANCE
-      when Time
-        Timestamp.new(val)
-      else
-        raise BindingError, "can't convert #{val} to CEL type"
-      end
-    end
-
-    alias_method :to_ruby_type, :value
-
-    private
-
-    def check; end
-  end
-
-  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)
-        def #{op}(other)
-          value = super
-          check_overflow(value)
-          Number.new(@type, value)
-        end
-      OUT
-    end
-
-    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}@
-          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
-    def initialize(value)
-      super(:bool, value)
-    end
-
-    (LOGICAL_OPERATORS - %w[== != in]).each do |op|
-      class_eval(<<-OUT, __FILE__, __LINE__ + 1)
-        def #{op}(other)
-          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.cast(super)
-    end
-
-    TRUE_VALUE = new(true)
-    FALSE_VALUE = new(false)
-
-    def self.cast(val)
-      val ? TRUE_VALUE : FALSE_VALUE
-    end
-  end
-
-  class Null < Literal
-    def initialize
-      super(:null_type, nil)
-    end
-
-    INSTANCE = new.freeze
-  end
-
-  class String < Literal
-    def initialize(value)
-      super(:string, value)
-    end
-
-    # override base String#%
-    def %(_other)
-      raise NoMethodError, "undefined method '%' for #{self}"
-    end
-
-    # CEL string functions
-
-    def contains(string)
-      Bool.cast(@value.include?(string))
-    end
-
-    def endsWith(string)
-      Bool.cast(@value.end_with?(string))
-    end
-
-    def startsWith(string)
-      Bool.cast(@value.start_with?(string))
-    end
-
-    def matches(pattern)
-      Macro.matches(self, pattern)
-    end
-
-    %i[+ -].each do |op|
-      class_eval(<<-OUT, __FILE__, __LINE__ + 1)
-        def #{op}(other)
-          String.new(super)
-        end
-      OUT
-    end
-  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)
-          other.is_a?(Cel::Bytes) ? Bool.cast(@string.__send__(__method__, other.string)) : super
-        end
-      OUT
-    end
-
-    %i[+ -].each do |op|
-      class_eval(<<-OUT, __FILE__, __LINE__ + 1)
-        def #{op}(other)
-          Bytes.new(@value + other.value)
-        end
-      OUT
-    end
-  end
-
-  class List < Literal
-    attr_reader :depth
-
-    def initialize(value, depth: 1)
-      value = value.map do |v|
-        Literal.to_cel_type(v)
-      end
-      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
-      [self]
-    end
-
-    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
-    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|
-      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) }
-    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
-
-  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
-
-    def +(other)
-      Timestamp.new(@value + other.to_f)
-    end
-
-    def -(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)
-        def #{op}(other)
-          other.is_a?(Cel::Literal) ? Bool.cast(super) : super
-        end
-      OUT
-    end
-
-    # Cel Functions
-
-    def getDate(tz = nil)
-      Number.new(:int, to_local_time(tz).day)
-    end
-
-    def getDayOfMonth(tz = nil)
-      getDate(tz) - 1
-    end
-
-    def getDayOfWeek(tz = nil)
-      Number.new(:int, to_local_time(tz).wday)
-    end
-
-    def getDayOfYear(tz = nil)
-      Number.new(:int, to_local_time(tz).yday - 1)
-    end
-
-    def getMonth(tz = nil)
-      Number.new(:int, to_local_time(tz).month - 1)
-    end
-
-    def getFullYear(tz = nil)
-      Number.new(:int, to_local_time(tz).year)
-    end
-
-    def getHours(tz = nil)
-      Number.new(:int, to_local_time(tz).hour)
-    end
-
-    def getMinutes(tz = nil)
-      Number.new(:int, to_local_time(tz).min)
-    end
-
-    def getSeconds(tz = nil)
-      Number.new(:int, to_local_time(tz).sec)
-    end
-
-    def getMilliseconds(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
-
-    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
-
-  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
-
-      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.cast(super)
-          when Numeric
-            @value == other
-
-          else
-            super
-          end
-        end
-      OUT
-    end
-
-    # Cel Functions
-
-    def getHours
-      Cel::Number.new(:int, (getMinutes / 60).to_i)
-    end
-
-    def getMinutes
-      Cel::Number.new(:int, (getSeconds / 60).to_i)
-    end
-
-    def getSeconds
-      Cel::Number.new(:int, @value.divmod(1).first)
-    end
-
-    def getMilliseconds
-      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
-
-    def init_from_string(value)
-      seconds = 0
-      nanos = 0
-      value.scan(/([0-9]*(?:\.[0-9]*)?)([a-z]+)/) do |duration, units|
-        case units
-        when "h"
-          seconds += Cel.to_numeric(duration) * 60 * 60
-        when "m"
-          seconds += Cel.to_numeric(duration) * 60
-        when "s"
-          seconds += Cel.to_numeric(duration)
-        when "ms"
-          nanos += Cel.to_numeric(duration) * 1000 * 1000
-        when "us"
-          nanos += Cel.to_numeric(duration) * 1000
-        when "ns"
-          nanos += Cel.to_numeric(duration)
-        else
-          raise EvaluateError, "#{units} is unsupported"
-        end
-      end
-      duration = seconds + (nanos / 1_000_000_000.0)
-      duration = -duration if value.start_with?("-")
-      duration
-    end
-  end
-
-  class Group
-    attr_reader :value
-
-    def initialize(value)
-      @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, :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
-
-  class Condition
-    attr_reader :if, :then, :else, :depth
-
-    def initialize(if_, then_, else_, depth: 1)
-      @if = if_
-      @then = then_
-      @else = else_
-      @depth = depth
-    end
-
-    def type
-      TYPES[:any]
-    end
-
-    def ==(other)
-      other.is_a?(Condition) && @if == other.if && @then == other.then && @else == other.else
-    end
-  end
 end
+
+require_relative "elements/group"
+require_relative "elements/condition"
+require_relative "elements/operation"
+require_relative "elements/invoke"
+require_relative "elements/message"
+require_relative "elements/identifier"
+require_relative "elements/function"
+require_relative "elements/literal"
+require_relative "elements/null"
+require_relative "elements/number"
+require_relative "elements/bool"
+require_relative "elements/string"
+require_relative "elements/bytes"
+require_relative "elements/list"
+require_relative "elements/map"
+require_relative "elements/timestamp"
+require_relative "elements/duration"