cel 0.2.0 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 868e7e643aad1444aa54da0dab45e583a49abf2e6af0dcbbd1512b88af209e88
-  data.tar.gz: 2f174f88813b63181f1c16e701d1baf961eda0d9ef18c575b29b5afdc53d450c
+  metadata.gz: ed190ec0ddbda3e8c5229160dff580efa6cf1175f8b5ed5245e8de40f1feb800
+  data.tar.gz: 5f5d64c6a0199a0d47c7c29a3ef0c022f666e752147cadefbe6fc7090685e819
 SHA512:
-  metadata.gz: 26c83e074c1729c00f5b8c3ca271865bb009f562326c6b6ddca3d5c127cf7c7f33ab93b3c964d4db0eafbe442e07dc1413abf2dc5b5ac487950da2d02fc8cd69
-  data.tar.gz: 3aa55062c1693eb5c3d3ad45bb09d95028c5115a9428d8bf2fdd3189b5c8869c4b6d92c6aa3e864b515f555fe78d3015fbeaf03799d64f0ef9f8365ce95a87d0
+  metadata.gz: c1c1aec4b0d8e54cf52a18057933c1ed214cddd79671ba6280f4e46f852c595f62259b4a10e2d8d0187d0b296f726b6dcae0b07aaccded157769b55f44d88900
+  data.tar.gz: 06c5d2653edca32b4cfb411a788734a0de1c9dcd6368f95b4ad4dcaeffe0b7fb82504c8e861d515acd19dbadb514804c5c6c108aa09e1600da0b9c1a60aec519

data/CHANGELOG.md

@@ -1,5 +1,47 @@
 ## [Unreleased]
 
+## [0.2.2] - 2023-08-17
+
+* Reimplements `Cel::Literal#==` in a simpler way, to avoid several comparison issues arising from the previous implementation.
+* fix initialization of `Cel::Duration` and `Cel::Timestamp` from string notation.
+* fix protobuf-to-cel parsing of negative literals.
+* more consistent usage of Cel types internally.
+* fix condition clause evaluation.
+
+
+## [0.2.1] - 2023-07-26
+
+
+### Improvements
+
+Collection type declarations are now better supported, i.e. declaring "an array of strings" is now possible:
+
+```ruby
+Cel::Types[:list, :string] # array of strings
+Cel::Environment.new(
+    names: Cel::Types[:list, :string],
+    owned_by: Cel::Types[:map, :string] # hash map of string keys
+)
+```
+
+### Bugfixes
+
+Collections passed as variables of an expression are now correctly cast to Cel types:
+
+```ruby
+env.evaluate("a", { a: [1, 2, 3] }) #=> now returns a Cel::List
+```
+
+Conversely, custom functions now expose ruby types in the blocks, instead of its Cel counterparts:
+
+```ruby
+func = Cel::Function(:list, :list, return_type: :list) do |a, b|
+  # a is now a ruby array, b as well
+  a & b
+  # function returns a ruby array, will be converted to a Cel::List for use in the expression
+end
+```
+
 ## [0.2.0] - 2023-01-17
 
 ### Features

data/README.md

