cel 0.3.1 → 0.4.1

data/lib/cel/extensions/string.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+module Cel
+  module Extensions
+    module String
+      module_function
+
+      def __check(funcall, checker:)
+        var = funcall.var
+        func = funcall.func
+        args = funcall.args
+
+        case func
+        when :quote
+          checker.check_arity(func, args, 1)
+          arg = checker.call(args.first)
+          return TYPES[:string] if checker.find_match_all_types(%i[string], arg)
+        when :indexOf, :lastIndexOf
+          if checker.call(var) == TYPES[:string]
+            checker.check_arity(func, args, 2, :>=)
+            arg, pos = args
+            arg = checker.call(arg)
+            if checker.find_match_all_types(%i[string], arg)
+              return TYPES[:int] if pos.nil?
+
+              pos = checker.call(pos)
+              return TYPES[:int] if checker.find_match_all_types(%i[int], pos)
+
+            end
+          end
+        when :split
+          if checker.call(var) == TYPES[:string]
+            checker.check_arity(func, args, 2, :>=)
+            arg, pos = args
+            arg = checker.call(arg)
+            if checker.find_match_all_types(%i[string], arg)
+              return TYPES[:list, :string] if pos.nil?
+
+              pos = checker.call(pos)
+              return TYPES[:list, :string] if checker.find_match_all_types(%i[int], pos)
+
+            end
+          end
+        when :substring
+          if checker.call(var) == TYPES[:string]
+            checker.check_arity(func, args, 2, :>=)
+            arg, pos = args
+            arg = checker.call(arg)
+            if checker.find_match_all_types(%i[int], arg)
+              return TYPES[:string] if pos.nil?
+
+              pos = checker.call(pos)
+              return TYPES[:string] if checker.find_match_all_types(%i[int], pos)
+
+            end
+          end
+        when :trim, :lowerAscii, :upperAscii, :reverse
+          if checker.call(var) == TYPES[:string]
+            checker.check_arity(func, args, 0)
+            return TYPES[:string]
+          end
+        when :format
+          if checker.call(var) == TYPES[:string]
+            checker.check_arity(func, args, 1)
+            arg = checker.call(args.first)
+            return TYPES[:string] if checker.find_match_all_types(%i[list], arg)
+          end
+        when :charAt
+          if checker.call(var) == TYPES[:string]
+            checker.check_arity(func, args, 1)
+            arg = checker.call(args.first)
+            return TYPES[:string] if checker.find_match_all_types(%i[int], arg)
+          end
+        when :replace
+          if checker.call(var) == TYPES[:string]
+            checker.check_arity(func, args, 2..3, :include?)
+            p, r, limit = args.map(&checker.method(:call))
+            if limit
+              return TYPES[:string] if checker.find_match_all_types(%i[string], [p, r]) &&
+                                       checker.find_match_all_types(%i[int], limit)
+            elsif checker.find_match_all_types(%i[string], [p, r])
+              return TYPES[:string]
+            end
+          end
+        when :join
+          if checker.call(var) == TYPES[:list, :string] || checker.call(var) == TYPES[:list, :any]
+            checker.check_arity(func, args, 1, :>=)
+            arg = checker.call(args.first)
+            return TYPES[:string] unless arg
+            return TYPES[:string] if checker.find_match_all_types(%i[string], arg)
+
+          end
+        end
+
+        checker.unsupported_operation(funcall)
+      end
+
+      def quote(str, program:)
+        value = program.call(str).value
+
+        # this should use String#dump, but this also replaces printable UTF8 characters
+
+        # replace quotes
+        value = value.gsub(/[\\'"\t\r\a\b\v\f\n]/) { |m| m.dump[1..-2] }
+
+        # replace invalid utf-8 chars
+        value = value.encode(Encoding::UTF_8, invalid: :replace)
+
+        # adding leading quotes if not quoted already
+        value = "\"#{value}\"" unless value.start_with?("\"") && value.end_with?("\"")
+
+        Cel::String.new(value)
+      end
+    end
+  end
+
+  class String
+    define_cel_method(:charAt) do |idx|
+      raise EvaluateError, "index out of range: #{idx}" unless idx.between?(0, @value.size)
+
+      String.new(@value[idx] || "")
+    end
+
+    define_cel_method(:indexOf) do |substr, *args|
+      idx, = args
+
+      raise EvaluateError, "index out of range: #{idx}" if idx && !idx.between?(0, @value.size)
+
+      Number.new(:int, @value.index(substr, *args) || -1)
+    end
+
+    define_cel_method(:lastIndexOf) do |substr, *args|
+      idx, = args
+
+      raise EvaluateError, "index out of range: #{idx}" if idx && !idx.between?(0, @value.size)
+
+      Number.new(:int, @value.rindex(substr, *args) || -1)
+    end
+
+    define_cel_method(:lowerAscii) do
+      String.new(@value.downcase(:ascii))
+    end
+
+    define_cel_method(:upperAscii) do
+      String.new(@value.upcase(:ascii))
+    end
+
+    UNICODE_WHITESPACE = /[ \t\r\n\u000C\u000D\u0020\u0085\u00A0\u1680\u2000-\u200A\u2028-\u2029\u202F\u205F\u3000]+/
+
+    define_cel_method(:trim) do
+      # why this? because String#split only takes null, horizontal tab, line feed, vertical tab, form feed,
+      # carriage return, space into account. We need the unicode definition of whitespace.
+      value = @value.gsub(/\A#{UNICODE_WHITESPACE}/o, "")
+                    .gsub(/#{UNICODE_WHITESPACE}\z/o, "")
+
+      String.new(value.strip)
+    end
+
+    define_cel_method(:reverse) do
+      String.new(@value.reverse)
+    end
+
+    define_cel_method(:split) do |pattern, *args|
+      raise NoOverloadError unless pattern.is_a?(String) && args.size.between?(0, 1)
+
+      limit, = args
+
+      raise NoOverloadError if limit && !limit.is_a?(Number)
+
+      if limit && limit.zero?
+        List.new([])
+      else
+        List.new(@value.split(pattern, *args))
+      end
+    end
+
+    define_cel_method(:substring) do |*args|
+      raise NoOverloadError unless args.size.between?(1, 2)
+
+      start_idx, end_idx = *args
+      end_idx ||= @value.size
+
+      raise EvaluateError, "index out of range: #{start_idx}" unless start_idx.between?(0, @value.size)
+
+      raise EvaluateError, "index out of range: #{end_idx}" if end_idx >= @value.size + 1
+
+      raise EvaluateError, "end index can't be higher than start index" if end_idx < start_idx
+
+      String.new(@value[start_idx..(end_idx - 1)])
+    end
+
+    define_cel_method(:replace) do |pattern, replacement, *args|
+      raise NoOverloadError unless args.size.between?(0, 1)
+
+      limit, = args
+
+      raise NoOverloadError unless pattern.is_a?(String) && replacement.is_a?(String)
+
+      pattern = pattern.value
+      replacement = replacement.value
+
+      value = if limit
+        raise NoOverloadError unless limit.is_a?(Number)
+
+        @value.gsub(pattern) do |m|
+          if limit.zero?
+            m
+          else
+            limit -= 1
+            replacement
+          end
+        end
+      else
+        @value.gsub(pattern, replacement)
+      end
+
+      String.new(value)
+    end
+
+    define_cel_method(:format) do |mappings|
+      String.new(format(@value, *mappings))
+    end
+  end
+
+  class List
+    define_cel_method(:join) do |*args|
+      String.new(super(*args))
+    end
+  end
+end

data/lib/cel/extensions.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "extensions/math"
+require_relative "extensions/string"
+require_relative "extensions/bind"
+require_relative "extensions/encoders"
+
+module Cel
+  EXTENSIONS = {
+    math: Extensions::Math,
+    strings: Extensions::String,
+    base64: Extensions::Encoders::Base64,
+    cel: Extensions::Bind,
+  }.freeze
+end

data/lib/cel/parser.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 #
 # DO NOT MODIFY!!!!
 # This file is automatically generated by Racc 1.8.1
@@ -32,7 +33,7 @@ else
   }
 end.freeze
 
-OPERATORS_RE = Regexp.union(*OPERATORS.keys)
+OPERATORS_RE = Regexp.union(*OPERATORS.keys).freeze
 
 BACKSLASH = "\\\\" # Must be literally two backslashes for proper interpolation
 DIGIT     = "[0-9]"
@@ -46,24 +47,24 @@ ESC_BYTE_SEQ = "#{BACKSLASH}[xX]#{HEXDIGIT}{2}"
 ESC_UNI_SEQ  = "#{BACKSLASH}u#{HEXDIGIT}{4}|#{BACKSLASH}U#{HEXDIGIT}{8}"
 ESC_SEQ      = "#{ESC_CHAR_SEQ}|#{ESC_BYTE_SEQ}|#{ESC_UNI_SEQ}|#{ESC_OCT_SEQ}"
 
-WHITESPACE_REGEX = /[ \t\r\n\u000C]+/
-COMMENT_REGEX = %r{//[^\n]*}
+WHITESPACE_REGEX = /[ \t\r\n\u000C]+/.freeze
+COMMENT_REGEX = %r{//[^\n]*}.freeze
 
 NUM_FLOAT_REGEX = Regexp.union(
   /#{DIGIT}+\.#{DIGIT}+#{EXPONENT}?/,
   /#{DIGIT}+#{EXPONENT}/,
   /\.#{DIGIT}+#{EXPONENT}?/
-)
+).freeze
 
 NUM_INT_REGEX = Regexp.union(
   /0x(?<hex>#{HEXDIGIT}+)/,
   /(?<dec>#{DIGIT}+)/
-)
+).freeze
 
 NUM_UINT_REGEX = Regexp.union(
   /0x(?<hex>#{HEXDIGIT}+)[uU]/,
   /(?<dec>#{DIGIT}+)[uU]/
-)
+).freeze
 
 STRING_REGEX = Regexp.union(
   /"""(?<str>(?:#{ESC_SEQ}|[^\\])*)"""/,
@@ -74,20 +75,20 @@ STRING_REGEX = Regexp.union(
   /#{RAW}'''(?<str>.*?)'''/m,
   /#{RAW}"(?<str>[^"\n\r]*)"/,
   /#{RAW}'(?<str>[^'\n\r]*)'/,
-)
+).freeze
 
-QUOTED_MAP_FIELD_REGEX = /`/
+QUOTED_MAP_FIELD_REGEX = /`/.freeze
 
-BYTES_REGEX = /[bB]#{STRING_REGEX}/
+BYTES_REGEX = /[bB]#{STRING_REGEX}/.freeze
 
 RESERVED = %W[
 as break const continue else
 for function if import let
 loop package namespace return
 var void while
-].freeze
+].each(&:freeze).freeze
 
-IDENTIFIER_REGEX = /[_a-zA-Z][_a-zA-Z0-9]*/
+IDENTIFIER_REGEX = /[_a-zA-Z][_a-zA-Z0-9]*/.freeze
 
 def initialize(
   package = nil,
@@ -404,9 +405,9 @@ def math_operation(op, operands)
       when  "*", "/", "%"
         depth = lhs.depth + 1
       end
-    when "+", "+"
+    when "+"
       case lhs.op
-      when  "+", "+"
+      when  "+"
         depth = lhs.depth + 1
       end
     end

data/lib/cel/program.rb

@@ -2,7 +2,7 @@
 
 module Cel
   class Program
-    attr_reader :context
+    attr_reader :environment, :context
 
     def initialize(context, environment)
       @context = context
@@ -55,7 +55,11 @@ module Cel
     end
 
     def evaluate_identifier(identifier)
-      if Cel::PRIMITIVE_TYPES.include?(identifier.to_sym)
+      id_sym = identifier.to_sym
+
+      if Cel::EXTENSIONS.key?(id_sym)
+        Cel::EXTENSIONS[id_sym]
+      elsif Cel::PRIMITIVE_TYPES.include?(id_sym)
         TYPES[identifier.to_sym]
       else
         val, func = @context.lookup(identifier)
@@ -179,12 +183,12 @@ module Cel
           t.is_a?(Class) && t < Protobuf.base_class ? 1 : 0
         end
 
-        val = lhs.public_send(op, rhs)
+        val = lhs.cel_send(op, rhs)
 
         Literal.to_cel_type(val)
       else
         op_value, *values = operands.map(&method(:call))
-        val = op_value.public_send(op, *values)
+        val = op_value.cel_send(op, *values)
 
         Literal.to_cel_type(val)
       end
@@ -193,7 +197,8 @@ module Cel
     def evaluate_invoke(invoke, var = invoke.var)
       return evaluate_standard_func(invoke) unless var
 
-      func = invoke.func
+      func = call(invoke.func) || invoke.func
+
       args = invoke.args
 
       var =
@@ -225,7 +230,7 @@ module Cel
       when String
         raise EvaluateError, "#{invoke} is not supported" unless String.method_defined?(func, false)
 
-        var.public_send(func, *args.map(&method(:call)))
+        var.cel_send(func, *args.map(&method(:call)))
       when Map
         return Macro.__send__(func, var, *args, program: self) if !Module.respond_to?(func) && Macro.respond_to?(func)
 
@@ -234,9 +239,13 @@ module Cel
         # to the expression x['foo'] when x evaluates to a map).
 
         if args
-          var.public_send(func, *args)
+          var.cel_send(func, *args)
         else
+          # this should only be a data accessor, calling functions is disallowed
+          raise EvaluateError, "#{invoke} is not supported" unless var.key?(func)
+
           begin
+            # TODO: use explicit lookup method to circumvent the need to method_missing it
             var.public_send(func)
           rescue NoMethodError
             raise NoSuchKeyError.new(var, func)
@@ -250,8 +259,8 @@ module Cel
         # to the expression x['foo'] when x evaluates to a map).
 
         args ?
-        var.public_send(func, *Array(args).map(&method(:call))) :
-        var.public_send(func)
+        var.cel_send(func, *Array(args).map(&method(:call))) :
+        var.cel_send(func)
       when Timestamp, Duration
         raise EvaluateError, "#{invoke} is not supported" unless var.class.method_defined?(func, false)
 
@@ -262,7 +271,7 @@ module Cel
         # runtime error no_such_field is raised.
         raise NoSuchFieldError.new(var, func) unless var.respond_to?(func)
 
-        var.public_send(func, *args)
+        var.cel_send(func, *args)
       when Literal
         # eliminate ruby API from the lookup
         raise NoMatchingOverloadError.new(var, func) if Literal.instance_methods.include?(func)
@@ -271,7 +280,7 @@ module Cel
         # runtime error no_such_field is raised.
         raise NoSuchFieldError.new(var, func) unless var.respond_to?(func)
 
-        var.public_send(func)
+        var.cel_send(func)
       when Protobuf.base_class
         # eliminate protobuf API from the lookup
         raise NoMatchingOverloadError.new(var, func) if Protobuf.base_class.instance_methods.include?(func)
@@ -283,8 +292,10 @@ module Cel
         value = Protobuf.lookup(var, func)
 
         Literal.to_cel_type(value)
-      else
-        if var.is_a?(Module) && var.const_defined?(func)
+      when Module
+        if var.respond_to?(func) && !Module.respond_to?(func)
+          return var.__send__(func, *args, program: self)
+        elsif var.const_defined?(func) && !Module.const_defined?(func)
           # this block assumes a message based call on a protobuf message, either to a
           # subclass/namespace (Foo.Bar), or an enum (Foo.BAR)
           # protobuf accessing enum module
@@ -313,8 +324,12 @@ module Cel
           return Literal.to_cel_type(value)
         end
 
+        raise EvaluateError, "#{invoke} is not supported"
+      else
         raise EvaluateError, "#{invoke} is not supported"
       end
+    rescue NoCelMethodError
+      raise EvaluateError, "#{invoke} is not supported"
     end
 
     def evaluate_condition(condition)

data/lib/cel/version.rb

@@ -2,6 +2,6 @@
 
 module Cel
   module Ruby
-    VERSION = "0.3.1"
+    VERSION = "0.4.1"
   end
 end

data/lib/cel.rb

@@ -1,17 +1,19 @@
 # frozen_string_literal: true
 
 require "bigdecimal"
-require "cel/version"
-require "cel/errors"
-require "cel/ast/types"
-require "cel/ast/elements"
-require "cel/parser"
-require "cel/macro"
-require "cel/context"
-require "cel/encoder" if RUBY_VERSION >= "3.1.0"
-require "cel/checker"
-require "cel/program"
-require "cel/environment"
+require_relative "cel/version"
+require_relative "cel/errors"
+require_relative "cel/ast/cel_methods"
+require_relative "cel/ast/types"
+require_relative "cel/ast/elements"
+require_relative "cel/extensions"
+require_relative "cel/parser"
+require_relative "cel/macro"
+require_relative "cel/context"
+require_relative "cel/encoder" if RUBY_VERSION >= "3.1.0"
+require_relative "cel/checker"
+require_relative "cel/program"
+require_relative "cel/environment"
 
 begin
   require "tzinfo"
@@ -19,7 +21,7 @@ rescue LoadError # rubocop:disable Lint/SuppressedException
 end
 
 begin
-  require "cel/ast/elements/protobuf"
+  require_relative "cel/ast/elements/protobuf"
 rescue LoadError => e
   puts e
   module Cel
@@ -252,4 +254,17 @@ module Cel
       /[[:upper:]]/.match?(typ[0]) ? typ : typ.capitalize
     end.join("::")
   end
+
+  # freeze constants to make cel ractor-friendly
+  Number.freeze
+  Bool.freeze
+  Null.freeze
+  String.freeze
+  Bytes.freeze
+  List.freeze
+  Map.freeze
+  Timestamp.freeze
+  Duration.freeze
+  Type.freeze
+  TYPES.each_value(&:freeze).freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cel
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.1
 platform: ruby
 authors:
 - Tiago Cardoso
@@ -51,6 +51,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: tzinfo-data
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  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
@@ -65,14 +79,37 @@ files:
 - LICENSE.txt
 - README.md
 - lib/cel.rb
+- lib/cel/ast/cel_methods.rb
 - lib/cel/ast/elements.rb
+- lib/cel/ast/elements/bool.rb
+- lib/cel/ast/elements/bytes.rb
+- lib/cel/ast/elements/condition.rb
+- lib/cel/ast/elements/duration.rb
+- lib/cel/ast/elements/function.rb
+- lib/cel/ast/elements/group.rb
+- lib/cel/ast/elements/identifier.rb
+- lib/cel/ast/elements/invoke.rb
+- lib/cel/ast/elements/list.rb
+- lib/cel/ast/elements/literal.rb
+- lib/cel/ast/elements/map.rb
+- lib/cel/ast/elements/message.rb
+- lib/cel/ast/elements/null.rb
+- lib/cel/ast/elements/number.rb
+- lib/cel/ast/elements/operation.rb
 - lib/cel/ast/elements/protobuf.rb
+- lib/cel/ast/elements/string.rb
+- lib/cel/ast/elements/timestamp.rb
 - lib/cel/ast/types.rb
 - lib/cel/checker.rb
 - lib/cel/context.rb
 - lib/cel/encoder.rb
 - lib/cel/environment.rb
 - lib/cel/errors.rb
+- lib/cel/extensions.rb
+- lib/cel/extensions/bind.rb
+- lib/cel/extensions/encoders.rb
+- lib/cel/extensions/math.rb
+- lib/cel/extensions/string.rb
 - lib/cel/macro.rb
 - lib/cel/parser.rb
 - lib/cel/program.rb
@@ -99,7 +136,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Pure Ruby implementation of Google Common Expression Language, https://opensource.google/projects/cel.
 test_files: []