cel 0.1.2 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d81d1083943f4f6d5bc415963b01c2f9be140074ae63493601b1613422fe29dd
-  data.tar.gz: 4ea24204656323c4bc8313293e64186973f28f84c4878b94804c5cb32b0cc047
+  metadata.gz: 54879dbe064eebebe6597acd098c6b10b8376f7b2333d2f822ca02c24a0815bb
+  data.tar.gz: 95e2fed808711b64aedc8ed6aff2f8bc8eb9e5f9562907c0d794df186a35f035
 SHA512:
-  metadata.gz: 22d25e42ca7b497e2dccbaf239a649a1a66af83001d9580faabf511cc71d8db76eca1d9ededd0fbfb3ba9bde25834750809022983364b6591bf8da1c99c6673c
-  data.tar.gz: 4526e92a70b428e512654fccc94adbe9dd4a0a32534aa1792b5633a72e55cc95e67c4ef99b5ab5b272cf822e7a7175ef28e73ada9f2e61ca5613699d715a78ca
+  metadata.gz: 59349c9633015f0a63c297573e30e33d459de63f1af8ff032f808b045c069716c19142e2208f653864bd4a2363009dd7cb54c8feed3160e6c792c260853cc79f
+  data.tar.gz: 2070807c5f7a01217117d96373372e111697727069b915a665acfc6fd2a58c6ff4adfb4fd747522585d7b03733cfb77ee2b7b726b6c36edb3f6d828a93ffed10

data/CHANGELOG.md

@@ -1,5 +1,90 @@
 ## [Unreleased]
 
+## [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
+
+#### Timestamp/Duration types
+
+Implementing `Cel::Timestamp` and `Cel::Duration` CEL types, along with support for functions for those types (such as `getDate`, `getDayOfYear`).
+
+```ruby
+Cel::Environment.new.evaluate("timestamp('2022-12-25T00:00:00Z').getDate()") #=> 25
+Cel::Environment.new.evaluate("duration('3600s10ms').getHours()") #=> 1
+```
+
+#### Protobuf-to-CEL conversion
+
+Support for auto-conversion of certain protobuf messages in the `google.protobf` package to CEL types.
+
+https://github.com/google/cel-spec/blob/master/doc/langdef.md#dynamic-values
+
+```ruby
+Cel::Environment.new.evaluate("google.protobuf.BoolValue{value: true}") #=> true
+Cel::Environment.new.evaluate("google.protobuf.Value{string_value: 'bla'}") #=> "bla"
+```
+
+#### Custom Functions
+
+`cel` supports the definition of custom functions in the environment, to be used in expressions:
+
+```ruby
+Cel::Environment.new(foo: Cel::Function(:int, :int, return_type: :int) { |a, b| a + b }).evaluate("foo(2, 2)") #=> 4
+```
+
+### Expression encoding/decoding
+
+Expressions can now be encoded and decoded, to improve storage / reparsing to and from JSON, for example.
+
+```ruby
+enc = Cel::Environment.new.encode("1 == 2") #=> ["op", ...
+store_to_db(JSON.dump(enc))
+
+# then, somewhere else
+env = Cel::Environment.new
+ast = env.decode(JSON.parse(read_from_db))
+env.evaluate(ast) #=> 3
+```
+
+**NOTE**: This feature is only available in ruby 3.1 .
+
+### Bugfixes
+
+* fixed parser bug disallowing identifiers composed "true" or "false" (such as "true_name").
+
 ## [0.1.2] - 2022-11-10
 
 point release to update links in rubygems.

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,12 +67,26 @@ 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.
 
 ```ruby
-# gem "google-protobuf" in your Gemfile
+require "google/protobuf"
 require "cel"
 
 env = Cel::Environment.new
@@ -79,6 +94,18 @@ env = Cel::Environment.new
 env.evaluate("google.protobuf.Duration{seconds: 123}.seconds == 123") #=> true
 ```
 
