params_ready_rails5 0.0.7

data/lib/params_ready/parameter/polymorph_parameter.rb

@@ -0,0 +1,172 @@
+require_relative 'parameter'
+require_relative 'polymorph_parameter'
+require_relative 'value_parameter'
+require_relative '../marshaller/parameter_module'
+require_relative '../marshaller/definition_module'
+require_relative '../marshaller/builder_module'
+require_relative '../marshaller/polymorph_marshallers'
+
+module ParamsReady
+  module Parameter
+    class PolymorphParameter < Parameter
+      include ComplexParameter
+      include Marshaller::ParameterModule
+
+      def_delegators :@definition, :identifier, :types
+      intent_for_children :restriction
+
+      def permission_depends_on
+        type = to_type
+        return [] if type.nil?
+        [type]
+      end
+
+      def set_value_as(value, type, context = Format.instance(:backend), validator = nil)
+        parameter = types[type].create
+        parameter.set_value value, context, validator
+        @value = parameter
+      end
+
+      def type
+        return nil unless is_definite?
+        bare_value.name
+      end
+
+      def to_type
+        bare_value
+      end
+
+      def [](key)
+        raise ParamsReadyError, "Type '#{key}' is not set, current type: nil" if is_nil?
+
+        param = bare_value
+        if param.name != key
+          raise ParamsReadyError, "Type '#{key}' is not set, current type: '#{param.name}'"
+        else
+          param
+        end
+      end
+
+      protected
+
+      def child_for_update(path)
+        type, *path = path
+        [self[type], type, path]
+      end
+
+      def updated_clone(_child_name, updated)
+        clone = definition.create
+        clone.populate_with(updated, frozen?)
+        clone
+      end
+
+      def populate_with(value, freeze = false)
+        @value = if freeze && value.frozen?
+          value
+        else
+          value.dup
+        end
+
+        self.freeze if freeze
+        self
+      end
+    end
+
+    class PolymorphParameterBuilder < Builder
+      include Marshaller::BuilderModule
+
+      register :polymorph
+
+      def self.instance(name, altn: nil)
+        new PolymorphParameterDefinition.new(name, altn: altn)
+      end
+
+      def type(input, *args, **opts, &block)
+        definition = self.class.resolve(input, *args, **opts, &block)
+        @definition.add_type definition
+      end
+
+      def identifier(identifier)
+        @definition.set_identifier identifier
+      end
+    end
+
+    class PolymorphParameterDefinition < Definition
+      include ValueParameterDefinition::ValueLike
+      include Marshaller::DefinitionModule[Marshaller::PolymorphMarshallers.collection]
+
+      obligatory! :types
+      attr_reader :types
+      # late_init :identifier, obligatory: true
+
+      parameter_class PolymorphParameter
+      name_for_formatter :polymorph
+
+      def initialize(*args, identifier: nil, types: [], default_name: nil, **options)
+        @types = {}
+        @alt_names = {}
+        add_types types
+        set_default(default_name)
+        super *args, **options
+        set_identifier identifier unless identifier.nil?
+      end
+
+      def add_type(definition)
+        check_type_names(definition)
+        raise ParamsReadyError, "Reused name: #{definition.name}" if @types.key? definition.name
+        raise ParamsReadyError, "Reused alternative: #{definition.altn}" if @alt_names.key? definition.altn
+        @types[definition.name] = definition
+        @alt_names[definition.altn] = definition
+      end
+
+      def check_type_names(definition)
+        return if @marshallers.nil?
+        return unless @marshallers.default?
+        default = @marshallers.default
+        return unless default.respond_to? :reserved?
+
+        raise ParamsReadyError, "Reserved name: #{definition.name}" if default.reserved?(definition.name)
+        raise ParamsReadyError, "Reserved alternative: #{definition.altn}" if default.reserved?(definition.altn)
+      end
+
+      def add_types(types)
+        return if types.nil?
+        types.each do |definition|
+          add_type definition
+        end
+      end
+
+      def set_identifier(type_identifier)
+        raise ParamsReadyError, "Identifier already taken: #{type_identifier}" if @alt_names&.key?(type_identifier)
+        raise ParamsReadyError, "Identifier already taken: #{type_identifier}" if @types&.key?(type_identifier)
+        set_marshaller using: :hash, type_identifier: type_identifier
+      end
+
+      def type(name, context)
+        name = if context.alternative?
+          @alt_names[name.to_sym].name
+        else
+          name
+        end
+        @types[name.to_sym]
+      end
+
+      def set_default(default_name)
+        return if default_name.nil?
+
+        type_def = types[default_name]
+        raise ParamsReadyError, "Unknown type '#{default_name}'" if type_def.nil?
+        raise ParamsReadyError, "Default type must have default" unless type_def.default_defined?
+        frozen = freeze_value(type_def.create)
+        @default = frozen
+      end
+
+      def finish
+        set_identifier :ppt unless marshallers.default?
+        super
+      end
+
+      freeze_variables :types
+    end
+  end
+end

