cel 0.1.0

data/lib/cel/ast/types.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Cel
+  class Type
+    def initialize(type)
+      @type = type
+    end
+
+    def ==(other)
+      other == @type || super
+    end
+
+    def to_str
+      @type.to_s
+    end
+
+    def type
+      TYPES[:type]
+    end
+
+    def cast(value)
+      case @type
+      when :int
+        Number.new(:int, Integer(value))
+      when :uint
+        Number.new(:uint, Integer(value).abs)
+      when :double
+        Number.new(:double, Float(value))
+      when :string
+        String.new(String(value))
+      when :bytes
+        Bytes.new(value.bytes)
+      when :bool
+        Bool.new(value)
+      when :any
+        value
+      else
+        raise Error, "unsupported cast operation to #{@type}"
+      end
+    end
+  end
+
+  class ListType < Type
+    attr_accessor :element_type
+
+    def initialize(type_list)
+      super(:list)
+      @type_list = type_list
+      @element_type = @type_list.empty? ? TYPES[:any] : @type_list.sample.type
+    end
+
+    def get(idx)
+      @type_list[idx]
+    end
+  end
+
+  class MapType < Type
+    attr_accessor :element_type
+
+    def initialize(type_map)
+      super(:map)
+      @type_map = type_map
+      @element_type = @type_map.empty? ? TYPES[:any] : @type_map.keys.sample.type
+    end
+
+    def get(attrib)
+      _, value = @type_map.find { |k, _| k == attrib.to_s }
+      value
+    end
+  end
+
+  # Primitive Cel Types
+
+  PRIMITIVE_TYPES = %i[int uint double bool string bytes list map null_type type].freeze
+  TYPES = PRIMITIVE_TYPES.map { |typ| [typ, Type.new(typ)] }.to_h
+  TYPES[:type] = Type.new(:type)
+  TYPES[:any] = Type.new(:any)
+end

data/lib/cel/checker.rb