+### Custom functions
+
+`cel-ruby` allows you to define custom functions to be used insde CEL expressions. While we **strongly** recommend usage of `Cel::Function` for defining them (due to the ability of them being used for checking), the only requirement is that the function object responds to `.call`:
+
+```ruby
+env = environment(foo: Cel::Function(:int, :int, return_type: :int) { |a, b|  a + b})
+env.evaluate("foo(2, 2)") #=> 4
+
+# this is also possible, just not as type-safe
+env2 = environment(foo: -> (a, b) { a + b})
+env2.evaluate("foo(2, 2)") #=> 4
+```
 
 ## Supported Rubies
 

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

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require "google/protobuf/struct_pb"
+require "google/protobuf/wrappers_pb"
+require "google/protobuf/any_pb"
+require "google/protobuf/well_known_types"
+
+module Cel
+  module Protobuf
+    module_function
+
+    def convert_from_protobuf(msg)
+      case msg
+      when Google::Protobuf::Any
+
+        any.unpack(type_msg).to_ruby
+      when Google::Protobuf::ListValue
+        msg.to_a
+      when Google::Protobuf::Struct
+        msg.to_h
+      when Google::Protobuf::Value
+        msg.to_ruby
+      when Google::Protobuf::BoolValue,
+           Google::Protobuf::BytesValue,
+           Google::Protobuf::DoubleValue,
+           Google::Protobuf::FloatValue,
+           Google::Protobuf::Int32Value,
+           Google::Protobuf::Int64Value,
+           Google::Protobuf::UInt32Value,
+           Google::Protobuf::UInt64Value,
+           Google::Protobuf::NullValue,
+           Google::Protobuf::StringValue
+        msg.value
+      when Google::Protobuf::Timestamp
+        msg.to_time
+      when Google::Protobuf::Duration
+        Cel::Duration.new(seconds: msg.seconds, nanos: msg.nanos)
+      else
+        raise Error, "#{msg.class}: protobuf to cel unsupported"
+      end
+    end
+
+    def convert_from_type(type, value)
+      case type
+      when "Any", "google.protobuf.Any"
+        type_url = value[Identifier.new("type_url")].value
+        _, type_msg = type_url.split("/", 2)
+        type_msg = const_get(type_msg.split(".").map(&:capitalize).join("::"))
+        encoded_msg = value[Identifier.new("value")].value.pack("C*")
+        any = Google::Protobuf::Any.new(type_url: type_url, value: encoded_msg)
+        value = Literal.to_cel_type(any.unpack(type_msg).to_ruby)
+      when "ListValue", "google.protobuf.ListValue"
+        value = value.nil? ? List.new([]) : value[Identifier.new("values")]
+      when "Struct", "google.protobuf.Struct"
+        value = value.nil? ? Map.new({}) : value[Identifier.new("fields")]
+      when "Value", "google.protobuf.Value"
+        return Null.new if value.nil?
+
+        key = value.keys.first
+
+        value = value.fetch(key, value)
+
+        value = Number.new(:double, value) if key == "number_value"
+
+        value
+      when "BoolValue", "google.protobuf.BoolValue"
+        value = value.nil? ? Bool.new(false) : value[Identifier.new("value")]
+      when "BytesValue", "google.protobuf.BytesValue"
+        value = value[Identifier.new("value")]
+      when "DoubleValue", "google.protobuf.DoubleValue",
+           "FloatValue", "google.protobuf.FloatValue"
+        value = value.nil? ? Number.new(:double, 0.0) : value[Identifier.new("value")]
+        value.type = TYPES[:double]
+      when "Int32Value", "google.protobuf.Int32Value",
+           "Int64Value", "google.protobuf.Int64Value"
+        value = value.nil? ? Number.new(:int, 0) : value[Identifier.new("value")]
+      when "Uint32Value", "google.protobuf.UInt32Value",
+           "Uint64Value", "google.protobuf.UInt64Value"
+        value = value.nil? ? Number.new(:uint, 0) : value[Identifier.new("value")]
+      when "NullValue", "google.protobuf.NullValue"
+        value = Null.new
+      when "StringValue", "google.protobuf.StringValue"
+        value = value.nil? ? String.new(+"") : value[Identifier.new("value")]
+      when "Timestamp", "google.protobuf.Timestamp"
+        seconds = value.fetch(Identifier.new("seconds"), 0)
+        nanos = value.fetch(Identifier.new("nanos"), 0)
+        value = Timestamp.new(Time.at(seconds, nanos, :nanosecond))
+      when "Duration", "google.protobuf.Duration"
+        seconds = value.fetch(Identifier.new("seconds"), 0)
+        nanos = value.fetch(Identifier.new("nanos"), 0)
+        value = Duration.new(seconds: seconds, nanos: nanos)
+      end
+      value
+    end
+
+    def try_invoke_from(var, func, args)
+      case var
+      when "Any", "google.protobuf.Any",
+        "ListValue", "google.protobuf.ListValue",
+        "Struct", "google.protobuf.Struct",
+        "Value", "google.protobuf.Value",
+        "BoolValue", "google.protobuf.BoolValue",
+        "BytesValue", "google.protobuf.BytesValue",
+        "DoubleValue", "google.protobuf.DoubleValue",
+        "FloatValue", "google.protobuf.FloatValue",
+        "Int32Value", "google.protobuf.Int32Value",
+        "Int64Value", "google.protobuf.Int64Value",
+        "Uint32Value", "google.protobuf.Uint32Value",
+        "Uint64Value", "google.protobuf.Uint64Value",
+        "NullValue", "google.protobuf.NullValue",
+        "StringValue", "google.protobuf.StringValue",
+        "Timestamp", "google.protobuf.Timestamp",
+        "Duration", "google.protobuf.Duration"
+        protoclass = var.split(".").last
+        protoclass = Google::Protobuf.const_get(protoclass)
+
+        value = if args.nil? && protoclass.constants.include?(func.to_sym)
+          protoclass.const_get(func)
+        else
+          protoclass.__send__(func, *args)
+        end
+
+        Literal.to_cel_type(value)
+      end
+    end
+  end
+end

data/lib/cel/ast/elements.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
+require "time"
 require "delegate"
