cel 0.2.3 → 0.3.0

data/lib/cel/environment.rb

@@ -2,10 +2,33 @@
 
 module Cel
   class Environment
-    def initialize(declarations = nil)
+    attr_reader :declarations, :package
+
+    def initialize(declarations: nil, container: nil, disable_check: false)
+      @disable_check = disable_check
       @declarations = declarations
-      @parser = Parser.new
-      @checker = Checker.new(@declarations)
+      @container = container
+      @package = nil
+      @checker = Checker.new(self)
+
+      if container && !container.empty?
+
+        module_dir = container.split(".")
+
+        Dir[File.join(*module_dir, "*.rb")].each do |path|
+          require path
+        end
+
+        proto_module_name = container.split(".").map do |sub|
+          sub.capitalize.gsub(/_([a-z\d]*)/) do
+            ::Regexp.last_match(1).capitalize
+          end
+        end.join("::")
+
+        @package = Object.const_get(proto_module_name) if Object.const_defined?(proto_module_name)
+      end
+
+      @parser = Parser.new(package)
     end
 
     def compile(expr)
@@ -20,7 +43,7 @@ module Cel
 
     def decode(encoded_expr)
       ast = Encoder.decode(encoded_expr)
-      @checker.check(ast)
+      @checker.check(ast) unless @disable_check
       ast
     end
 
@@ -31,15 +54,36 @@ module Cel
 
     def program(expr)
       expr = @parser.parse(expr) if expr.is_a?(::String)
-      @checker.check(expr)
-      Runner.new(@declarations, expr)
+      @checker.check(expr) unless @disable_check
+      Runner.new(self, expr)
     end
 
     def evaluate(expr, bindings = nil)
-      context = Context.new(@declarations, bindings)
+      declarations, bindings = process_bindings(bindings)
+      context = Context.new(declarations, bindings)
       expr = @parser.parse(expr) if expr.is_a?(::String)
-      @checker.check(expr)
-      Program.new(context).evaluate(expr)
+      @checker.check(expr) unless @disable_check
+      Program.new(context, self).evaluate(expr)
+    end
+
+    def process_bindings(bindings)
+      return [@declarations, bindings] unless @container && @package.nil?
+
+      declarations = @declarations.dup
+      bindings = bindings.dup
+
+      prefix = "#{@container}."
+
+      cbinding_keys = bindings.keys.select { |k| k.start_with?(prefix) }
+
+      cbinding_keys.each do |k|
+        cbinding = k.to_s.delete_prefix(prefix).to_sym
+
+        bindings[cbinding] = bindings.delete(k)
+        declarations[cbinding] = declarations.delete(k) if declarations.key?(k)
+      end
+
+      [declarations, bindings]
     end
 
     private
@@ -48,14 +92,15 @@ module Cel
   end
 
   class Runner
-    def initialize(declarations, ast)
-      @declarations = declarations
+    def initialize(environment, ast)
+      @environment = environment
       @ast = ast
     end
 
     def evaluate(bindings = nil)
-      context = Context.new(@declarations, bindings)
-      Program.new(context).evaluate(@ast)
+      declarations, bindings = @environment.process_bindings(bindings)
+      context = Context.new(declarations, bindings)
+      Program.new(context, @environment).evaluate(@ast)
     end
   end
 end

data/lib/cel/errors.rb

@@ -9,6 +9,24 @@ module Cel
 
   class EvaluateError < Error; end
 
+  class InvalidArgumentError < EvaluateError
+    attr_reader :code
+
+    def initialize(key)
+      super("invalid argument #{key}")
+      @code = :invalid_argument
+    end
+  end
+
+  class NoSuchKeyError < EvaluateError
+    attr_reader :code
+
+    def initialize(var, attrib)
+      super("No such key: #{attrib} in #{var}")
+      @code = :no_such_key
+    end
+  end
+
   class NoSuchFieldError < EvaluateError
     attr_reader :code
 
@@ -18,7 +36,7 @@ module Cel
     end
   end
 
-  class NoMatchingOverloadError < CheckError
+  class NoMatchingOverloadError < EvaluateError
     attr_reader :code
 
     def initialize(op)

data/lib/cel/macro.rb

@@ -12,66 +12,131 @@ module Cel
     #     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)
+    def has(invoke, program:)
       var = invoke.var
       func = invoke.func
 
       case var
       when Message
+        var = program.evaluate(var)
         # 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)
+        raise NoSuchFieldError.new(var, func) unless var.respond_to?(func)
 