@@ -0,0 +1,323 @@
+# frozen_string_literal: true
+
+module Cel
+  class Checker
+    def initialize(declarations)
+      @declarations = declarations
+    end
+
+    def check(ast)
+      case ast
+      when Group
+        check(ast.value)
+      when Invoke
+        check_invoke(ast)
+      when Operation
+        check_operation(ast)
+      when Literal
+        ast.type
+      when Identifier
+        check_identifier(ast)
+      when Condition
+        check_condition(ast)
+      end
+    end
+
+    alias_method :call, :check
+
+    private
+
+    def merge(declarations)
+      Checker.new(@declarations ? @declarations.merge(declarations) : declarations)
+    end
+
+    # TODO: add protobuf timestamp and duration
+    LOGICAL_EXPECTED_TYPES = %i[bool int uint double string bytes].freeze
+    ADD_EXPECTED_TYPES = %i[int uint double string bytes list].freeze
+    SUB_EXPECTED_TYPES = %i[int uint double].freeze
+    MULTIDIV_EXPECTED_TYPES = %i[int uint double].freeze
+    REMAINDER_EXPECTED_TYPES = %i[int uint].freeze
+
+    def check_operation(operation)
+      type = infer_operation_type(operation)
+      operation.type = type
+      type
+    end
+
+    BOOLABLE_OPERATORS = %w[&& || == != < <= >= >].freeze
+
+    def infer_operation_type(operation)
+      op = operation.op
+
+      values = operation.operands.map do |operand|
+        ev_operand = call(operand)
+
+        return TYPES[:any] if ev_operand == :any && !BOOLABLE_OPERATORS.include?(op)
+
+        ev_operand
+      end
+
+      if values.size == 1
+        # unary ops
+        type = values.first
+        case op
+        when "!"
+          return type if type == :bool
+
+        when "-"
+          return type if type == :int || type == :double # rubocop:disable Style/MultipleComparison
+
+        else
+          unsupported_type(operation)
+        end
+      else
+
+        case op
+        when "&&", "||", "==", "!=", "<", "<=", ">=", ">"
+          return TYPES[:bool]
+        when "in"
+          return TYPES[:bool] if find_match_all_types(%i[list map], values.last)
+        when "+"
+          if (type = find_match_all_types(ADD_EXPECTED_TYPES, values))
+            return type
+          end
+        when "-"
+          if (type = find_match_all_types(SUB_EXPECTED_TYPES, values))
+            return type
+          end
+        when "*", "/"
+          if (type = find_match_all_types(MULTIDIV_EXPECTED_TYPES, values))
+            return type
+          end
+        when "%"
+          if (type = find_match_all_types(REMAINDER_EXPECTED_TYPES, values))
+            return type
+          end
+        else
+          unsupported_type(operation)
+        end
+      end
+      unsupported_type(operation)
+    end
+
+    def check_invoke(funcall, var_type = nil)
+      var = funcall.var
+      func = funcall.func
+      args = funcall.args
+
+      return check_standard_func(funcall) unless var
+
+      var_type ||= case var
+                   when Identifier
+                     check_identifier(var)
+                   when Invoke
+                     check_invoke(var)
+                   else
+                     var.type
+      end
+
+      case var_type
+      when MapType
+        # A field selection expression, e.f, can be applied both to messages and
+        # to maps. For maps, selection is interpreted as the field being a string key.
+        case func
+        when :[]
+          attribute = var_type.get(args)
+          unsupported_operation(funcall) unless attribute
+        when :all, :exists, :exists_one
+          check_arity(funcall, args, 2)
+          identifier, predicate = args
+
+          unsupported_type(funcall) unless identifier.is_a?(Identifier)
+
+          element_checker = merge(identifier.to_sym => var_type.element_type)
+
+          unsupported_type(funcall) if element_checker.check(predicate) != :bool
+
+          return TYPES[:bool]
+        else
+          attribute = var_type.get(func)
+          unsupported_operation(funcall) unless attribute
+        end
+
+        call(attribute)
+      when ListType
+        case func
+        when :[]
+          attribute = var_type.get(args)
+          unsupported_operation(funcall) unless attribute
+          call(attribute)
+        when :all, :exists, :exists_one
+          check_arity(funcall, args, 2)
+          identifier, predicate = args
+
+          unsupported_type(funcall) unless identifier.is_a?(Identifier)
+
+          element_checker = merge(identifier.to_sym => var_type.element_type)
+
+          unsupported_type(funcall) if element_checker.check(predicate) != :bool
+
+          TYPES[:bool]
+        when :filter
+          check_arity(funcall, args, 2)
+          identifier, predicate = args
+
+          unsupported_type(funcall) unless identifier.is_a?(Identifier)
+
+          element_checker = merge(identifier.to_sym => var_type.element_type)
+
+          unsupported_type(funcall) if element_checker.check(predicate) != :bool
+
+          var_type
+        when :map
+          check_arity(funcall, args, 2)
+          identifier, predicate = args
+
+          unsupported_type(funcall) unless identifier.is_a?(Identifier)
+
+          element_checker = merge(identifier.to_sym => var_type.element_type)
+
+          var_type.element_type = element_checker.check(predicate)
+          var_type
+        else
+          unsupported_operation(funcall)
+        end
+      when TYPES[:string]
+        case func
+        when :contains, :endsWith, :startsWith
+          check_arity(funcall, args, 1)
+          return TYPES[:bool] if find_match_all_types(%i[string], call(args.first))
+        when :matches # rubocop:disable Lint/DuplicateBranch
+          check_arity(funcall, args, 1)
+          # TODO: verify if string can be transformed into a regex
+          return TYPES[:bool] if find_match_all_types(%i[string], call(args.first))
+        else
+          unsupported_type(funcall)
+        end
+        unsupported_operation(funcall)
+      else
+        TYPES[:any]
+      end
+    end
+
+    CAST_ALLOWED_TYPES = {
+      int: %i[uint double string], # TODO: enum, timestamp
+      uint: %i[int double string],
+      string: %i[int uint double bytes], # TODO: timestamp, duration
+      double: %i[int uint string],
+      bytes: %i[string],
+    }.freeze
+
+    def check_standard_func(funcall)
+      func = funcall.func
+      args = funcall.args
+
+      case func
+      when :type
+        check_arity(func, args, 1)
+        return TYPES[:type]
+      when :has
+        check_arity(func, args, 1)
+        unsupported_type(funcall) unless args.first.is_a?(Invoke)
+
+        return TYPES[:bool]
+      when :size
+        check_arity(func, args, 1)
+        return TYPES[:int] if find_match_all_types(%i[string bytes list map], call(args.first))
+      when :int, :uint, :string, :double, :bytes # :duration, :timestamp
+        check_arity(func, args, 1)
+        allowed_types = CAST_ALLOWED_TYPES[func]
+
+        return TYPES[func] if find_match_all_types(allowed_types, call(args.first))
+      when :matches
+        check_arity(func, args, 2)
+        return TYPES[:bool] if find_match_all_types(%i[string], args.map { |arg| call(arg) })
+      when :dyn
+        check_arity(func, args, 1)
+        arg_type = call(args.first)
+        case arg_type
+        when ListType, MapType
+          arg_type.element_type = TYPES[:any]
+        end
+        return arg_type
+      else
+        unsupported_type(funcall)
+      end
+
+      unsupported_operation(funcall)
+    end
+
+    def check_identifier(identifier)
+      return unless identifier.type == :any
+
+      return TYPES[:type] if Cel::PRIMITIVE_TYPES.include?(identifier.to_sym)
+
+      id_type = infer_dec_type(identifier.id)
+
+      return TYPES[:any] unless id_type
+
+      identifier.type = id_type
+
+      id_type
+    end
+
+    def check_condition(condition)
+      then_type = call(condition.then)
+      else_type = call(condition.else)
+
+      return then_type if then_type == else_type
+
+      TYPES[:any]
+    end
+
+    def infer_dec_type(id)
+      return unless @declarations
+
+      var_name, *id_call_chain = id.split(".").map(&:to_sym)
+
+      typ = @declarations[var_name]
+
+      return unless typ
+
+      return convert(typ) if id_call_chain.empty?
+    end
+
+    def convert(typ)
+      case typ
+      when Symbol
+        TYPES[typ] or
+          raise CheckError, "#{typ} is not aa valid type"
+      else
+        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
+
+      TYPES[type]
+    end
+
+    def check_arity(func, args, arity)
+      return if args.size == arity
+
+      raise CheckError, "`#{func}` invoked with wrong number of arguments (should be #{arity})"
+    end
+
+    def unsupported_type(op)
+      raise NoMatchingOverloadError, op
+    end
+
+    def unsupported_operation(op)
+      raise CheckError, "unsupported operation (#{op})"
+    end
+  end
+end