@@ -1,8 +1,8 @@
 # Cel::Ruby
 
 [![Gem Version](https://badge.fury.io/rb/cel.svg)](http://rubygems.org/gems/cel)
-[![pipeline status](https://gitlab.com/honeyryderchuck/cel-ruby/badges/master/pipeline.svg)](https://gitlab.com/honeyryderchuck/cel-ruby/pipelines?page=1&scope=all&ref=master)
-[![coverage report](https://gitlab.com/honeyryderchuck/cel-ruby/badges/master/coverage.svg?job=coverage)](https://honeyryderchuck.gitlab.io/cel-ruby/coverage/#_AllFiles)
+[![pipeline status](https://gitlab.com/os85/cel-ruby/badges/master/pipeline.svg)](https://gitlab.com/os85/cel-ruby/pipelines?page=1&scope=all&ref=master)
+[![coverage report](https://gitlab.com/os85/cel-ruby/badges/master/coverage.svg?job=coverage)](https://os85.gitlab.io/cel-ruby/coverage/#_AllFiles)
 
 Pure Ruby implementation of Google Common Expression Language, https://opensource.google/projects/cel.
 
@@ -45,19 +45,20 @@ end
 prg = env.program(ast)
 # 1.3 evaluate
 return_value = prg.evaluate(name: Cel::String.new("/groups/acme.co/documents/secret-stuff"),
-    group: Cel::String.new("acme.co")))
+    group: Cel::String.new("acme.co"))
 
 # 2.1 parse and check
 prg = env.program('name.startsWith("/groups/" + group)')
 # 2.2 then evaluate
 return_value = prg.evaluate(name: Cel::String.new("/groups/acme.co/documents/secret-stuff"),
-    group: Cel::String.new("acme.co")))
+    group: Cel::String.new("acme.co"))
 
 # 3. or parse, check and evaluate
 begin
   return_value = env.evaluate(ast,
     name: Cel::String.new("/groups/acme.co/documents/secret-stuff"),
-    group: Cel::String.new("acme.co"))
+    group: Cel::String.new("acme.co")
+  )
 rescue Cel::Error => e
   STDERR.puts("evaluation error: #{e.message}")
   raise e
@@ -66,6 +67,20 @@ end
 puts return_value #=> true
 ```
 
+### types
+
+`cel-ruby` supports declaring the types of variables in the environment, which allows for expression checking:
+
+```ruby
+env = Cel::Environment.new(
+  first_name: :string, # shortcut for Cel::Types[:string]
+  middle_names: Cel::Types[:list, :string], # list of strings
+  last_name: :string
+)
+
+# you can use Cel::Types to access any type of primitive type, i.e. Cel::Types[:bytes]
+```
+
 ### protobuf
 
 If `google/protobuf` is available in the environment, `cel-ruby` will also be able to integrate with protobuf declarations in CEL expressions.

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

@@ -60,9 +60,15 @@ module Cel
 
         value = value.fetch(key, value)
 
-        value = Number.new(:double, value) if key == "number_value"
-
-        value
+        value = case key
+                when "null_value"
+                  Null.new if value.zero?
+                when "number_value"
+                  value = -value.operands.first if value.is_a?(Operation) && value.op == "-" && value.unary?
+                  Number.new(:double, value)
+                else
+                  value
+        end
       when "BoolValue", "google.protobuf.BoolValue"
         value = value.nil? ? Bool.new(false) : value[Identifier.new("value")]
       when "BytesValue", "google.protobuf.BytesValue"

data/lib/cel/ast/elements.rb

@@ -143,6 +143,7 @@ module Cel
     end
 
     def ==(other)
+      other = other.value if other.is_a?(Literal)
       @value == other || super
     end
 
@@ -176,6 +177,10 @@ module Cel
       end
     end
 
+    def to_ruby_type
+      @value
+    end
+
     private
 
     def check; end
@@ -190,7 +195,7 @@ module Cel
       OUT
     end
 
-    LOGICAL_OPERATORS.each do |op|
+    (LOGICAL_OPERATORS - %w[==]).each do |op|
       class_eval(<<-OUT, __FILE__, __LINE__ + 1)
         def #{op}(other)
           Bool.new(super)
@@ -204,13 +209,17 @@ module Cel
       super(:bool, value)
     end
 
-    LOGICAL_OPERATORS.each do |op|
+    (LOGICAL_OPERATORS - %w[==]).each do |op|
       class_eval(<<-OUT, __FILE__, __LINE__ + 1)
         def #{op}(other)
           Bool.new(super)
         end
       OUT
     end
+
+    def !
+      Bool.new(super)
+    end
   end
 
   class Null < Literal
@@ -242,14 +251,6 @@ module Cel
       Macro.matches(self, pattern)
     end
 
-    LOGICAL_OPERATORS.each do |op|
-      class_eval(<<-OUT, __FILE__, __LINE__ + 1)
-        def #{op}(other)
-          other.is_a?(Cel::Literal) ? Bool.new(super) : super
-        end
-      OUT
-    end
-
     %i[+ -].each do |op|
       class_eval(<<-OUT, __FILE__, __LINE__ + 1)
         def #{op}(other)
@@ -268,7 +269,7 @@ module Cel
       [self]
     end
 
-    LOGICAL_OPERATORS.each do |op|
+    (LOGICAL_OPERATORS - %w[==]).each do |op|
       class_eval(<<-OUT, __FILE__, __LINE__ + 1)
         def #{op}(other)
           Bool.new(super)
@@ -296,6 +297,10 @@ module Cel
     def to_ary
       [self]
     end
+
+    def to_ruby_type
+      value.map(&:to_ruby_type)
+    end
   end
 
   class Map < Literal
@@ -318,6 +323,10 @@ module Cel
       [self]
     end
 
+    def 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 })
     end
@@ -346,7 +355,7 @@ module Cel
   class Timestamp < Literal
     def initialize(value)
       value = case value
-              when String then Time.parse(value)
+              when ::String then Time.parse(value)
               when Numeric then Time.at(value)
               else value
       end
@@ -431,7 +440,7 @@ module Cel
   class Duration < Literal
     def initialize(value)
       value = case value
-              when String
+              when ::String
                 init_from_string(value)
               when Hash
                 seconds, nanos = value.values_at(:seconds, :nanos)
@@ -541,6 +550,10 @@ module Cel
       end
     end
 
+    def unary?
+      @operands.size == 1
+    end
+
     def to_s
       return "#{@op}#{@operands.first}" if @operands.size == 1
 

data/lib/cel/ast/types.rb

@@ -21,6 +21,8 @@ module Cel
     end
 
     def cast(value)
+      value = value.value if value.is_a?(Literal)
+
       case @type
       when :int
         Number.new(:int, Integer(value))
@@ -58,6 +60,14 @@ module Cel
     def get(idx)
       @type_list[idx]
     end
+
+    def ==(other)
+      other == :list || super
+    end
+
+    def cast(value)
+      List.new(value)
+    end
   end
 
   class MapType < Type
@@ -73,12 +83,45 @@ module Cel
       _, value = @type_map.find { |k, _| k == attrib.to_s }
       value
     end
+
+    def ==(other)
+      other == :map || super
+    end
+
+    def cast(value)
+      Map.new(value)
+    end
   end
 
   # Primitive Cel Types
 
   PRIMITIVE_TYPES = %i[int uint double bool string bytes list map timestamp duration null_type type].freeze
-  TYPES = PRIMITIVE_TYPES.to_h { |typ| [typ, Type.new(typ)] }
+  COLTYPES = %i[list map].freeze
+  TYPES = (PRIMITIVE_TYPES - COLTYPES).to_h { |typ| [typ, Type.new(typ)] }
   TYPES[:type] = Type.new(:type)
   TYPES[:any] = Type.new(:any)
+
+  module CollectionTypeFetch
+    def [](*args)
+      col_type, elem_type = args
+
+      return super unless COLTYPES.include?(col_type)
+
+      return super if args.size > 2
+
+      elem_type ||= :any
+
+      type = case col_type
+             when :list
+               ListType.new([])
+             when :map
+               MapType.new({})
+      end
+
+      type.element_type = super(*elem_type)
+      type
+    end
+  end
+
+  TYPES.singleton_class.prepend(CollectionTypeFetch)
 end

data/lib/cel/checker.rb

@@ -148,7 +148,7 @@ module Cel
         case func
         when :[]
           attribute = var_type.get(args)
-          unsupported_operation(funcall) unless attribute
+          return TYPES[:any] unless attribute
         when :all, :exists, :exists_one
           check_arity(funcall, args, 2)
           identifier, predicate = args
@@ -162,7 +162,7 @@ module Cel
           return TYPES[:bool]
         else
           attribute = var_type.get(func)
-          unsupported_operation(funcall) unless attribute
+          return TYPES[:any] unless attribute
         end
 
         call(attribute)
@@ -357,7 +357,7 @@ module Cel
 
       return unless typ
 
-      return convert(typ) if id_call_chain.empty?
+      convert(typ) if id_call_chain.empty?
     end
 
     def convert(typ)
@@ -381,7 +381,7 @@ module Cel
         end
       end
 
-      TYPES[type]
+      type && types.is_a?(Type) ? types : TYPES[type]
     end
 
     def check_arity(func, args, arity)

data/lib/cel/macro.rb

@@ -43,21 +43,24 @@ module Cel
     end
 
     def all(collection, identifier, predicate, context:)
-      collection.all? do |element, *|
+      return_value = collection.all? do |element, *|
         Program.new(context.merge(identifier.to_sym => element)).evaluate(predicate).value
       end
+      Bool.new(return_value)
     end
 
     def exists(collection, identifier, predicate, context:)
-      collection.any? do |element, *|
+      return_value = collection.any? do |element, *|
         Program.new(context.merge(identifier.to_sym => element)).evaluate(predicate).value
       end
+      Bool.new(return_value)
     end
 
     def exists_one(collection, identifier, predicate, context:)
-      collection.one? do |element, *|
+      return_value = collection.one? do |element, *|
         Program.new(context.merge(identifier.to_sym => element)).evaluate(predicate).value
       end
+      Bool.new(return_value)
     end
 
     def filter(collection, identifier, predicate, context:)

data/lib/cel/program.rb

@@ -57,20 +57,22 @@ module Cel
         ev_operand
       end
 
-      if values.size == 1 &&
+      if operation.unary? &&
          op != "!" # https://bugs.ruby-lang.org/issues/18246
         # unary operations
-        values.first.__send__(:"#{op}@")
+        Literal.to_cel_type(values.first.__send__(:"#{op}@"))
       elsif op == "&&"
-        Bool.new(values.all? { |x| true == x }) # rubocop:disable Style/YodaCondition
+        Bool.new(values.all? { |x| true == x.value }) # rubocop:disable Style/YodaCondition
       elsif op == "||"
-        Bool.new(values.any? { |x| true == x }) # rubocop:disable Style/YodaCondition
+        Bool.new(values.any? { |x| true == x.value }) # rubocop:disable Style/YodaCondition
       elsif op == "in"
         element, collection = values
         Bool.new(collection.include?(element))
       else
         op_value, *values = values
-        op_value.public_send(op, *values)
+        val = op_value.public_send(op, *values)
+
+        Literal.to_cel_type(val)
       end
     end
 
@@ -93,7 +95,7 @@ module Cel
       when String
         raise EvaluateError, "#{invoke} is not supported" unless String.method_defined?(func, false)
 
-        var.public_send(func, *args)
+        var.public_send(func, *args.map(&method(:call)))
       when Message
         # If e evaluates to a message and f is not declared in this message, the
         # runtime error no_such_field is raised.
@@ -120,7 +122,7 @@ module Cel
     end
 
     def evaluate_condition(condition)
-      call(condition.if) ? call(condition.then) : call(condition.else)
+      call(condition.if).value ? call(condition.then) : call(condition.else)
     end
 
     def evaluate_standard_func(funcall)
@@ -134,8 +136,10 @@ module Cel
 
         val.class
       # MACROS
-      when :has, :size
+      when :has
         Macro.__send__(func, *args)
+      when :size
+        Cel::Number.new(:int, Macro.__send__(func, *args))
       when :matches
         Macro.__send__(func, *args.map(&method(:call)))
       when :int, :uint, :string, :double, :bytes, :duration, :timestamp
@@ -153,7 +157,7 @@ module Cel
     def evaluate_custom_func(func, funcall)
       args = funcall.args
 
-      func.call(*args.map(&method(:call)))
+      func.call(*args.map(&method(:call)).map(&:to_ruby_type))
     end
   end
 end

data/lib/cel/version.rb

@@ -2,6 +2,6 @@
 
 module Cel
   module Ruby
-    VERSION = "0.2.0"
+    VERSION = "0.2.2"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cel
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.2
 platform: ruby
 authors:
 - Tiago Cardoso
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-17 00:00:00.000000000 Z
+date: 2023-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -88,7 +88,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: Pure Ruby implementation of Google Common Expression Language, https://opensource.google/projects/cel.