params_ready 0.0.2 → 0.0.8

data/lib/params_ready/parameter/{hash_parameter.rb → struct_parameter.rb}

@@ -1,22 +1,23 @@
 require_relative 'parameter'
 require_relative '../builder'
-require_relative 'abstract_hash_parameter'
+require_relative 'abstract_struct_parameter'
 require_relative '../marshaller/parameter_module'
 
 
 module ParamsReady
   module Parameter
-    class HashParameter < AbstractHashParameter
+    class StructParameter < AbstractStructParameter
       include Marshaller::ParameterModule
     end
 
-    class HashParameterBuilder < Builder
-      include AbstractHashParameterBuilder::HashLike
+    class StructParameterBuilder < Builder
+      include AbstractStructParameterBuilder::StructLike
       include Marshaller::BuilderModule
-      register :hash
+      register :struct
+      register_deprecated :hash, use: :struct
 
       def self.instance(name, altn: nil)
-        new HashParameterDefinition.new(name, altn: altn)
+        new StructParameterDefinition.new(name, altn: altn)
       end
 
       def map(hash)
@@ -24,11 +25,11 @@ module ParamsReady
       end
     end
 
-    class HashParameterDefinition < AbstractHashParameterDefinition
-      include Marshaller::DefinitionModule[Marshaller::HashMarshallers.collection]
+    class StructParameterDefinition < AbstractStructParameterDefinition
+      include Marshaller::DefinitionModule[Marshaller::StructMarshallers.collection]
 
-      name_for_formatter :hash
-      parameter_class HashParameter
+      name_for_formatter :struct
+      parameter_class StructParameter
       freeze_variables :key_map
 
       def ensure_canonical(hash)

data/lib/params_ready/parameter/tuple_parameter.rb

@@ -98,7 +98,7 @@ module ParamsReady
         end
       end
 
-      class HashMarshaller
+      class StructMarshaller
         def marshal(fields, _format)
           fields.each_with_index.map do |field, index|
             [index.to_s, field]

data/lib/params_ready/parameter/value_parameter.rb

@@ -70,28 +70,32 @@ module ParamsReady
         builder_class.register name
       end
 
-      def self.instance(name, coder_or_name = nil, altn: nil)
+      def self.instance(name, coder_or_name = nil, altn: nil, **opts)
         coder = if coder_or_name.is_a? Symbol
-          self.coder(coder_or_name)
-        elsif coder_or_name.nil?
-          Value::GenericCoder.new(name)
+          coder_class = self.coder(coder_or_name)
+          coder_class.instance(**opts)
         else
-          coder_or_name
+          raise ParamsReadyError, 'Expected option hash to be empty' unless opts.empty?
+          if coder_or_name.nil?
+            Value::GenericCoder.new(name)
+          else
+            coder_or_name
+          end
         end
         new ValueParameterDefinition.new(name, coder, altn: altn)
       end
 
-      def self.[](type)
+      def self.[](coder_name)
         builder = Class.new(self)
-        capitalized = type.to_s.split('_').map(&:capitalize).join
+        capitalized = coder_name.to_s.split('_').map(&:capitalize).join
         qualified = "#{self.name}::#{capitalized}Builder".freeze
 
         builder.define_singleton_method :name do
           qualified
         end
 
-        builder.define_singleton_method :instance do |name, altn: nil|
-          superclass.instance(name, type, altn: altn)
+        builder.define_singleton_method :instance do |name, altn: nil, **opts|
+          superclass.instance(name, coder_name, altn: altn, **opts)
         end
 
         builder
@@ -161,7 +165,7 @@ module ParamsReady
       def ensure_canonical(value)
         coerced = coder.try_coerce value, Format.instance(:backend)
         if coder.strict_default? && value != coerced
-          raise ParamsReadyError, "input '#{value}' (#{value.class.name}) coerced to '#{coerced}' (#{coerced.class.name})"
+          raise ParamsReadyError, "input '#{value}'/#{value.class.name} (expected '#{coerced}'/#{coerced.class.name})"
         end
         validate coerced
         coerced

data/lib/params_ready/parameter_user.rb

@@ -15,29 +15,21 @@ module ParamsReady
     protected
 
     def parameter_definition(key)
-        self.class.parameter_definition key
+      self.class.parameter_definition key
     end
 
     def relation_definition(key)
