params_ready_rails5 0.0.7

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

data/lib/params_ready/query/predicate.rb

@@ -0,0 +1,203 @@
+require_relative '../extensions/registry'
+require_relative '../parameter/array_parameter'
+require_relative '../parameter/enum_set_parameter'
+require_relative '../helpers/arel_builder'
+
+module ParamsReady
+  module Query
+    class AbstractPredicateBuilder < AbstractBuilder
+      module HavingType
+        def type(type_name, *args, **opts, &block)
+          name, altn = data_object_handles
+          builder = type_builder_instance(type_name, name, *args, altn: altn, **opts)
+          builder.instance_eval(&block) unless block.nil?
+          @definition.set_type builder.fetch
+        end
+
+        def type_builder_instance(type_name, name, *args, altn:, **opts)
+          AbstractPredicateBuilder.type(type_name)
+                                  .instance(name, *args, altn: altn, **opts)
+        end
+      end
+
+      module HavingAttribute
+        def associations(*arr)
+          arr.each do |name|
+            @definition.add_association name
+          end
+        end
+
+        def attribute(name: nil, expression: nil, &block)
+          expression = if expression
+            raise ParamsReadyError, 'Block unexpected' unless block.nil?
+            expression
+          else
+            raise ParamsReadyError, 'Expression unexpected' unless expression.nil?
+            block
+          end
+          @definition.set_attribute(name, expression)
+        end
+      end
+
+      include HavingArelTable
+
+      extend Extensions::Registry
+      registry :types, as: :type, getter: true
+      register_type :value, Parameter::ValueParameterBuilder
+      register_type :array, Parameter::ArrayParameterBuilder
+      register_type :enum_set, Parameter::EnumSetParameterBuilder
+    end
+
+    class AbstractPredicateDefinition < Parameter::AbstractDefinition
+      late_init :arel_table, obligatory: false, freeze: false
+
+      module HavingAttribute
+        def self.included(base)
+          base.collection :associations, :association
+        end
+
+        def set_attribute(name, select_expression)
+          @attribute_name = name
+          @select_expression = select_expression
+        end
+
+        def attribute_name
+          @attribute_name || @name
+        end
+
+        def select_expression
+          @select_expression || attribute_name
+        end
+
+        def build_select_expression(arel_table, context)
+          arel_builder = Helpers::ArelBuilder.instance(select_expression, arel_table: @arel_table)
+          arel = arel_builder.to_arel(arel_table, context, self)
+
+          arel
+        end
+
+        def alias_select_expression(arel_table, context)
+          build_select_expression(arel_table, context).as(attribute_name.to_s)
+        end
+      end
+    end
+
+    module Predicate
+      module HavingChildren
+        def context_for_predicates(context)
+          intent_for_children(context)
+        end
+      end
+
+      module HavingAssociations
+        def dig(record, associations)
+          associations.reduce(record) do |record, assoc|
+            next record if record.nil?
+
+            record.send assoc
+          end
+        end
+      end
+
+      module HavingAttribute
+        extend Forwardable
+        def_delegators :definition, :build_select_expression, :alias_select_expression
+        include HavingAssociations
+
+        def to_query(arel_table, context: Restriction.blanket_permission)
+          table = definition.arel_table || arel_table
+          select_expression = build_select_expression(table, context)
+          build_query(select_expression, context: context)
+        end
+
+        def context_for_predicates(context)
+          # We consider a an attribute having parameter atomic
+          # so it's permitted per se including its contents
+          context.permit_all
+        end
+
+        def test(record)
+          return nil unless is_definite?
+
+          attribute_name = definition.attribute_name
+          record = dig(record, definition.associations)
+
+          perform_test(record, attribute_name)
+        end
+      end
+
+      module DelegatingPredicate
+        def self.included(base)
+          base.include Parameter::DelegatingParameter
+        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 unless eligible_for_query?(arel_table, context)
+
+          context = context_for_predicates(context)
+          to_query(arel_table, context: context)
+        end
+        attr_reader :data
+
+      end
+    end
+
+    class PredicateRegistry
+      extend Extensions::Registry
+
+      registry :operator_names, as: :operator_by_name, name_method: :name
+      registry :operator_alt_names, as: :operator_by_alt_name, name_method: :altn
+      registry :predicates, as: :predicate, getter: true
+
+      def self.operator_by(identifier, format)
+        if format.alternative?
+          @@operator_alt_names[identifier]
+        else
+          @@operator_names[identifier]
+        end
+      end
+
+      def self.operator(identifier, format, collision_check = false)
+        operator = find_operator(identifier, format, collision_check)
+        if operator.nil? && !collision_check
+          raise("No such operator: #{identifier}")
+        end
+
+        operator
+      end
+
+      def self.find_operator(identifier, format, collision_check)
+        operator = operator_by(identifier, format)
+        if operator.nil?
+          name_as_string = identifier.to_s
+          invertor = if format.alternative?
+            'n_'
+          else
+            'not_'
+          end
+          if !collision_check && name_as_string.start_with?(invertor)
+            bare_name = name_as_string[invertor.length..-1].to_sym
+            inverted = PredicateRegistry.operator(bare_name, format)
+            if inverted.nil?
+              nil
+            elsif inverted.inverse_of.nil?
+              Not.new(inverted)
+            else
+              operator(inverted.inverse_of, format)
+            end
+          else
+            nil
+          end
+        else
+          operator
+        end
+      end
+    end
+  end
+end

