oso-oso 0.14.2 → 0.20.1.pre.beta

data/lib/oso/polar/data_filtering.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module Oso
+  module Polar
+    # Data filtering interface for Ruby
+    module DataFiltering
+      # Represents a set of filter sequences that should allow the host
+      # to obtain the records satisfying a query.
+      class FilterPlan
+        attr_reader :result_sets
+
+        def self.parse(polar, partials, class_name)
+          types = polar.host.serialize_types
+          parsed_json = polar.ffi.build_filter_plan(types, partials, 'resource', class_name)
+          result_sets = parsed_json['result_sets'].map do |rset|
+            ResultSet.parse polar, rset
+          end
+
+          new polar: polar, result_sets: result_sets
+        end
+
+        def initialize(polar:, result_sets:)
+          @polar = polar
+          @result_sets = result_sets
+        end
+
+        def build_query # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+          combine = nil
+          result_sets.each_with_object([]) do |rs, qb|
+            rs.resolve_order.each_with_object({}) do |i, set_results|
+              req = rs.requests[i]
+              cs = req.constraints.each { |c| c.ground set_results }
+              typ = @polar.host.types[req.class_tag]
+              q = typ.build_query[cs]
+              if i != rs.result_id
+                set_results[i] = typ.exec_query[q]
+              else
+                combine = typ.combine_query
+                qb.push q
+              end
+            end
+          end.reduce(&combine)
+        end
+
+        # Represents a sequence of filters for one set of results
+        class ResultSet
+          attr_reader :requests, :resolve_order, :result_id
+
+          def self.parse(polar, parsed_json)
+            resolve_order = parsed_json['resolve_order']
+            result_id = parsed_json['result_id']
+            requests = parsed_json['requests'].each_with_object({}) do |req, reqs|
+              reqs[req[0].to_i] = Request.parse(polar, req[1])
+            end
+
+            new resolve_order: resolve_order, result_id: result_id, requests: requests
+          end
+
+          def initialize(requests:, resolve_order:, result_id:)
+            @resolve_order = resolve_order
+            @requests = requests
+            @result_id = result_id
+          end
+        end
+
+        # Represents a filter for a result set
+        class Request
+          attr_reader :constraints, :class_tag
+
+          def self.parse(polar, parsed_json)
+            constraints = parsed_json['constraints'].map do |con|
+              Filter.parse polar, con
+            end
+            class_tag = parsed_json['class_tag']
+
+            new(constraints: constraints, class_tag: class_tag)
+          end
+
+          def initialize(constraints:, class_tag:)
+            @constraints = constraints
+            @class_tag = class_tag
+          end
+        end
+      end
+
+      # Represents relationships between resources, eg. one-one or one-many
+      class Relation
+        attr_reader :kind, :other_type, :my_field, :other_field
+
+        def initialize(kind:, other_type:, my_field:, other_field:)
+          @kind = kind
+          @other_type = other_type
+          @my_field = my_field
+          @other_field = other_field
+        end
+      end
+
+      # Represents field-field relationships on one resource.
+      class Field
+        attr_reader :field
+
+        def initialize(field:)
+          @field = field
+        end
+      end
+
+      # Represents field-field relationships on different resources.
+      class Ref
+        attr_reader :field, :result_id
+
+        def initialize(field:, result_id:)
+          @field = field
+          @result_id = result_id
+        end
+      end
+
+      # Represents a condition that must hold on a resource.
+      class Filter
+        attr_reader :kind, :field, :value
+
+        CHECKS = {
+          'Eq' => ->(a, b) { a == b },
+          'In' => ->(a, b) { b.include? a },
+          'Neq' => ->(a, b) { a != b },
+          'Contains' => ->(a, b) { a.include? b }
+        }.freeze
+
+        def initialize(kind:, field:, value:)
+          @kind = kind
+          @field = field
+          @value = value
+          @check = CHECKS[kind]
+          raise "Unknown constraint kind `#{kind}`" if @check.nil?
+        end
+
+        def ground(results)
+          return unless value.is_a? Ref
+
+          ref = value
+          @value = results[ref.result_id]
+          @value = value.map { |v| v.send ref.field } unless ref.field.nil?
+        end
+
+        def check(item)
+          val = value.is_a?(Field) ? item.send(value.field) : value
+          item = field.nil? ? item : item.send(field)
+          @check[item, val]
+        end
+
+        def self.parse(polar, constraint) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+          kind = constraint['kind']
+          field = constraint['field']
+          value = constraint['value']
+
+          value_kind = value.keys.first
+          value = value[value_kind]
+
+          case value_kind
+          when 'Term'
+            value = polar.host.to_ruby value
+          when 'Ref'
+            child_field = value['field']
+            result_id = value['result_id']
+            value = Ref.new field: child_field, result_id: result_id
+          when 'Field'
+            value = Field.new field: value
+          else
+            raise "Unknown value kind `#{value_kind}`"
+          end
+
+          new kind: kind, field: field, value: value
+        end
+      end
+    end
+  end
+end

