params_ready_rails5 0.0.7

data/lib/params_ready/parameter_definer.rb

@@ -0,0 +1,14 @@
+require_relative 'helpers/parameter_definer_class_methods'
+require_relative 'helpers/parameter_storage_class_methods'
+require_relative 'helpers/relation_builder_wrapper'
+
+module ParamsReady
+  module ParameterDefiner
+    def self.included(base)
+      base.extend(Helpers::ParameterStorageClassMethods)
+      base.extend(Helpers::ParameterDefinerClassMethods)
+    end
+  end
+end
+
+

data/lib/params_ready/parameter_user.rb

@@ -0,0 +1,35 @@
+require_relative 'result'
+require_relative 'helpers/usage_rule'
+require_relative 'helpers/options'
+require_relative 'helpers/parameter_user_class_methods'
+require_relative 'helpers/parameter_storage_class_methods'
+require_relative 'parameter/state'
+
+module ParamsReady
+  module ParameterUser
+    def self.included(base)
+      base.extend(Helpers::ParameterStorageClassMethods)
+      base.extend(Helpers::ParameterUserClassMethods)
+    end
+
+    protected
+
+    def parameter_definition(key)
+      self.class.parameter_definition key
+    end
+
+    def relation_definition(key)
+      self.class.relation_definition key
+    end
+
+    def populate_state_for(key, params, context = Format.instance(:frontend), validator = nil)
+      definition = create_state_for key
+      result, state = definition.from_input(params || {}, context: context, validator: validator || Result.new(:params_ready))
+      [result, state]
+    end
+
+    def create_state_for(key)
+      self.class.params_ready_option.create_state_for(key)
+    end
+  end
+end

data/lib/params_ready/query/array_grouping.rb

@@ -0,0 +1,68 @@
+require_relative '../parameter/struct_parameter'
+require_relative '../parameter/array_parameter'
+require_relative 'grouping'
+require_relative 'predicate'
+
+module ParamsReady
+  module Query
+    class ArrayGrouping < Parameter::StructParameter
+      include Parameter::GroupingLike
+
+      def predicates
+        self[:array].to_a
+      end
+
+      def operator
+        self[:operator].unwrap
+      end
+
+      def context_for_predicates(restriction)
+        restriction.for_children(self)
+      end
+
+      def to_query(arel_table, context: Restriction.blanket_permission)
+        array = self[:array]
+
+        context = array.intent_for_children(context)
+        super arel_table, context: context
+      end
+    end
+
+    class ArrayGroupingBuilder < Builder
+      include Parameter::AbstractStructParameterBuilder::StructLike
+      PredicateRegistry.register_predicate :array_grouping_predicate, self
+
+      def prototype(type_name, name = :proto, *arr, **opts, &block)
+        prototype = PredicateRegistry.predicate(type_name).instance(name, *arr, **opts)
+        prototype.instance_eval(&block) unless block.nil?
+        @definition.set_prototype prototype.build
+      end
+
+      def self.instance(name, altn: nil)
+        new ArrayGroupingDefinition.new(name, altn: altn)
+      end
+
+      def operator(&block)
+        definition = Builder.define_grouping_operator(:operator, altn: :op, &block)
+        add definition
+      end
+    end
+
+    class ArrayGroupingDefinition < Parameter::StructParameterDefinition
+      def initialize(*args, **opts)
+        super
+      end
+
+      late_init :prototype, getter: false, obligatory: false do |prototype|
+        array = Builder.define_array(:array, altn: :a) do
+          prototype(prototype)
+          default []
+        end
+        add_child array
+        Extensions::Undefined
+      end
+
+      parameter_class ArrayGrouping
+    end
+  end
+end

data/lib/params_ready/query/custom_predicate.rb

