cel 0.1.0

data/lib/cel/program.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Cel
+  class Program
+    def initialize(context)
+      @context = context
+    end
+
+    def evaluate(ast)
+      case ast
+      when Group
+        evaluate(ast.value)
+      when Invoke
+        evaluate_invoke(ast)
+      when Operation
+        evaluate_operation(ast)
+      when Message
+        ast.struct
+      when Literal
+        evaluate_literal(ast)
+      when Identifier
+        evaluate_identifier(ast)
+      when Condition
+        evaluate_condition(ast)
+      end
+    end
+
+    alias_method :call, :evaluate
+
+    private
+
+    def evaluate_identifier(identifier)
+      if Cel::PRIMITIVE_TYPES.include?(identifier.to_sym)
+        TYPES[identifier.to_sym]
+      else
+        @context.lookup(identifier)
+      end
+    end
+
+    def evaluate_literal(val)
+      case val
+      when List
+        List.new(val.value.map { |y| call(y) })
+      else
+        val
+      end
+    end
+
+    def evaluate_operation(operation)
+      op = operation.op
+
+      values = operation.operands.map do |operand|
+        ev_operand = call(operand)
+
+        # return ev_operand if op == "||" && ev_operand == true
+
+        ev_operand
+      end
+
+      if values.size == 1 &&
+         op != "!" # https://bugs.ruby-lang.org/issues/18246
+        # unary operations
+        values.first.__send__(:"#{op}@")
+      elsif op == "&&"
+        Bool.new(values.all? { |x| x == true })
+      elsif op == "||"
+        Bool.new(values.any? { |x| x == true })
+      elsif op == "in"
+        element, collection = values
+        Bool.new(collection.include?(element))
+      else
+        op_value, *values = values
+        op_value.public_send(op, *values)
+      end
+    end
+
+    def evaluate_invoke(invoke, var = invoke.var)
+      func = invoke.func
+      args = invoke.args
+
+      return evaluate_standard_func(invoke) unless var
+
+      var = case var
+            when Identifier
+              evaluate_identifier(var)
+            when Invoke
+              evaluate_invoke(var)
+            else
+              var
+      end
+
+      case var
+      when String
+        raise EvaluateError, "#{invoke} is not supported" unless String.method_defined?(func, false)
+
+        var.public_send(func, *args)
+      when Message
+        # If e evaluates to a message and f is not declared in this message, the
+        # runtime error no_such_field is raised.
+        raise NoSuchFieldError.new(var, func) unless var.field?(func)
+
+        var.public_send(func)
+      when Map, List
+        return Macro.__send__(func, var, *args, context: @context) if Macro.respond_to?(func)
+
+        # If e evaluates to a map, then e.f is equivalent to e['f'] (where f is
+        # still being used as a meta-variable, e.g. the expression x.foo is equivalent
+        # to the expression x['foo'] when x evaluates to a map).
+
+        args ?
+        var.public_send(func, *args) :
+        var.public_send(func)
+      else
+        raise EvaluateError, "#{invoke} is not supported"
+      end
+    end
+
+    def evaluate_condition(condition)
+      call(condition.if) ? call(condition.then) : call(condition.else)
+    end
+
+    def evaluate_standard_func(funcall)
+      func = funcall.func
+      args = funcall.args
+
+      case func
+      when :type
+        val = call(args.first)
+        return val.type if val.respond_to?(:type)
+
+        val.class
+      # MACROS
+      when :has, :size
+        Macro.__send__(func, *args)
+      when :matches
+        Macro.__send__(func, *args.map { |arg| call(arg) })
+      when :int, :uint, :string, :double, :bytes # :duration, :timestamp
+        type = TYPES[func]
+        type.cast(call(args.first))
+      when :dyn
+        call(args.first)
+      else
+        raise EvaluateError, "#{funcall} is not supported"
+      end
+    end
+  end
+end