data/lib/params_ready/parameter/state.rb

@@ -0,0 +1,132 @@
+require_relative '../error'
+require_relative '../../params_ready/parameter/struct_parameter'
+require_relative '../query/relation'
+
+module ParamsReady
+  module Parameter
+    class State < StructParameter
+      extend Query::Relation::PageAccessors
+      extend Forwardable
+      def_delegators :definition, :relations
+
+      def relation(name)
+        raise ParamsReadyError, "Relation not defined: '#{name}'" unless relations.include? name
+        child(name)
+      end
+
+      def self.relation_delegator(name)
+        define_method name do |relation_name, *args|
+          relation(relation_name).send(name, *args)
+        end
+        ruby2_keywords name
+      end
+
+      relation_delegator :ordering
+      relation_delegator :num_pages
+      relation_delegator :page_no
+      relation_delegator :offset
+      relation_delegator :limit
+      relation_delegator :has_previous?
+      relation_delegator :has_previous?
+      relation_delegator :has_next?
+      relation_delegator :has_page?
+
+      def page(relation_name = nil, delta = 0, count: nil)
+        if delta == 0
+          clone
+        else
+          raise ParamsReadyError, "Relation must be specified when delta is not 0" if relation_name.nil?
+
+          return nil unless relation(relation_name).pagination.can_yield_page? delta, count: count
+          new_offset = relation(relation_name).new_offset(delta)
+          update_in(new_offset, [relation_name, :pagination, 0])
+        end
+      end
+
+      def current_page
+        page
+      end
+
+      def first_page(relation_name)
+        value = relation(relation_name).pagination.first_page_value
+        update_in(value, [relation_name, :pagination])
+      end
+
+      def last_page(relation_name, *args, **opts)
+        value = relation(relation_name).pagination.last_page_value(*args, **opts)
+        return if value.nil?
+        update_in(value, [relation_name, :pagination])
+      end
+
+      def previous_page(relation_name, delta = 1)
+        value = relation(relation_name).pagination.previous_page_value(delta)
+        return if value.nil?
+        update_in(value, [relation_name, :pagination])
+      end
+
+      def next_page(relation_name, delta = 1, count: nil)
+        value = relation(relation_name).pagination.next_page_value(delta, count: count)
+        return if value.nil?
+        update_in(value, [relation_name, :pagination])
+      end
+
+      def before_page(relation_name, keyset)
+        value = relation(relation_name).pagination.before_page_value(keyset)
+        update_in(value, [relation_name, :pagination])
+      end
+
+      def after_page(relation_name, keyset)
+        value = relation(relation_name).pagination.after_page_value(keyset)
+        update_in(value, [relation_name, :pagination])
+      end
+
+      def limited_at(relation_name, limit)
+        limit_key = relation(relation_name).pagination.limit_key
+        update_in(limit, [relation_name, :pagination, limit_key])
+      end
+
+      def toggled_order(relation_name, column)
+        new_order = relation(relation_name).ordering.toggled_order_value(column)
+        toggled = update_in(new_order, [relation_name, :ordering])
+        toggled.first_page(relation_name)
+      end
+
+      def reordered(relation_name, column, direction)
+        new_order = relation(relation_name).ordering.reordered_value(column, direction)
+        reordered = update_in(new_order, [relation_name, :ordering])
+        reordered.first_page(relation_name)
+      end
+    end
+
+    class StateBuilder < StructParameterBuilder
+      def relation(relation)
+        @definition.add_relation relation
+      end
+
+      def self.instance
+        definition = StateDefinition.new(:'', altn: :'')
+        new definition
+      end
+    end
+
+    class StateDefinition < StructParameterDefinition
+      parameter_class State
+      attr_reader :relations
+
+      def initialize(*args, **opts)
+        super *args, **opts
+        @relations = Set.new
+      end
+
+      def add_relation(relation)
+        if @relations.include? relation.name
+          raise ParamsReadyError, "Relation already there '#{relation.name}'"
+        end
+        @relations << relation.name
+        add_child relation
+      end
+
+      freeze_variable :relations
+    end
+  end
+end