data/lib/cel/context.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Cel
+  class Context
+    def initialize(bindings)
+      @bindings = bindings.dup
+
+      return unless @bindings
+
+      @bindings.each do |k, v|
+        @bindings[k] = to_cel_type(v)
+      end
+    end
+
+    def lookup(identifier)
+      raise EvaluateError, "no value in context for #{identifier}" unless @bindings
+
+      id = identifier.id
+      val = @bindings.dig(*id.split(".").map(&:to_sym))
+
+      raise EvaluateError, "no value in context for #{identifier}" unless val
+
+      val
+    end
+
+    def merge(bindings)
+      Context.new(@bindings ? @bindings.merge(bindings) : bindings)
+    end
+
+    private
+
+    def to_cel_type(v)
+      Literal.to_cel_type(v)
+    end
+  end
+end

data/lib/cel/environment.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Cel
+  class Environment
+    def initialize(declarations = nil)
+      @declarations = declarations
+      @parser = Parser.new
+      @checker = Checker.new(@declarations)
+    end
+
+    def compile(expr)
+      ast = @parser.parse(expr)
+      @checker.check(ast)
+      ast
+    end
+
+    def check(expr)
+      ast = @parser.parse(expr)
+      @checker.check(ast)
+    end
+
+    def program(expr)
+      expr = compile(expr) if expr.is_a?(::String)
+      Runner.new(expr)
+    end
+
+    def evaluate(expr, bindings = nil)
+      context = Context.new(bindings)
+      expr = compile(expr) if expr.is_a?(::String)
+      Program.new(context).evaluate(expr)
+    end
+
+    private
+
+    def validate(ast, structs); end
+  end
+
+  class Runner
+    def initialize(ast)
+      @ast = ast
+    end
+
+    def evaluate(bindings = nil)
+      context = Context.new(bindings)
+      Program.new(context).evaluate(@ast)
+    end
+  end
+end