@@ -0,0 +1,102 @@
+require_relative 'predicate'
+require_relative '../parameter/parameter'
+require_relative '../parameter/definition'
+
+module ParamsReady
+  module Query
+    class CustomPredicate < Parameter::AbstractParameter
+      include Predicate::DelegatingPredicate
+      include Predicate::HavingChildren
+
+      def initialize(definition)
+        super definition
+        @data = definition.type.create
+      end
+
+      def eligible_for_query?(arel_table, context)
+        return false unless context.permitted? self
+        eligibility_test = definition.eligibility_test
+        return true if eligibility_test.nil?
+
+        instance_exec(arel_table, context, &eligibility_test)
+      end
+
+      def to_query(arel_table, context: Restriction.blanket_permission)
+        return unless eligible_for_query?(arel_table, context)
+
+        to_query = definition.to_query
+        raise ParamsReadyError, "Method 'to_query' unimplemented in '#{name}'" if to_query.nil?
+        result = instance_exec(arel_table, context, &to_query)
+
+        case result
+        when Arel::Nodes::Node, nil
+          result
+        else
+          literal = Arel::Nodes::SqlLiteral.new(result)
+          grouping = Arel::Nodes::Grouping.new(literal)
+          grouping
+        end
+      end
+
+      def test(record)
+        test = definition.test
+        raise ParamsReadyError, "Method 'test' unimplemented in '#{name}'" if test.nil?
+        self.instance_exec(record, &test)
+      end
+    end
+
+    class CustomPredicateBuilder < Builder
+      PredicateRegistry.register_predicate :custom_predicate, self
+      include AbstractPredicateBuilder::HavingType
+
+      def initialize(name, altn: nil)
+        super CustomPredicateDefinition.new(name, altn: altn)
+      end
+
+      def type_builder_instance(type_name, name, *args, altn:, **opts, &block)
+        builder_class = Builder.builder(type_name)
+        builder_class.instance(name, *args, altn: altn, **opts)
+      end
+
+      def data_object_handles
+        [@definition.name, @definition.altn]
+      end
+
+      def to_query(&proc)
+        @definition.set_to_query(proc)
+      end
+
+      def eligible(&proc)
+        @definition.set_eligibility_test(proc)
+      end
+
+      def test(&proc)
+        @definition.set_test(proc)
+      end
+    end
+
+    class CustomPredicateDefinition < Parameter::AbstractDefinition
+      late_init :type, obligatory: true, freeze: false
+      freeze_variable :type
+      late_init :to_query, obligatory: false
+      late_init :eligibility_test, obligatory: false
+      late_init :test, obligatory: false
+
+      include Parameter::DelegatingDefinition[:type]
+
+      def initialize(*args, type: nil, to_query: nil, test: nil, **opts)
+        @type = type
+        @to_query = to_query
+        @test = test
+        super *args, **opts
+      end
+
+      def finish
+        @type.finish
+        super
+      end
+
+      parameter_class CustomPredicate
+    end
+  end
+end

data/lib/params_ready/query/exists_predicate.rb

@@ -0,0 +1,103 @@
+require_relative 'predicate'
+require_relative 'structured_grouping'
+require_relative 'join_clause'
+
+module ParamsReady
+  module Query
+    class ExistsPredicate < StructuredGrouping
+      include Predicate::HavingAssociations
+
+      def to_query(query_table, context: Restriction.blanket_permission)
+        query_table = definition.outer_table || query_table
+
+        subquery_table = self.definition.arel_table
+        raise ParamsReadyError, "Arel table for '#{name}' not set" if subquery_table.nil?
+
+        predicates = predicate_group(subquery_table, context: context)
+
+        join_clause = self.related query_table, subquery_table, context
+        subquery = GroupingOperator.instance(:and).connect(predicates, join_clause)
+        select = subquery_table.where(subquery)
+        query = select.take(1).project(Arel.star).exists
+        if definition.has_child?(:existence) && self[:existence].unwrap == :none
+          query.not
+        else
+          query
+        end
+      end
+
+      def related(query_table, subquery_table, context)
+        return nil if definition.related.nil?
+
+        grouping = definition.related.to_arel(query_table, subquery_table, context, self)
+        subquery_table.grouping(grouping)
+      end
+
+      def test(record)
+        return nil unless is_definite?
+
+        collection = dig(record, definition.path_to_collection)
+
+        result = if collection.nil?
+          false
+        else
+          collection.any? do |item|
+            super item
+          end
+        end
+
+        if definition.has_child?(:existence) && self[:existence].unwrap == :none
+          !result
+        else
+          result
+        end
+      end
+    end
+
+    class ExistsPredicateBuilder < Builder
+      PredicateRegistry.register_predicate :exists_predicate, self
+
+      include GroupingLike
+      include Parameter::AbstractStructParameterBuilder::StructLike
+      include HavingArelTable
+
+      def self.instance(name, altn: nil, coll: nil)
+        new ExistsPredicateDefinition.new(name, altn: altn, path_to_collection: Array(coll))
+      end
+
+      def related(on: nil, eq: nil, &block)
+        join_statement = JoinStatement.new(on: on, eq: eq, &block)
+        @definition.set_related(join_statement)
+      end
+
+      def outer_table(arel_table)
+        @definition.set_outer_table arel_table
+      end
+
+      def existence(&block)
+        definition = Builder.define_symbol(:existence, altn: :ex) do
+          constrain :enum, [:some, :none]
+          include &block
+        end
+        add definition
+      end
+    end
+
+    class ExistsPredicateDefinition < StructuredGroupingDefinition
+      late_init :outer_table, obligatory: false, freeze: false
+      late_init :arel_table, obligatory: false, freeze: false
+      late_init :related, obligatory: false, freeze: true
+
+      def initialize(*args, path_to_collection: nil, **opts)
+        @path_to_collection = path_to_collection
+        super *args, **opts
+      end
+
+      def path_to_collection
+        @path_to_collection || [@name]
+      end
+
+      parameter_class ExistsPredicate
+    end
+  end
+end