-        self.class.relation_definition key
+      self.class.relation_definition key
     end
 
-    def populate_state_for(method, params, context = Format.instance(:frontend), validator = nil)
-      definition = create_state_for method
+    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(method)
-      builder = Parameter::StateBuilder.instance
-      options = self.class.params_ready_storage
-      options.parameter_rules do |rule|
-        builder.add rule.parameter_definition if rule.valid_for(method)
-      end
-      options.relation_rules do |rule|
-        builder.relation rule.parameter_definition if rule.valid_for(method)
-      end
-      builder.build
+    def create_state_for(key)
+      self.class.params_ready_option.create_state_for(key)
     end
   end
-end
+end

data/lib/params_ready/query/array_grouping.rb

@@ -1,11 +1,11 @@
-require_relative '../parameter/hash_parameter'
+require_relative '../parameter/struct_parameter'
 require_relative '../parameter/array_parameter'
 require_relative 'grouping'
 require_relative 'predicate'
 
 module ParamsReady
   module Query
-    class ArrayGrouping < Parameter::HashParameter
+    class ArrayGrouping < Parameter::StructParameter
       include Parameter::GroupingLike
 
       def predicates
@@ -29,7 +29,7 @@ module ParamsReady
     end
 
     class ArrayGroupingBuilder < Builder
-      include Parameter::AbstractHashParameterBuilder::HashLike
+      include Parameter::AbstractStructParameterBuilder::StructLike
       PredicateRegistry.register_predicate :array_grouping_predicate, self
 
       def prototype(type_name, name = :proto, *arr, **opts, &block)
@@ -48,7 +48,7 @@ module ParamsReady
       end
     end
 
-    class ArrayGroupingDefinition < Parameter::HashParameterDefinition
+    class ArrayGroupingDefinition < Parameter::StructParameterDefinition
       def initialize(*args, **opts)
         super
       end

data/lib/params_ready/query/exists_predicate.rb

@@ -58,7 +58,7 @@ module ParamsReady
       PredicateRegistry.register_predicate :exists_predicate, self
 
       include GroupingLike
-      include Parameter::AbstractHashParameterBuilder::HashLike
+      include Parameter::AbstractStructParameterBuilder::StructLike
       include HavingArelTable
 
       def self.instance(name, altn: nil, coll: nil)
@@ -66,8 +66,8 @@ module ParamsReady
       end
 
       def related(on: nil, eq: nil, &block)
-        join_statement = JoinStatement.new(on: on, eq: eq, &block)
-        @definition.set_related(join_statement)
+        join_statement = JoinStatement::Builder.new(on: on, eq: eq, &block)
+        @definition.set_related(join_statement.build)
       end
 
       def outer_table(arel_table)

data/lib/params_ready/query/grouping.rb

@@ -48,6 +48,10 @@ module ParamsReady
         definition = Builder.define_grouping_operator(:operator, altn: :op, &block)
         add definition
       end
+
+      def to_query?(&block)
+        helper :to_query?, &block
+      end
     end
   end
 
@@ -67,10 +71,12 @@ module ParamsReady
         arel_table.grouping(subqueries)
       end
 
-      def eligible_for_query?(_table, context)
+      def eligible_for_query?(table, context)
         return false unless context.permitted? self
+        return false unless is_definite?
+        return true unless respond_to?(:to_query?)
 
-        is_definite?
+        to_query?(table, context)
       end
 
       def to_query_if_eligible(arel_table, context:)

data/lib/params_ready/query/join_clause.rb

@@ -1,14 +1,45 @@
 require_relative '../helpers/arel_builder'
+require_relative '../error'
 
 module ParamsReady
   module Query
     class Join
+      class Builder
+        def initialize(&block)
+          @block = block
+          @statement_builder = nil
+          @only_if = nil
+        end
+
+        def build
+          instance_eval(&@block)
+          @block = nil
+          raise ParamsReadyError, 'Join statement must be present' if @statement_builder.nil?
+          [@statement_builder.build, @only_if]
+        end
+
+        def on(expression, arel_table: nil)
+          @statement_builder ||= JoinStatement::Builder.new
+          @statement_builder.on(expression, arel_table: arel_table)
+        end
+
+        def only_if(&block)
+          @only_if = block
+          nil
+        end
+      end
+
       attr_reader :arel_table, :statement, :type
 
