params_ready 0.0.1

data/lib/params_ready/parameter/value_parameter.rb

@@ -0,0 +1,182 @@
+require_relative 'parameter'
+require_relative '../value/validator'
+require_relative '../value/coder'
+require_relative 'definition'
+require_relative '../builder'
+
+module ParamsReady
+  module Parameter
+    class ValueParameter < Parameter
+      def_delegators :@definition, :coder
+
+      def marshal(intent)
+        return nil if is_nil?
+
+        value = bare_value
+        return value unless intent.marshal?(name_for_formatter)
+
+        coder.format(value, intent)
+      end
+
+      protected
+
+      def update_self(value)
+        clone = dup
+        clone.set_value value
+
+        if frozen?
+          if clone == self
+            return false, self
+          else
+            [true, clone.freeze]
+          end
+        else
+          [true, clone]
+        end
+      end
+
+      def populate_with(value)
+        @value = value.dup
+      end
+    end
+
+    class ValueParameterBuilder < Builder
+      module ValueLike
+        def constrain(name_or_constraint, *args, strategy: :raise, **opts, &block)
+          validator = Value::Validator.instance(name_or_constraint, *args, strategy: strategy, **opts, &block)
+          @definition.add_constraint validator
+        end
+
+        def coerce(&block)
+          @definition.set_coerce(block)
+        end
+
+        def format(&block)
+          @definition.set_format(block)
+        end
+
+        def type_identifier(name)
+          @definition.set_type_identifier(name)
+        end
+      end
+
+      include ValueLike
+      extend Extensions::Registry
+
+      register :value
+
+      registry :coders, as: :coder, getter: true do |name, _|
+        builder_class = ValueParameterBuilder[name]
+        builder_class.register name
+      end
+
+      def self.instance(name, coder_or_name = nil, altn: nil)
+        coder = if coder_or_name.is_a? Symbol
+          self.coder(coder_or_name)
+        elsif coder_or_name.nil?
+          Value::GenericCoder.new(name)
+        else
+          coder_or_name
+        end
+        new ValueParameterDefinition.new(name, coder, altn: altn)
+      end
+
+      def self.[](type)
+        builder = Class.new(self)
+        capitalized = type.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)
+        end
+
+        builder
+      end
+
+      register_coder :integer, Value::IntegerCoder
+      register_coder :decimal, Value::DecimalCoder
+      register_coder :string, Value::StringCoder
+      register_coder :symbol, Value::SymbolCoder
+      register_coder :boolean, Value::BooleanCoder
+      register_coder :date, Value::DateCoder
+      register_coder :datetime, Value::DateTimeCoder
+    end
+
+    class ValueParameterDefinition < Definition
+      extend Forwardable
+      def_delegators :@coder, :set_coerce, :set_format, :set_type_identifier
+
+      name_for_formatter :value
+
+      def name_for_formatter
+        coder_name = @coder.type_identifier
+        return coder_name unless coder_name.nil?
+
+        super
+      end
+
+      parameter_class ValueParameter
+
+      module ValueLike
+        def duplicate_value(value)
+          value.dup
+        end
+
+        def freeze_value(value)
+          value.freeze
+        end
+      end
+
+      include ValueLike
+
+      attr_reader :coder
+
+      collection :constraints, :constraint do |constraint|
+        raise ParamsReadyError, "Can't constrain after default has been set" if default_defined?
+        constraint
+      end
+
+      def initialize(name, coder, *args, constraints: [], **options)
+        @coder = coder
+        @constraints = constraints
+        super name, *args, **options
+      end
+
+      def try_canonicalize(input, context, validator = nil)
+        value = coder.try_coerce input, context
+        return value if Extensions::Undefined.value_indefinite?(value)
+
+        value, validator = validate value, validator
+        if validator.nil? || validator.ok?
+          [value.freeze, validator]
+        else
+          [nil, validator]
+        end
+      end
+
+      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})"
+        end
+        validate coerced
+        coerced
+      end
+
+      def validate(value, validator = nil)
+        constraints.reduce([value, validator]) do |(value, validator), constraint|
+          constraint.validate value, validator
+        end
+      end
+
+      def finish
+        @coder.finish if @coder.respond_to?(:finish)
+        super
+      end
+    end
+  end
+end

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,43 @@
+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(method, params, context = Format.instance(:frontend), validator = nil)
+      definition = create_state_for method
+      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
+    end
+  end
+end

data/lib/params_ready/query/array_grouping.rb

@@ -0,0 +1,68 @@
+require_relative '../parameter/hash_parameter'
+require_relative '../parameter/array_parameter'
+require_relative 'grouping'
+require_relative 'predicate'
+
+module ParamsReady
+  module Query
+    class ArrayGrouping < Parameter::HashParameter
+      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::AbstractHashParameterBuilder::HashLike
+      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::HashParameterDefinition
+      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::AbstractHashParameterBuilder::HashLike
+      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