data/lib/oso/polar/errors.rb

@@ -3,7 +3,7 @@
 module Oso
   module Polar
     # Base error type for Oso::Polar.
-    class Error < ::RuntimeError
+    class Error < ::Oso::Error
       attr_reader :stack_trace
 
       # @param message [String]
@@ -68,7 +68,7 @@ module Oso
       end
     end
     class DuplicateClassAliasError < PolarRuntimeError # rubocop:disable Style/Documentation
-      # @param as [String]
+      # @param name [String]
       # @param old [Class]
       # @param new [Class]
       def initialize(name:, old:, new:)
@@ -101,7 +101,6 @@ module Oso
     class ParameterError < ApiError; end
 
     class ValidationError < Error; end
-    class RolesValidationError < Error; end
 
     UNEXPECTED_EXPRESSION_MESSAGE = <<~MSG
       Received Expression from Polar VM. The Expression type is not yet supported in this language.

data/lib/oso/polar/ffi/error.rb

@@ -56,7 +56,7 @@ module Oso
             operational_error(subkind, msg: msg, details: details)
           when 'Parameter'
             api_error(subkind, msg: msg, details: details)
-          when 'RolesValidation'
+          when 'Validation'
             validation_error(msg, details: details)
           end
         end
@@ -146,7 +146,7 @@ module Oso
         # @return [::Oso::Polar::ValidationError] the object converted into the expected format.
         private_class_method def self.validation_error(msg, details:)
           # This is currently the only type of validation error.
-          ::Oso::Polar::RolesValidationError.new(msg, details: details)
+          ::Oso::Polar::ValidationError.new(msg, details: details)
         end
       end
     end

data/lib/oso/polar/ffi/polar.rb

@@ -14,17 +14,22 @@ module Oso
           ffi_lib FFI::LIB_PATH
 
           attach_function :new, :polar_new, [], FFI::Polar
-          attach_function :enable_roles, :polar_enable_roles, [FFI::Polar], :int32
-          attach_function :validate_roles_config, :polar_validate_roles_config, [FFI::Polar, :string], :int32
-          attach_function :load, :polar_load, [FFI::Polar, :string, :string], :int32
+          attach_function :load, :polar_load, [FFI::Polar, :string], :int32
           attach_function :clear_rules, :polar_clear_rules, [FFI::Polar], :int32
           attach_function :next_inline_query, :polar_next_inline_query, [FFI::Polar, :uint32], FFI::Query
           attach_function :new_id, :polar_get_external_id, [FFI::Polar], :uint64
           attach_function :new_query_from_str, :polar_new_query, [FFI::Polar, :string, :uint32], FFI::Query
           attach_function :new_query_from_term, :polar_new_query_from_term, [FFI::Polar, :string, :uint32], FFI::Query
           attach_function :register_constant, :polar_register_constant, [FFI::Polar, :string, :string], :int32
+          attach_function :register_mro, :polar_register_mro, [FFI::Polar, :string, :string], :int32
           attach_function :next_message, :polar_next_polar_message, [FFI::Polar], FFI::Message
           attach_function :free, :polar_free, [FFI::Polar], :int32
+          attach_function(
+            :build_filter_plan,
+            :polar_build_filter_plan,
+            [FFI::Polar, :string, :string, :string, :string],
+            :string
+          )
         end
         private_constant :Rust
 
@@ -37,25 +42,20 @@ module Oso
           polar
         end
 