data/lib/params_ready/query/predicate_operator.rb

@@ -0,0 +1,132 @@
+require_relative 'predicate'
+
+module ParamsReady
+  module Query
+    class PredicateOperator
+      def self.dup
+        self
+      end
+
+      def self.define_operator(name, altn, arel: nil, test: nil, inverse_of: nil)
+        define_singleton_method :name do
+          name
+        end
+
+        define_singleton_method :altn do
+          altn
+        end
+
+        if arel
+          define_singleton_method :to_query do |attribute, value|
+            attribute.send(arel, value)
+          end
+        end
+
+        if test
+          define_singleton_method :test do |record, attribute_name, value|
+            attribute = record.send attribute_name
+            attribute.send test, value
+          end
+        end
+
+        define_singleton_method :inverse_of do
+          inverse_of
+        end
+
+        unless PredicateRegistry.operator(self.name, Format.instance(:backend), true).nil?
+          raise ParamsReadyError, "Operator name taken #{self.name}"
+        end
+
+        unless PredicateRegistry.operator(self.altn, Format.instance(:frontend), true).nil?
+          raise ParamsReadyError, "Operator altn taken #{self.name}"
+        end
+
+        PredicateRegistry.register_operator_by_name self
+        PredicateRegistry.register_operator_by_alt_name self
+      end
+
+      def altn
+        self.class.altn
+      end
+    end
+
+    class In < PredicateOperator
+      define_operator :in, :in, arel: :in
+
+      def self.test(record, attribute_name, values)
+        attribute = record.send attribute_name
+        values.include? attribute
+      end
+    end
+
+
+    class ComparisonPredicateOperator < PredicateOperator; end
+
+    class Like < ComparisonPredicateOperator
+      define_operator :like, :lk
+
+      def self.to_query(attribute_name, value)
+        attribute_name.matches("%#{value}%")
+      end
+
+      def self.test(record, attribute_name, value)
+        attribute = record.send attribute_name
+        result = Regexp.new(value, Regexp::IGNORECASE) =~ attribute
+        result.nil? ? false : true
+      end
+    end
+
+    class Equal < ComparisonPredicateOperator
+      define_operator :equal, :eq, arel: :eq, test: :==
+    end
+
+    class NotEqual < ComparisonPredicateOperator
+      define_operator :not_equal, :neq, arel: :not_eq, test: :!=
+    end
+
+    class GreaterThan < ComparisonPredicateOperator
+      define_operator :greater_than, :gt, arel: :gt, test: :>, inverse_of: :less_than_or_equal
+
+      def self.test(record, attribute_name, value)
+        attribute = record.send attribute_name
+        attribute > value
+      end
+    end
+
+    class LessThan < ComparisonPredicateOperator
+      define_operator :less_than, :lt, arel: :lt, test: :<, inverse_of: :greater_than_or_equal
+    end
+
+    class GraterThanOrEqual < ComparisonPredicateOperator
+      define_operator :greater_than_or_equal, :gteq, arel: :gteq, test: :>=, inverse_of: :less_than
+    end
+
+    class LessThanOrEqual < ComparisonPredicateOperator
+      define_operator :less_than_or_equal, :lteq, arel: :lteq, test: :<=, inverse_of: :greater_than
+    end
+
+    class Not
+      def initialize(operator)
+        @operator = operator
+      end
+
+      def name
+        "not_#{@operator.name}"
+      end
+
+      def altn
+        "n#{@operator.altn}"
+      end
+
+      def test(*args)
+        result = @operator.test *args
+        !result
+      end
+
+      def to_query(*args)
+        result = @operator.to_query(*args)
+        result.not
+      end
+    end
+  end
+end