-      def initialize(table, type, &block)
-        @arel_table = table
+      def initialize(table, type, table_alias: nil, &block)
+        @arel_table = Helpers::ArelBuilder::Table.instance(table, table_alias: table_alias)
         @type = arel_type(type)
-        @statement = JoinStatement.new(&block)
+        @statement, @only_if = Builder.new(&block).build
+        freeze
+      end
+
+      def arel_table(context, parameter)
+        @arel_table.to_arel(context, parameter)
       end
 
       def arel_type(type)
@@ -19,32 +50,51 @@ module ParamsReady
         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)
+      def to_arel(joined_table, base_table, context, parameter)
+        return joined_table unless eligible?(context, parameter)
+
+        arel_table = arel_table(context, parameter)
+        join_statement = @statement.to_arel(base_table, arel_table, context, parameter)
+        joined_table.join(arel_table, @type).on(join_statement)
+      end
+
+      def eligible?(context, parameter)
+        return true if @only_if.nil?
+
+        @only_if.call(context, parameter)
       end
     end
 
     class JoinStatement
-      def initialize(on: nil, eq: nil, &block)
-        @conditions = []
-        if on
-          condition = on(on)
-          if eq
-            condition.eq(eq)
+      class Builder
+        def initialize(on: nil, eq: nil, &block)
+          @condition_builders = []
+          if on.nil?
+            raise ParamsReadyError, 'Parameter :eq unexpected' unless eq.nil?
+          else
+            condition = on(on)
+            condition.eq(eq) unless eq.nil?
           end
-        else
-          raise ParamsReadyError('Parameter :eq unexpected') unless eq.nil?
+          @block = block
         end
 
-        instance_eval(&block) unless block.nil?
-        raise ParamsReadyError, "Join clause is empty" if @conditions.empty?
+        def on(expression, arel_table: nil)
+          condition = JoinCondition::Builder.new(expression, arel_table: arel_table)
+          @condition_builders << condition
+          condition
+        end
+
+        def build
+          instance_eval(&@block) unless @block.nil?
+          JoinStatement.new(@condition_builders.map(&:build))
+        end
       end
 
-      def on(expression, arel_table: nil)
-        condition = JoinCondition.new(expression, arel_table: arel_table)
-        @conditions << condition
-        condition
+      def initialize(conditions)
+        @conditions = conditions.freeze
+        raise ParamsReadyError, "Join clause is empty" if @conditions.empty?
+
+        freeze
       end
 
       def to_arel(base_table, join_table, context, parameter)
@@ -58,16 +108,29 @@ module ParamsReady
     end
 
     class JoinCondition
-      def initialize(expression, arel_table: nil)
-        @on = Helpers::ArelBuilder.instance(expression, arel_table: arel_table)
-        @to = nil
-        @op = nil
+      class Builder
+        def initialize(expression, arel_table: nil)
+          @on = Helpers::ArelBuilder::Attribute.instance(expression, arel_table: arel_table)
+          @op = nil
+          @to = nil
+        end
+
+        def eq(expression, arel_table: nil)
+          raise ParamsReadyError, "Operator already set" unless @op.nil?
+          @op = :eq
+          @to = Helpers::ArelBuilder::Attribute.instance(expression, arel_table: arel_table)
+        end
+
+        def build
+          JoinCondition.new(@on, @op, @to)
+        end
       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)
+      def initialize(on, op, to)
+        @on = on
+        @op = op
+        @to = to
+        freeze
       end
 
       def to_arel(base_table, join_table, context, parameter)

data/lib/params_ready/query/predicate.rb

@@ -1,6 +1,6 @@
 require_relative '../extensions/registry'
 require_relative '../parameter/array_parameter'
-require_relative '../parameter/hash_set_parameter'
+require_relative '../parameter/enum_set_parameter'
 require_relative '../helpers/arel_builder'
 
 module ParamsReady
@@ -45,7 +45,7 @@ module ParamsReady
       registry :types, as: :type, getter: true
       register_type :value, Parameter::ValueParameterBuilder
       register_type :array, Parameter::ArrayParameterBuilder
-      register_type :hash_set, Parameter::HashSetParameterBuilder
+      register_type :enum_set, Parameter::EnumSetParameterBuilder
     end
 
     class AbstractPredicateDefinition < Parameter::AbstractDefinition
