params_ready 0.0.1

data/lib/params_ready/query/structured_grouping.rb

@@ -0,0 +1,58 @@
+require_relative '../parameter/hash_parameter'
+require_relative '../parameter/value_parameter'
+require_relative 'fixed_operator_predicate'
+require_relative 'nullness_predicate'
+require_relative 'grouping'
+
+module ParamsReady
+  module Query
+    class StructuredGrouping < Parameter::HashParameter
+      include Parameter::GroupingLike
+      def predicates
+        return [] if is_nil?
+
+        definition.predicates.keys.map do |name|
+          parameter = child(name)
+          next nil unless parameter.is_definite?
+          parameter
+        end.compact
+      end
+
+      def operator
+        self[:operator].unwrap
+      end
+
+      def context_for_predicates(restriction)
+        intent_for_children(restriction)
+      end
+    end
+
+    class StructuredGroupingBuilder < Builder
+      include GroupingLike
+      include Parameter::AbstractHashParameterBuilder::HashLike
+      PredicateRegistry.register_predicate :structured_grouping_predicate, self
+
+      def self.instance(name, altn: nil)
+        new StructuredGroupingDefinition.new(name, altn: altn)
+      end
+    end
+
+    class StructuredGroupingDefinition < Parameter::HashParameterDefinition
+      attr_reader :arel_table, :predicates
+
+      def initialize(*args, **opts)
+        @predicates = {}
+        super *args, **opts
+      end
+
+      def add_predicate(predicate)
+        raise ParamsReadyError, "Predicate name taken: '#{predicate.name}" if predicates.key? predicate.name
+        predicates[predicate.name] = predicate
+      end
+
+      parameter_class StructuredGrouping
+
+      freeze_variables :predicates
+    end
+  end
+end

data/lib/params_ready/query/variable_operator_predicate.rb

@@ -0,0 +1,125 @@
+require_relative 'predicate'
+require_relative '../parameter/hash_parameter'
+require_relative '../parameter/value_parameter'
+require_relative '../value/validator'
+require_relative 'predicate_operator'
+
+module ParamsReady
+  module Query
+    class VariableOperatorPredicate < Parameter::AbstractParameter
+      include Predicate::DelegatingPredicate
+      include Predicate::HavingAttribute
+
+      def initialize(definition)
+        super definition
+        @data = definition.hash_parameter.create
+      end
+
+      def build_query(select_expression, context: nil)
+        operator.to_query(select_expression, value)
+      end
+
+      def perform_test(record, attribute_name)
+        operator.test(record, attribute_name, value)
+      end
+
+      def value
+        @data[:value].unwrap
+      end
+
+      def operator
+        @data[:operator].unwrap
+      end
+
+      def inspect_content
+        op, val = if is_definite?
+          op = @data[:operator].unwrap_or(nil)&.name || '?'
+          val = @data[:value].unwrap_or('?')
+        else
+          %w[? ?]
+        end
+        "#{definition.attribute_name} #{op} #{val}"
+      end
+    end
+
+    class OperatorCoder < Value::Coder
+      def self.coerce(value, context)
+        return value if value.class == Class && value < PredicateOperator
+        identifier = value.to_sym
+        PredicateRegistry.operator(identifier, context)
+      end
+
+      def self.format(value, intent)
+        intent.hash_key(value)
+      end
+
+      def self.strict_default?
+        false
+      end
+    end
+
+    Parameter::ValueParameterBuilder.register_coder :predicate_operator, OperatorCoder
+
+    class VariableOperatorPredicateBuilder < AbstractPredicateBuilder
+      PredicateRegistry.register_predicate :variable_operator_predicate, self
+      include HavingType
+      include HavingAttribute
+      include DelegatingBuilder[:hash_parameter_builder]
+
+      def self.instance(name, altn: nil, attr: nil)
+        new VariableOperatorPredicateDefinition.new name, altn: altn, attribute_name: attr
+      end
+
+      def data_object_handles
+        [:value, :val]
+      end
+
+      def operators(*arr, &block)
+        @definition.set_operators(arr, &block)
+      end
+    end
+
+    class VariableOperatorPredicateDefinition < AbstractPredicateDefinition
+      include HavingAttribute
+
+      attr_reader :hash_parameter_builder
+      attr_reader :hash_parameter
+
+      def initialize(*args, attribute_name: nil, **opts)
+        super *args, **opts
+        @attribute_name = attribute_name
+        @hash_parameter_builder = Builder.builder(:hash).instance(name, altn: altn)
+        @operator_parameter_builder = Builder.builder(:predicate_operator).instance(:operator, altn: :op)
+      end
+
+      def set_type(type)
+        @type = type
+        @hash_parameter_builder.add @type.finish
+      end
+
+      def set_operators(array, &block)
+        context = Format.instance(:backend)
+
+        operators = array.map do |name|
+          PredicateRegistry.operator(name, context)
+        end
+        @operator_parameter_builder.include do
+          constrain :enum, operators
+        end
+        @operator_parameter_builder.include(&block) unless block.nil?
+        @hash_parameter_builder.add @operator_parameter_builder.build
+      end
+
+      def finish
+        @hash_parameter = @hash_parameter_builder.build
+        @hash_parameter_builder = nil
+        @operator_parameter_builder = nil
+        @type = nil
+
+        super
+      end
+
+      parameter_class VariableOperatorPredicate
+    end
+  end
+end

data/lib/params_ready/query_context.rb

@@ -0,0 +1,21 @@
+require 'forwardable'
+require_relative 'restriction'
+
+module ParamsReady
+  class QueryContext
+    include Restriction::Wrapper
+    extend Forwardable
+    attr_reader :data
+    def_delegator :data, :[]
+
+    def initialize(restriction, data = {})
+      @data = data.freeze
+      raise ParamsReadyError, "Restriction expected, got: #{restriction.inspect}" unless restriction.is_a? Restriction
+      @restriction = restriction.freeze
+    end
+
+    def clone(restriction:)
+      QueryContext.new restriction, data
+    end
+  end
+end