data/lib/params_ready/query/fixed_operator_predicate.rb

@@ -0,0 +1,77 @@
+require 'forwardable'
+
+require_relative '../parameter/value_parameter'
+require_relative '../parameter/array_parameter'
+require_relative 'predicate'
+require_relative 'predicate_operator'
+
+module ParamsReady
+  module Query
+    class FixedOperatorPredicate < Parameter::AbstractParameter
+      include Predicate::DelegatingPredicate
+      include Predicate::HavingAttribute
+
+      def initialize(definition, **options)
+        super definition
+        @data = definition.type.create
+      end
+
+      def build_query(select_expression, context: nil)
+        definition.operator.to_query(select_expression, @data.unwrap)
+      end
+
+      def perform_test(record, attribute_name)
+        definition.operator.test(record, attribute_name, @data.unwrap)
+      end
+
+      def inspect_content
+        op = definition.operator.name
+        "#{definition.attribute_name} #{op} #{@data.inspect}"
+      end
+    end
+
+    class FixedOperatorPredicateBuilder < AbstractPredicateBuilder
+      PredicateRegistry.register_predicate :fixed_operator_predicate, self
+      include HavingType
+      include HavingValue
+      include HavingAttribute
+
+      def self.instance(name, altn: nil, attr: nil)
+        new FixedOperatorPredicateDefinition.new name, altn: altn, attribute_name: attr
+      end
+
+      def data_object_handles
+        [@definition.name, @definition.altn]
+      end
+
+      def operator(name)
+        operator = PredicateRegistry.operator name, Format.instance(:backend)
+        @definition.set_operator operator
+      end
+    end
+
+    class FixedOperatorPredicateDefinition < AbstractPredicateDefinition
+      extend Forwardable
+      include HavingAttribute
+      include Parameter::DelegatingDefinition[:type]
+
+      late_init :operator, obligatory: true
+      late_init :type, obligatory: true, freeze: false
+
+      def initialize(*args, attribute_name: nil, type: nil, operator: nil, **opts)
+        @attribute_name = attribute_name
+        @type = type
+        @operator = operator
+        @associations = []
+        super *args, **opts
+      end
+
+      def finish
+        @type.finish
+        super
+      end
+
+      parameter_class FixedOperatorPredicate
+    end
+  end
+end

data/lib/params_ready/query/grouping.rb

@@ -0,0 +1,177 @@
+require_relative 'join_clause'
+require_relative '../parameter/parameter'
+require_relative '../parameter/value_parameter'
+
+module ParamsReady
+  class Builder
+    module GroupingLike
+      def predicate_builder(name)
+        symbol = name.to_sym
+        return nil unless Query::PredicateRegistry.has_predicate?(symbol)
+
+        Query::PredicateRegistry.predicate(symbol)
+      end
+
+      def method_missing(name, *args, **opts, &proc)
+        builder_class = predicate_builder(name)
+        if builder_class
+          builder = builder_class.instance *args, **opts
+          build_predicate builder, &proc
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        return true unless predicate_builder(name).nil?
+
+        super
+      end
+
+      def build_predicate(builder, &proc)
+        builder.instance_eval(&proc)
+        definition = builder.build
+        add_predicate definition
+      end
+
+      def add_predicate(name_or_definition, *args, **opts, &block)
+        if name_or_definition.is_a? Parameter::AbstractDefinition
+          @definition.add_predicate name_or_definition
+          add name_or_definition
+        else
+          builder = predicate_builder(name_or_definition).instance *args, **opts
+          build_predicate builder, &block
+        end
+      end
+
+      def operator(&block)
+        definition = Builder.define_grouping_operator(:operator, altn: :op, &block)
+        add definition
+      end
+    end
+  end
+
+  module Parameter
+    module GroupingLike
+      def predicate_group(arel_table, context: Restriction.blanket_permission)
+        subqueries = predicates.reduce(nil) do |acc, predicate|
+          query = predicate.to_query_if_eligible(arel_table, context: context)
+          # This duplicates the operator logic
+          # but we want operator to be optional
+          # for single predicate groupings
+          next query if acc.nil?
+
+          operator.connect(acc, query)
+        end
+        return nil if subqueries.nil?
+        arel_table.grouping(subqueries)
+      end
+
+      def eligible_for_query?(_table, context)
+        return false unless context.permitted? self
+
+        is_definite?
+      end
+
+      def to_query_if_eligible(arel_table, context:)
+        return nil unless eligible_for_query?(arel_table, context)
+
+        context = context_for_predicates(context)
+        to_query(arel_table, context: context)
+      end
+
+      def to_query(arel_table, context: Restriction.blanket_permission)
+        self.predicate_group(arel_table, context: context)
+      end
+
+      def test(record)
+        return nil unless is_definite?
+
+        predicates = self.predicates
+        return nil if predicates.empty?
+
+        operator.test(record, predicates)
+      end
+    end
+  end
+
+  module Query
+    class GroupingOperatorCoder < Value::SymbolCoder
+      def self.coerce(value, _)
+        return value if value.is_a? GroupingOperator
+
+        symbol = super
+        GroupingOperator.instance(symbol)
+      end
+
+      def self.format(value, _)
+        value.type.to_s
+      end
+
+      def self.strict_default?
+        false
+      end
+    end
+
+    Parameter::ValueParameterBuilder.register_coder :grouping_operator, GroupingOperatorCoder
+
+    class GroupingOperator
+      attr_reader :type
+
+      def self.instance(type)
+        raise ParamsReadyError, "Unimplemented operator: #{type}" unless @instances.key? type
+        @instances[type]
+      end
+
+      def arel_method
+        case type
+        when :and, :or then type
+        else
+          raise ParamsReadyError, "Unimplemented operator: #{type}"
+        end
+      end
+
+      def test_method
+        case type
+        when :and then :all?
+        when :or then :any?
+        else
+          raise ParamsReadyError, "Unimplemented operator: #{type}"
+        end
+      end
+
+      def connect(a, b)
+        return b if a.nil?
+        return a if b.nil?
+        a.send arel_method, b
+      end
+
+      def ==(other)
+        return false unless other.class <= GroupingOperator
+        type == other.type
+      end
+
+      def test(record, predicates)
+        definite = predicates.map do |predicate|
+          predicate.test(record)
+        end.compact
+
+        return nil if definite.empty?
+
+        definite.send(test_method)
+      end
+
+      protected
+
+      def initialize(type)
+        @type = type
+      end
+
+      @instances = {}
+      @instances[:and] = GroupingOperator.new(:and)
+      @instances[:or] = GroupingOperator.new(:or)
+
+      private_class_method :new
+    end
+  end
+end