-        # @raise [FFI::Error] if the FFI call returns an error.
-        def enable_roles
-          result = Rust.enable_roles(self)
-          process_messages
-          handle_error if result.zero?
-        end
-
-        # @raise [FFI::Error] if the FFI call returns an error.
-        def validate_roles_config(config)
-          result = Rust.validate_roles_config(self, JSON.dump(config))
+        def build_filter_plan(types, partials, variable, class_tag)
+          types = JSON.dump(types)
+          partials = JSON.dump(partials)
+          plan = Rust.build_filter_plan(self, types, partials, variable, class_tag)
           process_messages
-          handle_error if result.zero?
+          handle_error if plan.nil?
+          # TODO(gw) more error checking?
+          JSON.parse plan
         end
 
-        # @param src [String]
-        # @param filename [String]
+        # @param sources [Array<Source>]
         # @raise [FFI::Error] if the FFI call returns an error.
-        def load(src, filename: nil)
-          loaded = Rust.load(self, src, filename)
+        def load(sources)
+          loaded = Rust.load(self, JSON.dump(sources))
           process_messages
           handle_error if loaded.zero?
         end
@@ -117,6 +117,14 @@ module Oso
           handle_error if registered.zero?
         end
 
+        # @param name [String]
+        # @param mro [Array<Integer>]
+        # @raise [FFI::Error] if the FFI call returns an error.
+        def register_mro(name, mro)
+          registered = Rust.register_mro(self, name, JSON.dump(mro))
+          handle_error if registered.zero?
+        end
+
         def next_message
           Rust.next_message(self)
         end

data/lib/oso/polar/ffi/query.rb

@@ -21,6 +21,7 @@ module Oso
           attach_function :next_message, :polar_next_query_message, [FFI::Query], FFI::Message
           attach_function :source, :polar_query_source_info, [FFI::Query], FFI::Source
           attach_function :free, :query_free, [FFI::Query], :int32
+          attach_function :bind, :polar_bind, [FFI::Query, :string, :string], :int32
         end
         private_constant :Rust
 
@@ -49,8 +50,7 @@ module Oso
           handle_error if res.zero?
         end
 
-        # @param result [Boolean]
-        # @param call_id [Integer]
+        # @param message [String]
         # @raise [FFI::Error] if the FFI call returns an error.
         def application_error(message)
           res = Rust.application_error(self, message)
@@ -67,6 +67,11 @@ module Oso
           ::Oso::Polar::QueryEvent.new(JSON.parse(event.to_s))
         end
 
+        def bind(name, value)
+          res = Rust.bind(self, name, JSON.dump(value))
+          handle_error if res.zero?
+        end
+
         def next_message
           Rust.next_message(self)
         end

data/lib/oso/polar/host.rb

@@ -34,14 +34,31 @@ module Oso
       end
     end
 
+    # For holding type metadata: name, fields, etc.
+    class UserType
+      attr_reader :name, :klass, :id, :fields, :build_query, :combine_query, :exec_query
+
+      def initialize(name:, klass:, id:, fields:, build_query:, combine_query:, exec_query:) # rubocop:disable Metrics/ParameterLists
+        @name = name
+        @klass = klass
+        @id = id
+        # accept symbol keys
+        @fields = fields.each_with_object({}) { |kv, o| o[kv[0].to_s] = kv[1] }
+        @build_query = build_query
+        @combine_query = combine_query
+        @exec_query = exec_query
+      end
+    end
+
     # Translate between Polar and the host language (Ruby).
     class Host # rubocop:disable Metrics/ClassLength
+      # @return [Hash<String, UserType>]
+      attr_reader :types
+
       protected
 
       # @return [FFI::Polar]
       attr_reader :ffi_polar
-      # @return [Hash<String, Class>]
-      attr_reader :classes
       # @return [Hash<Integer, Object>]
       attr_reader :instances
       # @return [Boolean]
@@ -53,42 +70,60 @@ module Oso
 
       def initialize(ffi_polar)
         @ffi_polar = ffi_polar
-        @classes = {}
+        @types = {}
         @instances = {}
         @accept_expression = false
       end
 
       def initialize_copy(other)
         @ffi_polar = other.ffi_polar