data/lib/cel/errors.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Cel
+  class Error < StandardError; end
+
+  class ParseError < Error; end
+
+  class CheckError < Error; end
+
+  class EvaluateError < Error; end
+
+  class NoSuchFieldError < EvaluateError
+    attr_reader :code
+
+    def initialize(var, attrib)
+      super("No such field: #{var}.#{attrib}")
+      @code = :no_such_field
+    end
+  end
+
+  class NoMatchingOverloadError < CheckError
+    attr_reader :code
+
+    def initialize(op)
+      super("No matching overload: #{op}")
+      @code = :no_matching_overload
+    end
+  end
+
+  class BindingError < EvaluateError; end
+end

data/lib/cel/macro.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Cel
+  module Macro
+    module_function
+
+    # If e evaluates to a protocol buffers version 2 message and f is a defined field:
+    #     If f is a repeated field or map field, has(e.f) indicates whether the field is non-empty.
+    #     If f is a singular or oneof field, has(e.f) indicates whether the field is set.
+    # If e evaluates to a protocol buffers version 3 message and f is a defined field:
+    #     If f is a repeated field or map field, has(e.f) indicates whether the field is non-empty.
+    #     If f is a oneof or singular message field, has(e.f) indicates whether the field is set.
+    #     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)
+      var = invoke.var
+      func = invoke.func
+
+      case var
+      when Message
+        # 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.field?(func)
+
+        Bool.new(!var.public_send(func).nil?)
+      when Map
+        # If e evaluates to a map, then has(e.f) indicates whether the string f
+        # is a key in the map (note that f must syntactically be an identifier).
+        Bool.new(var.respond_to?(func))
+      else
+        # In all other cases, has(e.f) evaluates to an error.
+        raise EvaluateError, "#{invoke} is not supported"
+      end
+    end
+
+    def size(literal)
+      literal.size
+    end
+
+    def matches(string, pattern)
+      pattern = Regexp.new(pattern)
+      Bool.new(pattern.match?(string))
+    end
+
+    def all(collection, identifier, predicate, context:)
+      collection.all? do |element, *|
+        Program.new(context.merge(identifier.to_sym => element)).evaluate(predicate).value
+      end
+    end
+
+    def exists(collection, identifier, predicate, context:)
+      collection.any? do |element, *|
+        Program.new(context.merge(identifier.to_sym => element)).evaluate(predicate).value
+      end
+    end
+
+    def exists_one(collection, identifier, predicate, context:)
+      collection.one? do |element, *|
+        Program.new(context.merge(identifier.to_sym => element)).evaluate(predicate).value
+      end
+    end
+
+    def filter(collection, identifier, predicate, context:)
+      collection.select do |element, *|
+        Program.new(context.merge(identifier.to_sym => element)).evaluate(predicate).value
+      end
+    end
+
+    def map(collection, identifier, predicate, context:)
+      collection.map do |element, *|
+        Program.new(context.merge(identifier.to_sym => element)).evaluate(predicate)
+      end
+    end
+  end
+end