data/lib/params_ready/parameter/struct_parameter.rb

@@ -0,0 +1,64 @@
+require_relative 'parameter'
+require_relative '../builder'
+require_relative 'abstract_struct_parameter'
+require_relative '../marshaller/parameter_module'
+
+
+module ParamsReady
+  module Parameter
+    class StructParameter < AbstractStructParameter
+      include Marshaller::ParameterModule
+    end
+
+    class StructParameterBuilder < Builder
+      include AbstractStructParameterBuilder::StructLike
+      include Marshaller::BuilderModule
+      register :struct
+      register_deprecated :hash, use: :struct
+
+      def self.instance(name, altn: nil)
+        new StructParameterDefinition.new(name, altn: altn)
+      end
+
+      def map(hash)
+        @definition.add_map(hash, **{})
+      end
+    end
+
+    class StructParameterDefinition < AbstractStructParameterDefinition
+      include Marshaller::DefinitionModule[Marshaller::StructMarshallers.collection]
+
+      name_for_formatter :struct
+      parameter_class StructParameter
+      freeze_variables :key_map
+
+      def ensure_canonical(hash)
+        context = Format.instance(:backend)
+
+        value, _validator = try_canonicalize hash, context, nil, freeze: true
+        return value if value.length == hash.length
+
+        extra_keys = hash.keys.select do |key|
+          !value.key?(key)
+        end.map do |key|
+          "'#{key.to_s}'"
+        end.join(", ")
+        raise ParamsReadyError, "extra keys found -- #{extra_keys}" if extra_keys.length > 0
+        value
+      end
+
+
+      def add_map(hash)
+        @key_map ||= Helpers::KeyMap.new
+        hash.each do |key, value|
+          @key_map.map(key, to: value)
+        end
+      end
+
+      def remap?(context)
+        return false if key_map.nil?
+        context.remap?
+      end
+    end
+  end
+end

data/lib/params_ready/parameter/tuple_parameter.rb