-        @classes = other.classes.dup
+        @types = other.types.dup
         @instances = other.instances.dup
       end
 
-      # Fetch a Ruby class from the {#classes} cache.
+      # Fetch a Ruby class from the {#types} cache.
       #
       # @param name [String]
       # @return [Class]
       # @raise [UnregisteredClassError] if the class has not been registered.
       def get_class(name)
-        raise UnregisteredClassError, name unless classes.key? name
+        raise UnregisteredClassError, name unless types.key? name
 
-        classes[name].get
+        types[name].klass.get
       end
 
-      # Store a Ruby class in the {#classes} cache.
+      # Store a Ruby class in the {#types} cache.
       #
       # @param cls [Class] the class to cache.
       # @param name [String] the name to cache the class as.
       # @return [String] the name the class is cached as.
       # @raise [DuplicateClassAliasError] if attempting to register a class
       # under a previously-registered name.
-      def cache_class(cls, name:)
-        raise DuplicateClassAliasError.new name: name, old: get_class(name), new: cls if classes.key? name
+      def cache_class(cls, name:, fields:, build_query:, combine_query:, exec_query:) # rubocop:disable Metrics/ParameterLists, Metrics/MethodLength
+        raise DuplicateClassAliasError.new name: name, old: get_class(name), new: cls if types.key? name
 
-        classes[name] = PolarClass.new(cls)
+        types[name] = types[cls] = UserType.new(
+          name: name,
+          klass: PolarClass.new(cls),
+          id: cache_instance(cls),
+          fields: fields || {},
+          combine_query: combine_query,
+          exec_query: exec_query,
+          build_query: build_query
+        )
         name
       end
 
+      def register_mros # rubocop:disable Metrics/AbcSize
+        types.values.uniq.each do |typ|
+          mro = []
+          typ.klass.get.ancestors.each do |a|
+            mro.push(types[a].id) if types.key?(a)
+          end
+          ffi_polar.register_mro(typ.name, mro)
+        end
+      end
+
       # Check if an instance exists in the {#instances} cache.
       #
       # @param id [Integer]
@@ -160,7 +195,7 @@ module Oso
 
       # Compare two values
       #
-      # @param op [String] operation to perform.
+      # @param operation [String] operation to perform.
       # @param args [Array<Object>] left and right args to operation.
       # @raise [PolarRuntimeError] if operation fails or is unsupported.
       # @return [Boolean]
@@ -190,6 +225,10 @@ module Oso
         left_index && right_index && left_index < right_index
       end
 
+      def subclass?(left_tag:, right_tag:)
+        get_class(left_tag) <= get_class(right_tag)
+      end
+
       # Check if instance is an instance of class.
       #
       # @param instance [Hash<String, Object>]
@@ -201,6 +240,32 @@ module Oso
         instance.is_a? cls
       end
 
+      def serialize_types # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        polar_types = {}
+        types.values.uniq.each do |typ|
+          tag = typ.name
+          fields = typ.fields
+          field_types = {}
+          fields.each do |k, v|
+            field_types[k] =
+              if v.is_a? ::Oso::Polar::DataFiltering::Relation
+                {
+                  'Relation' => {
+                    'kind' => v.kind,
+                    'other_class_tag' => v.other_type,
+                    'my_field' => v.my_field,
+                    'other_field' => v.other_field
+                  }
+                }
+              else
+                { 'Base' => { 'class_tag' => types[v].name } }
+              end
+          end
+          polar_types[tag] = field_types
+        end
+        polar_types
+      end
+
       # Turn a Ruby value into a Polar term that's ready to be sent across the
       # FFI boundary.
       #
@@ -242,7 +307,9 @@ module Oso
                     { 'Pattern' => { 'Instance' => { 'tag' => value.tag, 'fields' => dict['Dictionary'] } } }
                   end
                 else
-                  { 'ExternalInstance' => { 'instance_id' => cache_instance(value), 'repr' => nil } }
+                  instance_id = nil
+                  instance_id = types[value].id if value.is_a?(Class) && types.key?(value)
+                  { 'ExternalInstance' => { 'instance_id' => cache_instance(value, id: instance_id), 'repr' => nil } }
                 end
         { 'value' => value }
       end