params_ready 0.0.1

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(base_table, context, parameter)
+        join_statement = @statement.to_arel(base_table, @arel_table, context, parameter)
+        base_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

data/lib/params_ready/query/nullness_predicate.rb

@@ -0,0 +1,71 @@
+require_relative 'predicate'
+require_relative '../parameter/value_parameter'
+
+module ParamsReady
+  module Query
+    class NullnessPredicate < Parameter::AbstractParameter
+      include Predicate::DelegatingPredicate
+      include Predicate::HavingAttribute
+
+      def initialize(definition)
+        super definition
+        @data = definition.value_parameter.create
+      end
+
+      def build_query(select_expression, context: nil)
+        query = select_expression.eq(nil)
+        if !unwrap
+          query.not
+        else
+          query
+        end
+      end
+
+      def perform_test(record, attribute_name)
+        if unwrap
+          return true if record.nil?
+          record.send(attribute_name).nil?
+        else
+          return false if record.nil?
+          !record.send(attribute_name).nil?
+        end
+      end
+
+      def inspect_content
+        "#{definition.attribute_name} is_null? #{@data.inspect}"
+      end
+    end
+
+    class NullnessPredicateBuilder < AbstractPredicateBuilder
+      include HavingAttribute
+      PredicateRegistry.register_predicate :nullness_predicate, self
+
+      include HavingValue
+
+      def self.instance(name, altn: nil, attr: nil)
+        new NullnessPredicateDefinition.new name, altn: altn, attribute_name: attr
+      end
+    end
+
+    class NullnessPredicateDefinition < AbstractPredicateDefinition
+      include HavingAttribute
+      include Parameter::DelegatingDefinition[:value_parameter]
+
+      attr_reader :value_parameter
+      freeze_variables :value_parameter
+
+      def initialize(*args, attribute_name: nil, **opts)
+        super *args, **opts
+        @attribute_name = attribute_name
+        @value_parameter = Builder.builder(:boolean).instance(self.name, altn: self.altn).fetch
+      end
+
+      def finish
+        @value_parameter.finish
+        super
+      end
+
+      parameter_class NullnessPredicate
+    end
+  end
+end

data/lib/params_ready/query/polymorph_predicate.rb

@@ -0,0 +1,77 @@
+require 'forwardable'
+require_relative 'predicate'
+require_relative '../parameter/polymorph_parameter'
+
+module ParamsReady
+  module Query
+    class PolymorphPredicate < Parameter::AbstractParameter
+      include Predicate::DelegatingPredicate
+      include Predicate::HavingChildren
+
+      def_delegators :@data,
+                     :intent_for_children,
+                     :permission_depends_on
+
+      def initialize(definition, **_)
+        super definition
+        @data = definition.polymorph_parameter.create
+      end
+
+      def to_query(arel_table, context: Restriction.blanket_permission)
+        data[data.type].to_query_if_eligible(arel_table, context: context)
+      end
+
+      def test(record)
+        return nil unless is_definite?
+
+        data[data.type].test(record)
+      end
+    end
+
+    class PolymorphPredicateBuilder < AbstractPredicateBuilder
+      PredicateRegistry.register_predicate :polymorph_predicate, self
+      include HavingValue
+
+      def self.instance(name, altn: nil)
+        new PolymorphPredicateDefinition.new name, altn: altn
+      end
+
+      def type(type_name, *args, **opts, &block)
+        builder = PredicateRegistry.predicate(type_name).instance(*args, **opts)
+        builder.instance_eval(&block) unless block.nil?
+        type = builder.build
+        @definition.add_type type
+      end
+
+      def identifier(identifier)
+        @definition.set_identifier(identifier)
+      end
+    end
+
+    class PolymorphPredicateDefinition < AbstractPredicateDefinition
+      extend Forwardable
+
+      attr_reader :polymorph_parameter, :name, :altn
+      freeze_variable :polymorph_parameter
+      def_delegators :@polymorph_parameter,
+                     :add_type,
+                     :set_optional,
+                     :set_default,
+                     :set_identifier,
+                     :set_marshaller
+
+      def initialize(*args, **opts)
+        super
+        @polymorph_parameter = Parameter::PolymorphParameterDefinition.new(name, altn: altn)
+        @optional = false
+      end
+
+      def finish
+        @polymorph_parameter.finish
+        super
+      end
+
+      parameter_class PolymorphPredicate
+    end
+  end
+end