@@ -0,0 +1,152 @@
+require 'set'
+require_relative 'parameter'
+require_relative '../builder'
+require_relative 'definition'
+require_relative 'array_parameter'
+require_relative '../marshaller/tuple_marshallers'
+require_relative '../marshaller/definition_module'
+require_relative '../marshaller/builder_module'
+require_relative '../marshaller/parameter_module'
+
+module ParamsReady
+  module Parameter
+    class TupleParameter < Parameter
+      include ArrayParameter::ArrayLike
+      include Marshaller::ParameterModule
+
+      def_delegators :@definition, :names, :fields, :separator, :marshaller
+
+      freeze_variable :value do |array|
+        next if Extensions::Undefined.value_indefinite?(array)
+        array.each(&:freeze)
+      end
+
+      def method_missing(name, *args)
+        integer = ordinal_to_integer(name)
+        if integer.nil?
+          super
+        else
+          self[integer - 1]
+        end
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        return true unless ordinal_to_integer(name).nil?
+        super
+      end
+
+      protected
+
+      def element(index)
+        return nil if is_nil?
+
+        value = bare_value
+        if index < 0 || index >= value.length
+          raise ParamsReadyError, "Index out of bounds: #{index}"
+        else
+          value[index]
+        end
+      end
+
+      ORDINALS = %i{
+        first second third fourth fifth sixth seventh eighth nineth tenth
+      }.each_with_index.map do |ordinal, index|
+        [ordinal, index + 1]
+      end.to_h.freeze
+
+      def ordinal_to_integer(name)
+        integer = ORDINALS[name]
+        return nil if integer.nil?
+        return nil if definition.arity < integer
+
+        integer
+      end
+
+      def init_value
+        @value = []
+        fields.each do |definition|
+          @value << definition.create
+        end
+      end
+    end
+
+    class TupleParameterBuilder < Builder
+      include Marshaller::BuilderModule
+      register :tuple
+
+      def self.instance(name, altn: nil)
+        new TupleParameterDefinition.new(name, altn: altn)
+      end
+
+      def field(input, *args, **opts, &block)
+        definition = self.class.resolve(input, *args, **opts, &block)
+        @definition.add_field definition
+      end
+    end
+
+    class TupleParameterDefinition < Definition
+      include ArrayParameterDefinition::ArrayLike
+      include Marshaller::DefinitionModule[Marshaller::TupleMarshallers.collection]
+
+      class StringMarshaller
+        def initialize(separator:)
+          @separator = separator
+        end
+
+        def marshal(fields, _format)
+          fields.join(@separator)
+        end
+      end
+
+      class StructMarshaller
+        def marshal(fields, _format)
+          fields.each_with_index.map do |field, index|
+            [index.to_s, field]
+          end.to_h
+        end
+      end
+
+      name_for_formatter :tuple
+
+      parameter_class TupleParameter
+
+      def initialize(*args, separator: nil, fields: nil, **options)
+        @fields = []
+        add_fields fields unless fields.nil?
+        super *args, **options
+      end
+
+      def add_fields(fields)
+        fields.each do |field|
+          add_field(field)
+        end
+      end
+
+      collection :fields, :field do |field|
+        raise ParamsReadyError, "Can't add field if default is present" if default_defined?
+        raise ParamsReadyError, "Not a field definition #{field.class.name}" unless field.is_a? AbstractDefinition
+        raise ParamsReadyError, "Field is not a value #{field.class.name}" unless field.is_a? ValueParameterDefinition
+        raise ParamsReadyError, "Field can't be optional" if field.optional?
+        raise ParamsReadyError, "Field can't have default" if field.default_defined?
+        field
+      end
+
+      def arity
+        @fields.length
+      end
+
+      def ensure_canonical(array)
+        raise ParamsReadyError, "Not an array" unless array.is_a? Array
+        context = Format.instance(:backend)
+        marshaller = marshallers.instance(Array)
+        value, _validator = marshaller.canonicalize(self, array, context, nil, freeze: true)
+        value
+      end
+
+      def freeze
+        @fields.freeze
+        super
+      end
+    end
+  end
+end

data/lib/params_ready/parameter/value_parameter.rb

@@ -0,0 +1,186 @@
+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, **opts)
+        coder = if coder_or_name.is_a? Symbol
+          coder_class = self.coder(coder_or_name)
+          coder_class.instance(**opts)
+        else
+          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.[](coder_name)
+        builder = Class.new(self)
+        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, **opts|
+          superclass.instance(name, coder_name, altn: altn, **opts)
+        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 if @coder.respond_to? :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} (expected '#{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