data/lib/params_ready/query/join_clause.rb

@@ -0,0 +1,87 @@
+require_relative '../helpers/arel_builder'
+
+module ParamsReady
+  module Query
+    class Join
+      attr_reader :arel_table, :statement, :type
+
+      def initialize(table, type, &block)
+        @arel_table = table
+        @type = arel_type(type)
+        @statement = JoinStatement.new(&block)
+      end
+
+      def arel_type(type)
+        case type
+        when :inner then Arel::Nodes::InnerJoin
+        when :outer then Arel::Nodes::OuterJoin
+        else raise ParamsReadyError, "Unimplemented join type '#{type}'"
+        end
+      end
+
+      def to_arel(joined_table, base_table, context, parameter)
+        join_statement = @statement.to_arel(base_table, @arel_table, context, parameter)
+        joined_table.join(@arel_table, @type).on(join_statement)
+      end
+    end
+
+    class JoinStatement
+      def initialize(on: nil, eq: nil, &block)
+        @conditions = []
+        if on
+          condition = on(on)
+          if eq
+            condition.eq(eq)
+          end
+        else
+          raise ParamsReadyError('Parameter :eq unexpected') unless eq.nil?
+        end
+
+        instance_eval(&block) unless block.nil?
+        raise ParamsReadyError, "Join clause is empty" if @conditions.empty?
+      end
+
+      def on(expression, arel_table: nil)
+        condition = JoinCondition.new(expression, arel_table: arel_table)
+        @conditions << condition
+        condition
+      end
+
+      def to_arel(base_table, join_table, context, parameter)
+        @conditions.reduce(nil) do |result, condition|
+          arel = condition.to_arel(base_table, join_table, context, parameter)
+          next arel if result.nil?
+
+          result.and(arel)
+        end
+      end
+    end
+
+    class JoinCondition
+      def initialize(expression, arel_table: nil)
+        @on = Helpers::ArelBuilder.instance(expression, arel_table: arel_table)
+        @to = nil
+        @op = nil
+      end
+
+      def eq(expression, arel_table: nil)
+        raise ParamsReadyError, "Operator already set" unless @op.nil?
+        @op = :eq
+        @to = Helpers::ArelBuilder.instance(expression, arel_table: arel_table)
+      end
+
+      def to_arel(base_table, join_table, context, parameter)
+        if @to.nil?
+          grouping =  @on.to_arel(:none, context, parameter)
+          return grouping if grouping.is_a? Arel::Nodes::Node
+
+          Arel::Nodes::Grouping.new(grouping)
+        else
+          lhs =  @on.to_arel(base_table, context, parameter)
+          rhs = @to.to_arel(join_table, context, parameter)
+          lhs.send(@op, rhs)
+        end
+      end
+    end
+  end
+end