@@ -70,7 +70,7 @@ module ParamsReady
         end
 
         def build_select_expression(arel_table, context)
-          arel_builder = Helpers::ArelBuilder.instance(select_expression, arel_table: @arel_table)
+          arel_builder = Helpers::ArelBuilder::Attribute.instance(select_expression, arel_table: @arel_table)
           arel = arel_builder.to_arel(arel_table, context, self)
 
           arel

data/lib/params_ready/query/relation.rb

@@ -136,7 +136,7 @@ module ParamsReady
 
       def perform_count(scope: nil, context: Restriction.blanket_permission)
         scope ||= definition.model_class if definition.model_class_defined?
-        group = predicate_group(scope.arel_table, context: context)
+        group = to_query_if_eligible(scope.arel_table, context: context)
         relation = scope.where(group)
         relation = perform_joins(relation, context)
         relation.count
@@ -144,7 +144,7 @@ module ParamsReady
 
       def keysets(limit, direction, keyset, scope: nil, context: Restriction.blanket_permission, &block)
         model_class = scope || definition.model_class
-        group = predicate_group(model_class.arel_table, context: context)
+        group = to_query_if_eligible(model_class.arel_table, context: context)
         relation = model_class.where(group)
         relation = perform_joins(relation, context)
 
@@ -156,7 +156,7 @@ module ParamsReady
 
       def build_relation(scope: nil, include: [], context: Restriction.blanket_permission, paginate: true)
         model_class = scope || definition.model_class
-        group = predicate_group(model_class.arel_table, context: context)
+        group = to_query_if_eligible(model_class.arel_table, context: context)
         relation = model_class.where(group)
         relation = relation.includes(*include) unless include.empty?
         relation = perform_joins(relation, context)
@@ -165,9 +165,12 @@ module ParamsReady
       end
 
       def perform_joins(relation, context)
-        return relation if definition.joins.empty?
+        eligible_joins = definition.joins.select do |join|
+          join.eligible?(context, self)
+        end
+        return relation if eligible_joins.empty?
 
-        sql = joined_tables(relation.arel_table, context).join_sources.map(&:to_sql).join(' ')
+        sql = join_tables(eligible_joins, relation.arel_table, context).join_sources.map(&:to_sql).join(' ')
         relation.joins(sql)
       end
 
@@ -176,7 +179,7 @@ module ParamsReady
 
         arel_table = joined_tables(model_class.arel_table, context)
 
-        group = self.predicate_group(model_class.arel_table, context: context)
+        group = to_query_if_eligible(model_class.arel_table, context: context)
 
         query = if group.nil?
           arel_table
@@ -200,7 +203,7 @@ module ParamsReady
       def build_query(model_class, context)
         arel_table = arel_table(model_class)
 
-        group = self.predicate_group(arel_table, context: context)
+        group = to_query_if_eligible(arel_table, context: context)
         joined = joined_tables(arel_table, context)
 
         query = if group.nil?
@@ -212,6 +215,12 @@ module ParamsReady
         [arel_table, query]
       end
 
+      def to_query_if_eligible(arel_table, context:)
+        return if respond_to?(:to_query?) && !to_query?(arel_table, context)
+
+        predicate_group(arel_table, context: context)
+      end
+
       def order_if_applicable(arel_table, context)
         if child_is_definite?(:ordering) && (context.permitted?(ordering) || ordering.required?)
           ordering = self.ordering.to_arel(arel_table, context: context)
@@ -248,16 +257,23 @@ module ParamsReady
         query
       end
 
-      def joined_tables(proper_table, context)
-        definition.joins.reduce(proper_table) do |table, join|
-          join.to_arel(table, context, self)
+      def joined_tables(base_table, context)
+        join_tables(definition.joins, base_table, context)
+      end
+
+      def join_tables(joins, base_table, context)
+        joins.reduce(base_table) do |joined_table, join|
+          join = join.to_arel(joined_table, base_table, context, self)
+          next joined_table if join.nil?
+
+          join
         end
       end
     end
 
     class RelationParameterBuilder < Builder
       include GroupingLike
-      include Parameter::AbstractHashParameterBuilder::HashLike
+      include Parameter::AbstractStructParameterBuilder::StructLike
       include HavingModel
 
       def self.instance(name, altn: nil)