data/lib/cel/protobuf.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Cel
+  module Protobuf
+    module CheckExtensions
+      def self.included(klass)
+        super
+        klass.alias_method :check_standard_func_without_protobuf, :check_standard_func
+        klass.alias_method :check_standard_func, :check_standard_func_with_protobuf
+
+        klass.alias_method :check_invoke_without_protobuf, :check_invoke
+        klass.alias_method :check_invoke, :check_invoke_with_protobuf
+      end
+
+      private
+
+      def check_invoke_with_protobuf(funcall)
+        var = funcall.var
+
+        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
+
+        return check_invoke_without_protobuf(funcall, var_type) if var_type.is_a?(Cel::Type)
+        return check_invoke_without_protobuf(funcall, var_type) unless var_type < Google::Protobuf::MessageExts
+
+        func = funcall.func
+
+        attribute = var_type.descriptor.lookup(func.to_s)
+
+        raise NoSuchFieldError.new(var, func) unless attribute
+
+        # TODO: return super to any, or raise error?
+
+        type = attribute.type
+
+        # https://github.com/google/cel-spec/blob/master/doc/langdef.md#protocol-buffer-data-conversion
+        case type
+        when :int32, :int64, :sint32, :sint64, :sfixed32, :sfixed64
+          TYPES[:int]
+        when :uint32, :uint64, :fixed32, :fixed64
+          TYPES[:uint]
+        when :float, :double
+          TYPES[:double]
+        when :bool, :string, :bytes
+          TYPES[type]
+        when :repeated
+          TYPES[:list]
+        when :map
+          TYPES[:map]
+        when :oneof
+          TYPES[:any]
+        else
+          type
+        end
+      end
+
+      def check_standard_func_with_protobuf(funcall)
+        func = funcall.func
+        args = funcall.args
+
+        case func
+        when :duration
+          check_arity(func, args, 1)
+          unsupported_type(funcall) unless args.first.is_a?(String)
+
+          return Google::Protobuf::Duration
+        when :timestamp
+          check_arity(func, args, 1)
+          unsupported_type(funcall) unless args.first.is_a?(String)
+
+          return Google::Protobuf::Timestamp
+        end
+
+        check_standard_func_without_protobuf(funcall)
+      end
+    end
+
+    module EvaluateExtensions
+      def self.included(klass)
+        super
+        klass.alias_method :evaluate_standard_func_without_protobuf, :evaluate_standard_func
+        klass.alias_method :evaluate_standard_func, :evaluate_standard_func_with_protobuf
+
+        klass.alias_method :evaluate_invoke_without_protobuf, :evaluate_invoke
+        klass.alias_method :evaluate_invoke, :evaluate_invoke_with_protobuf
+      end
+
+      private
+
+      def evaluate_invoke_with_protobuf(invoke)
+        var = invoke.var
+
+        return evaluate_standard_func(invoke) unless var
+
+        var = case var
+              when Identifier
+                evaluate_identifier(var)
+              when Invoke
+                evaluate_invoke(var)
+              else
+                var
+        end
+
+        return evaluate_invoke_without_protobuf(invoke, var) unless var.is_a?(Google::Protobuf::MessageExts)
+
+        func = invoke.func
+
+        var.public_send(func)
+      end
+
+      def evaluate_standard_func_with_protobuf(funcall)
+        func = funcall.func
+        args = funcall.args
+
+        case func
+        when :duration
+          seconds = 0
+          nanos = 0
+          args.first.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
+          return Google::Protobuf::Duration.new(seconds: seconds, nanos: nanos)
+        when :timestamp
+          time = Time.parse(args.first)
+          return Google::Protobuf::Timestamp.from_time(time)
+        end
+
+        evaluate_standard_func_without_protobuf(funcall)
+      end
+    end
+
+    module ContextExtensions
+      def self.included(klass)
+        super
+        klass.alias_method :to_cel_type_without_protobuf, :to_cel_type
+        klass.alias_method :to_cel_type, :to_cel_type_with_protobuf
+      end
+
+      def to_cel_type_with_protobuf(v)
+        return v if v.is_a?(Google::Protobuf::MessageExts)
+
+        to_cel_type_without_protobuf(v)
+      end
+    end
+  end
+
+  Checker.include(Protobuf::CheckExtensions)
+  Program.include(Protobuf::EvaluateExtensions)
+  Context.include(Protobuf::ContextExtensions)
+end

data/lib/cel/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Cel
+  module Ruby
+    VERSION = "0.1.0"
+  end
+end

data/lib/cel.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+require "cel/version"
+require "cel/errors"
+require "cel/ast/types"
+require "cel/parser"
+require "cel/macro"
+require "cel/context"
+require "cel/checker"
+require "cel/program"
+require "cel/environment"
+
+begin
+  require "google/protobuf/well_known_types"
+  require "cel/protobuf"
+rescue LoadError # rubocop:disable Lint/SuppressedException
+end
+
+module Cel
+  def self.to_numeric(anything)
+    num = BigDecimal(anything.to_s)
+    if num.frac.zero?
+      num.to_i
+    else
+      num.to_f
+    end
+  end
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: cel
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tiago Cardoso
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-11-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: minitest
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Pure Ruby implementation of Google Common Expression Language, https://opensource.google/projects/cel.
+email:
+- cardoso_tiago@hotmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- CHANGELOG.md
+- README.md
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/cel.rb
+- lib/cel/ast/elements.rb
+- lib/cel/ast/types.rb
+- lib/cel/checker.rb
+- lib/cel/context.rb
+- lib/cel/environment.rb
+- lib/cel/errors.rb
+- lib/cel/macro.rb
+- lib/cel/parser.rb
+- lib/cel/program.rb
+- lib/cel/protobuf.rb
+- lib/cel/version.rb
+homepage:
+licenses:
+- Apache 2.0
+metadata:
+  bug_tracker_uri: https://gitlab.com/honeyryderchuck/cel-ruby/issues
+  changelog_uri: https://gitlab.com/honeyryderchuck/cel-ruby/-/blob/master/CHANGELOG.md
+  source_code_uri: https://gitlab.com/honeyryderchuck/cel-ruby
+  homepage_uri: https://gitlab.com/honeyryderchuck/cel-ruby
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.6'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.14
+signing_key:
+specification_version: 4
+summary: Pure Ruby implementation of Google Common Expression Language, https://opensource.google/projects/cel.
+test_files: []