params_ready 0.0.1

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/hash_parameter'
+require_relative '../query/relation'
+
+module ParamsReady
+  module Parameter
+    class State < HashParameter
+      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 < HashParameterBuilder
+      def relation(relation)
+        @definition.add_relation relation
+      end
+
+      def self.instance
+        definition = StateDefinition.new(:'', altn: :'')
+        new definition
+      end
+    end
+
+    class StateDefinition < HashParameterDefinition
+      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/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 HashMarshaller
+        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