@@ -288,9 +304,8 @@ module ParamsReady
         add ordering
       end
 
-      def join_table(arel_table, type, &block)
-        join = Join.new arel_table, type, &block
-        join.freeze
+      def join_table(arel_table, type, table_alias: nil, &block)
+        join = Join.new arel_table, type, table_alias: nil, &block
         @definition.add_join(join)
       end
     end

data/lib/params_ready/query/structured_grouping.rb

@@ -1,4 +1,4 @@
-require_relative '../parameter/hash_parameter'
+require_relative '../parameter/struct_parameter'
 require_relative '../parameter/value_parameter'
 require_relative 'fixed_operator_predicate'
 require_relative 'nullness_predicate'
@@ -6,7 +6,7 @@ require_relative 'grouping'
 
 module ParamsReady
   module Query
-    class StructuredGrouping < Parameter::HashParameter
+    class StructuredGrouping < Parameter::StructParameter
       include Parameter::GroupingLike
       def predicates
         return [] if is_nil?
@@ -29,7 +29,7 @@ module ParamsReady
 
     class StructuredGroupingBuilder < Builder
       include GroupingLike
-      include Parameter::AbstractHashParameterBuilder::HashLike
+      include Parameter::AbstractStructParameterBuilder::StructLike
       PredicateRegistry.register_predicate :structured_grouping_predicate, self
 
       def self.instance(name, altn: nil)
@@ -37,7 +37,7 @@ module ParamsReady
       end
     end
 
-    class StructuredGroupingDefinition < Parameter::HashParameterDefinition
+    class StructuredGroupingDefinition < Parameter::StructParameterDefinition
       attr_reader :arel_table, :predicates
 
       def initialize(*args, **opts)

data/lib/params_ready/query/variable_operator_predicate.rb

@@ -1,5 +1,5 @@
 require_relative 'predicate'
-require_relative '../parameter/hash_parameter'
+require_relative '../parameter/struct_parameter'
 require_relative '../parameter/value_parameter'
 require_relative '../value/validator'
 require_relative 'predicate_operator'
@@ -12,7 +12,7 @@ module ParamsReady
 
       def initialize(definition)
         super definition
-        @data = definition.hash_parameter.create
+        @data = definition.struct_parameter.create
       end
 
       def build_query(select_expression, context: nil)
@@ -33,8 +33,8 @@ module ParamsReady
 
       def inspect_content
         op, val = if is_definite?
-          op = @data[:operator].unwrap_or(nil)&.name || '?'
-          val = @data[:value].unwrap_or('?')
+          @data[:operator].unwrap_or(nil)&.name || '?'
+          @data[:value].unwrap_or('?')
         else
           %w[? ?]
         end
@@ -64,7 +64,7 @@ module ParamsReady
       PredicateRegistry.register_predicate :variable_operator_predicate, self
       include HavingType
       include HavingAttribute
-      include DelegatingBuilder[:hash_parameter_builder]
+      include DelegatingBuilder[:struct_parameter_builder]
 
       def self.instance(name, altn: nil, attr: nil)
         new VariableOperatorPredicateDefinition.new name, altn: altn, attribute_name: attr
@@ -82,19 +82,19 @@ module ParamsReady
     class VariableOperatorPredicateDefinition < AbstractPredicateDefinition
       include HavingAttribute
 
-      attr_reader :hash_parameter_builder
-      attr_reader :hash_parameter
+      attr_reader :struct_parameter_builder
+      attr_reader :struct_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)
+        @struct_parameter_builder = Builder.builder(:struct).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
+        @struct_parameter_builder.add @type.finish
       end
 
       def set_operators(array, &block)
@@ -107,12 +107,12 @@ module ParamsReady
           constrain :enum, operators
         end
         @operator_parameter_builder.include(&block) unless block.nil?
-        @hash_parameter_builder.add @operator_parameter_builder.build
+        @struct_parameter_builder.add @operator_parameter_builder.build
       end
 
       def finish
-        @hash_parameter = @hash_parameter_builder.build
-        @hash_parameter_builder = nil
+        @struct_parameter = @struct_parameter_builder.build
+        @struct_parameter_builder = nil
         @operator_parameter_builder = nil
         @type = nil