-        Bool.new(!var.public_send(func).nil?)
+        value = var.public_send(func)
+        field = var.class.descriptor.lookup(func.to_s)
+
+        if field.label == :repeated
+          # If f is a repeated field or map field, has(e.f) indicates whether the field is non-empty.
+          Bool.cast(field.get(var).size.positive?)
+        elsif field.has_presence?
+          # If f is a oneof or singular message field, has(e.f) indicates whether the field is set.
+          Bool.cast(field.has?(var))
+        else
+          # 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).
+          value = field.get(var)
+          case field.type
+          when :bool
+            Bool.cast(value == true)
+          when :string, :bytes
+            Bool.cast(!value.empty?)
+          when :enum
+            Bool.cast(value != field.default)
+          else
+            Bool.cast(value != 0)
+          end
+        end
       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))
+        Bool.cast(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
+    def size(literal, program: nil)
+      literal = program.evaluate(literal) if program
+      Cel::Number.new(:int, program.evaluate(literal).size)
     end
 
-    def matches(string, pattern)
+    def matches(string, pattern, program: nil)
+      pattern = program.evaluate(pattern) if program
       pattern = Regexp.new(pattern)
-      Bool.new(pattern.match?(string))
+      Bool.cast(pattern.match?(string))
     end
 
-    def all(collection, identifier, predicate, context:)
-      return_value = collection.all? do |element, *|
-        Program.new(context.merge(identifier.to_sym => element)).evaluate(predicate).value
+    def all(collection, *identifiers, predicate, program:)
+      identifiers = identifiers.map(&:to_sym)
+      error = nil
+
+      return_value = with_context(collection, identifiers).map do |context|
+        program.with_extra_context(context).evaluate(predicate).value
+      rescue StandardError => e
+        error = e
       end
-      Bool.new(return_value)
+
+      has_false = return_value.include?(false)
+
+      # if any predicate evaluates to false, the macro evaluates to false, ignoring any errors
+      # from other predicates.
+      raise error if error && !has_false
+
+      Bool.cast(!has_false)
     end
 
-    def exists(collection, identifier, predicate, context:)
-      return_value = collection.any? do |element, *|
-        Program.new(context.merge(identifier.to_sym => element)).evaluate(predicate).value
+    def exists(collection, *identifiers, predicate, program:)
+      identifiers = identifiers.map(&:to_sym)
+
+      return_value = with_context(collection, identifiers).any? do |context|
+        program.with_extra_context(context).evaluate(predicate).value
       end
-      Bool.new(return_value)
+      Bool.cast(return_value)
     end
 
-    def exists_one(collection, identifier, predicate, context:)
-      return_value = collection.one? do |element, *|
-        Program.new(context.merge(identifier.to_sym => element)).evaluate(predicate).value
+    def exists_one(collection, *identifiers, predicate, program:)
+      identifiers = identifiers.map(&:to_sym)
+
+      # This macro does not short-circuit in order to remain consistent with logical operators
+      # being the only operators which can absorb errors within CEL.
+      return_value = with_context(collection, identifiers).select do |context|
+        program.with_extra_context(context).evaluate(predicate).value
       end
-      Bool.new(return_value)
+      Bool.cast(return_value.size == 1)
     end
 
-    def filter(collection, identifier, predicate, context:)
-      collection.select do |element, *|
-        Program.new(context.merge(identifier.to_sym => element)).evaluate(predicate).value
+    def filter(collection, *identifiers, predicate, program:)
+      identifiers = identifiers.map(&:to_sym)
+
+      return_value = with_context(collection, identifiers).filter_map do |context|
+        next unless program.with_extra_context(context).evaluate(predicate).value
+
+        context.values.last
       end
+      List.new(return_value)
     end
 
-    def map(collection, identifier, predicate, context:)
-      collection.map do |element, *|
-        Program.new(context.merge(identifier.to_sym => element)).evaluate(predicate)
+    def map(collection, *identifiers, predicate, program:)
+      identifiers = identifiers.map(&:to_sym)
+
+      return_value = with_context(collection, identifiers).map do |context|
+        program.with_extra_context(context).evaluate(predicate)
+      end
+      List.new(return_value)
+    end
+
+    def with_context(collection, identifiers)
+      case collection
+      when Map
+        raise EvaluateError, "can only support 2 identifiers" unless identifiers.size <= 2
+      else
+        collection = collection.each_cons(identifiers.size)
+      end
+
+      collection.map do |elements|
+        identifiers.zip(elements).to_h
       end
     end
   end