data/lib/params_ready/restriction.rb

@@ -0,0 +1,252 @@
+module ParamsReady
+  class Restriction
+    module Wrapper
+      extend Forwardable
+      attr_reader :restriction
+      def_delegators :restriction, :name_permitted?, :permitted?, :permissions_for
+
+      def delegate(*args)
+        return self if @restriction.everything?
+
+        new_restriction = @restriction.delegate(*args)
+        clone(restriction: new_restriction)
+      end
+
+      def for_children(parameter)
+        return self if @restriction.everything?
+
+        new_restriction = @restriction.for_children parameter
+        clone(restriction: new_restriction)
+      end
+
+      def permit_all
+        return self if @restriction.everything?
+
+        clone(restriction: Restriction.blanket_permission)
+      end
+
+      def permit(*list)
+        restriction = Restriction.permit(*list)
+        return self if @restriction.everything? && restriction.everything?
+
+        clone(restriction: restriction)
+      end
+
+      def prohibit(*list)
+        restriction = Restriction.prohibit(*list)
+        return self if @restriction.everything? && restriction.everything?
+
+        clone(restriction: restriction)
+      end
+
+      def to_restriction
+        @restriction
+      end
+    end
+
+    class Everything
+      def self.key?(_)
+        true
+      end
+
+      def self.[](_)
+        Everything
+      end
+
+      def self.dup
+        self
+      end
+    end
+
+    class Nothing
+      def self.key?(_)
+        false
+      end
+
+      def self.[](_)
+        Nothing
+      end
+
+      def self.dup
+        self
+      end
+    end
+
+    def self.blanket_permission
+      @blanket_permission ||= Allowlist.new
+    end
+
+    def self.permit(*args)
+      Allowlist.instance(*args)
+    end
+
+    def self.prohibit(*args)
+      Denylist.instance(*args)
+    end
+
+    def self.from_array(arr)
+      arr.each_with_object({}) do |element, restriction|
+        case element
+        when String, Symbol
+          restriction[element.to_sym] = Everything
+        when Hash
+          element.each do |key, value|
+            restriction[key.to_sym] = value
+          end
+        else
+          raise TypeError.new("Unexpected as restriction item: #{element}")
+        end
+      end
+    end
+
+    def self.instance(*list)
+      return blanket_permission if list.length == 1 && list[0] == default
+
+      restriction_list = if list.length == 1 && list[0].is_a?(Regexp)
+        list[0]
+      else
+        from_array(list)
+      end
+      new restriction_list
+    end
+
+    attr_reader :restriction
+
+    def initialize(restriction = self.class.default)
+      @restriction = if restriction.is_a? self.class
+        restriction.restriction
+      else
+        restriction.freeze
+      end
+      freeze
+    end
+
+    def hash
+      @restriction.hash
+    end
+
+    def everything?
+      @restriction == self.class.default
+    end
+
+    def name_listed?(name)
+      if @restriction.is_a? Regexp
+        name =~ @restriction
+      else
+        @restriction.key?(name)
+      end
+    end
+
+    def permitted?(parameter)
+      name = parameter.name
+      return false unless name_permitted?(name)
+      return true unless parameter.respond_to? :permission_depends_on
+
+      children = parameter.permission_depends_on
+      intent = parameter.intent_for_children(self)
+      children.all? do |child|
+        intent.permitted?(child)
+      end
+    end
+
+    def delegate(parent, delegate_name, *others)
+      return self if everything?
+
+      list = restriction_list_for(parent)
+
+      self.class.instance({ delegate_name => list }, *others)
+    end
+
+    def for_children(parameter)
+      return self if everything?
+
+      list = restriction_list_for(parameter)
+      if list.is_a? Restriction
+        list
+      else
+        self.class.instance(*list)
+      end
+    end
+
+    def restriction_list_for(parameter)
+      name = parameter.name
+      raise ParamsReadyError, "Parameter '#{name}' not permitted" unless name_permitted? name
+      restriction_list_for_name(name)
+    end
+
+    def to_restriction
+      self
+    end
+
+    def permit_all
+      self.class.permit_all
+    end
+
+    def self.permit_all
+      new default
+    end
+
+    class Allowlist < Restriction
+      def self.default
+        Everything
+      end
+
+      def name_permitted?(name)
+        name_listed?(name)
+      end
+
+      def permit(*args)
+        self.class.permit(*args)
+      end
+
+      def ==(other)
+        return false unless other.is_a? self.class
+        return true if object_id == other.object_id
+
+        restriction == other.restriction
+      end
+
+      protected
+
+      def restriction_list_for_name(name)
+        if @restriction.is_a? Regexp
+          self.class.default
+        else
+          @restriction[name]
+        end
+      end
+    end
+
+    class Denylist < Restriction
+      def self.default
+        Nothing
+      end
+
+      def name_permitted?(name)
+        return true unless name_listed?(name)
+        return false unless @restriction.is_a?(Hash)
+        return true if @restriction[name].is_a?(Array)
+        return true if @restriction[name].is_a?(Symbol)
+        return true if @restriction[name] == self.class.default
+
+        false
+      end
+
+      def prohibit(*args)
+        self.class.prohibit(*args)
+      end
+
+      protected
+
+      def restriction_list_for_name(name)
+        if @restriction.is_a? Regexp
+          self.class.default
+        elsif @restriction[name].nil?
+          self.class.default
+        else
+          @restriction[name]
+        end
+      end
+    end
+  end
+end