+require_relative "elements/protobuf"
 
 module Cel
   LOGICAL_OPERATORS = %w[< <= >= > == != in].freeze
@@ -20,11 +22,22 @@ module Cel
     def ==(other)
       super || other.to_s == @id.to_s
     end
+
+    def to_s
+      @id.to_s
+    end
   end
 
   class Message < SimpleDelegator
     attr_reader :type, :struct
 
+    def self.new(type, struct)
+      value = convert_from_type(type, struct)
+      return value if value.is_a?(Null) || value != struct
+
+      super
+    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|
@@ -36,11 +49,32 @@ module Cel
     def field?(key)
       !@type.get(key).nil?
     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]
+      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),
+        ]
+      end
+    end
   end
 
   class Invoke
     attr_reader :var, :func, :args
 
+    def self.new(func:, var: nil, args: nil)
+      Protobuf.try_invoke_from(var, func, args) || super
+    end
+
     def initialize(func:, var: nil, args: nil)
       @var = var
       @func = func.to_sym
@@ -48,10 +82,14 @@ module Cel
     end
 
     def ==(other)
-      super || (
-        other.respond_to?(:to_ary) &&
+      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
@@ -67,6 +105,33 @@ module Cel
     end
   end
 
+  class Function
+    attr_reader :types, :type
+
+    def initialize(*types, 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
+    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
 
@@ -82,6 +147,8 @@ module Cel
     end
 
     def self.to_cel_type(val)
+      val = Protobuf.convert_from_protobuf(val) if val.is_a?(Google::Protobuf::MessageExts)
+
       case val
       when Literal, Identifier
         val
@@ -102,11 +169,17 @@ module Cel
         Bool.new(val)
       when nil
         Null.new
+      when Time
+        Timestamp.new(val)
       else
         raise BindingError, "can't convert #{val} to CEL type"
       end
     end
 
+    def to_ruby_type
+      @value
+    end
+
     private
 
     def check; end
@@ -227,6 +300,10 @@ module Cel
     def to_ary
       [self]
     end
+
+    def to_ruby_type
+      value.map(&:to_ruby_type)
+    end
   end
 
   class Map < Literal
@@ -249,6 +326,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
@@ -274,12 +355,178 @@ module Cel
     end
   end
 
+  class Timestamp < Literal
+    def initialize(value)
+      value = case value
+              when String then Time.parse(value)
+              when Numeric then Time.at(value)
+              else value
+      end
+      super(:timestamp, value)
+    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.new(super) : super
+        end
+      OUT
+    end
+
+    # Cel Functions
+
+    def getDate(tz = nil)
+      to_local_time(tz).day
+    end
+
+    def getDayOfMonth(tz = nil)
+      getDate(tz) - 1
+    end
+
+    def getDayOfWeek(tz = nil)
+      to_local_time(tz).wday
+    end
+
+    def getDayOfYear(tz = nil)
+      to_local_time(tz).yday - 1
+    end
+
+    def getMonth(tz = nil)
+      to_local_time(tz).month - 1
+    end
+
+    def getFullYear(tz = nil)
+      to_local_time(tz).year
+    end
+
+    def getHours(tz = nil)
+      to_local_time(tz).hour
+    end
+
+    def getMinutes(tz = nil)
+      to_local_time(tz).min
+    end
+
+    def getSeconds(tz = nil)
+      to_local_time(tz).sec
+    end
+
+    def getMilliseconds(tz = nil)
+      to_local_time(tz).nsec / 1_000_000
+    end
+
+    private
+
+    def to_local_time(tz = nil)
+      time = @value
+      if tz
+        tz = TZInfo::Timezone.get(tz) unless tz.match?(/\A[+-]\d{2,}:\d{2,}\z/)
+        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
+      super(:duration, value)
+    end
+
+    LOGICAL_OPERATORS.each do |op|
+      class_eval(<<-OUT, __FILE__, __LINE__ + 1)
+        def #{op}(other)
+          case other
+          when Cel::Literal
+            Bool.new(super)
+          when Numeric
+            @value == other
+
+          else
+            super
+          end
+        end
+      OUT
+    end
+
+    # Cel Functions
+
+    def getHours
+      (getMinutes / 60).to_i
+    end
+
+    def getMinutes
+      (getSeconds / 60).to_i
+    end
+
+    def getSeconds
+      @value.divmod(1).first
+    end
+
+    def getMilliseconds
+      (@value.divmod(1).last * 1000).round
+    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
+      seconds + (nanos / 1_000_000_000.0)
+    end
+  end
+
   class Group
     attr_reader :value
 
     def initialize(value)
       @value = value
     end
+
+    def ==(other)
+      other.is_a?(Group) && @value == other.value
+    end
   end
 
   class Operation
@@ -294,10 +541,13 @@ module Cel
     end
 
     def ==(other)
-      if other.is_a?(Array)
+      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
@@ -318,5 +568,9 @@ module Cel
       @then = then_
       @else = else_
     end
+
+    def ==(other)
+      other.is_a?(Condition) && @if == other.if && @then == other.then && @else == other.else
+    end
   end
 end