params_ready_rails5 0.0.7

data/lib/params_ready/parameter/abstract_struct_parameter.rb

@@ -0,0 +1,204 @@
+require_relative 'parameter'
+require_relative '../helpers/key_map'
+require_relative '../marshaller/struct_marshallers'
+require_relative '../marshaller/builder_module'
+require_relative '../marshaller/definition_module'
+
+module ParamsReady
+  module Parameter
+    using Extensions::Hash
+
+    class AbstractStructParameter < Parameter
+      include ComplexParameter
+
+      def_delegators :@definition, :names, :remap?
+      intent_for_children :restriction
+
+      EMPTY_HASH = '0'
+
+      freeze_variable :value do |value|
+        next if value.nil? || value == Extensions::Undefined
+
+        value.values.each do |child|
+          child.freeze
+        end
+      end
+
+      def []=(name, value)
+        init_for_write
+        c = child(name)
+        c.set_value(value)
+      end
+
+      def [](name)
+        child(name)
+      end
+
+      def find_in_hash(hash, context)
+        found, result = super hash, context
+
+        if !(default_defined? || optional?) && result == Extensions::Undefined
+          # nil value for non-default and non-optional hash means
+          # children may be able to set themselves if they have defaults
+          [true, {}]
+        elsif result == EMPTY_HASH
+          [true, {}]
+        else
+          [found, result]
+        end
+      end
+
+      def wrap_output(output, intent)
+        if (output.nil? || output.empty?) && !default_defined? && !optional?
+          nil
+        else
+          super
+        end
+      end
+
+      def for_output(format, restriction: nil, data: nil)
+        restriction ||= Restriction.blanket_permission
+
+        intent = Intent.new(format, restriction, data: data)
+        output = format(intent)
+        return {} if output.nil? || output == EMPTY_HASH
+        output
+      end
+
+      def for_frontend(format = :frontend, restriction: nil, data: nil)
+        for_output(format, restriction: restriction, data: data)
+      end
+
+      def for_model(format = :update, restriction: nil)
+        for_output(format, restriction: restriction)
+      end
+
+      protected
+
+      def child_for_update(path)
+        child_name, *path = path
+        [self[child_name], child_name, path]
+      end
+
+      def updated_clone(name, updated)
+        clone = definition.create
+        frozen = frozen? || @value&.frozen?
+        clone.populate_with(bare_value, frozen, name => updated)
+      end
+
+      def child(name)
+        return nil if is_nil?
+
+        value = bare_value
+        raise ParamsReadyError, "No such name: #{name}" unless names.key? name
+        if value.key? name
+          value[name]
+        else
+          child = definition.child_definition(name).create
+          raise ParamsReadyError, "Expected definite value for '#{name}' parameter" if child.nil?
+          place(name, child) unless frozen?
+          child
+        end
+      end
+
+      def populate_with(hash, freeze = false, **replacement)
+        @value = {}
+        names.each_key do |name|
+          incoming = replacement[name] || hash[name]
+
+          own = if freeze && incoming.frozen?
+            incoming
+          else
+            incoming.dup
+          end
+
+          own.freeze if freeze
+
+          place(name, own)
+        end
+
+        self.freeze if freeze
+        self
+      end
+
+      def place(name, child)
+        @value[name] = child
+      end
+
+      def init_value
+        @value = names.map do |name, definition|
+          [name, definition.create]
+        end.to_h
+      end
+    end
+
+    module AbstractStructParameterBuilder
+      include Marshaller::BuilderModule
+
+      module StructLike
+        def add(input, *args, **opts, &block)
+          definition = self.class.resolve(input, *args, **opts, &block)
+          @definition.add_child definition
+        end
+      end
+    end
+
+    class AbstractStructParameterDefinition < Definition
+      attr_reader :key_map
+
+      def duplicate_value(value)
+        value.values.map do |param|
+          [param.name, param.dup]
+        end.to_h
+      end
+
+      def freeze_value(value)
+        value.values.each(&:freeze)
+        value.freeze
+      end
+
+      attr_reader :names
+
+      def initialize(*args, **options)
+        super *args, **options
+        @key_map = nil
+        @names = {}
+      end
+
+      def child_definition(name)
+        raise ParamsReadyError, "No such name: #{name}" unless names.key? name
+        names[name]
+      end
+
+      def has_child?(name)
+        names.key? name
+      end
+
+      def set_default(value)
+        value = infer_default if value == :inferred
+        super(value)
+      end
+
+      def infer_default
+        names.reduce({}) do |result, pair|
+          child_def = pair[1]
+          unless child_def.default_defined?
+            raise ParamsReadyError, "Can't infer default, child '#{definition.name}' is not optional and has no default" unless child_def.optional?
+          else
+            result[child_def.name] = child_def.default
+          end
+          result
+        end
+      end
+
+      def add_child(child)
+        raise ParamsReadyError, "Not a parameter definition: '#{child.class.name}'" unless child.is_a?(AbstractDefinition)
+        raise ParamsReadyError, "Name already there: '#{child.name}'" if @names.key?(child.name)
+        raise ParamsReadyError, "Child can't be added after default has been set" if default_defined?
+        @names[child.name] = child
+      end
+
+      freeze_variables :names
+    end
+  end
+end

data/lib/params_ready/parameter/array_parameter.rb

@@ -0,0 +1,197 @@
+require_relative 'parameter'
+require_relative 'definition'
+require_relative 'abstract_struct_parameter'
+require_relative '../builder'
+require_relative '../marshaller/array_marshallers'
+require_relative '../marshaller/builder_module'
+require_relative '../marshaller/definition_module'
+require_relative '../marshaller/parameter_module'
+
+module ParamsReady
+  module Parameter
+    class ArrayParameter < Parameter
+      module ArrayLike
+        include ComplexParameter
+
+        def []=(index, value)
+          init_for_write
+          c = element(index)
+          c.set_value value
+        end
+
+        def [](index)
+          if index == :cnt || index == 'cnt'
+            count = ValueParameterBuilder.instance(:cnt, :integer).build.create
+            count.set_value(self.length)
+            count.freeze
+            count
+          else
+            element(index)
+          end
+        end
+
+        protected
+
+        def updated_clone(index, updated_child)
+          clone = definition.create
+          clone.populate_with(bare_value, frozen?, { index => updated_child })
+          clone
+        end
+
+        def child_for_update(path)
+          index, *child_path = path
+          child = element(index)
+          raise ParamsReadyError, "No element at index '#{index}' in '#{name}'" if child.nil?
+          [child, index, child_path]
+        end
+
+        def populate_with(array, freeze = false, replacement = {})
+          @value = []
+          array.each_with_index do |element, index|
+            incoming = replacement[index] || element
+
+            own = if freeze && incoming.frozen?
+              incoming
+            else
+              incoming.dup
+            end
+
+            own.freeze if freeze
+
+            @value << own
+          end
+
+          self.freeze if freeze
+          self
+        end
+      end
+
+      include ArrayLike
+      include Marshaller::ParameterModule
+
+      intent_for_children :delegate do
+        definition.prototype.name
+      end
+
+      def_delegators :@definition, :prototype
+      def_delegators :bare_value, :length, :count, :each, :each_with_index, :map, :reduce, :to_a
+
+      freeze_variable :value do |array|
+        array.each(&:freeze)
+      end
+
+      def <<(value)
+        init_for_write
+        c = element(length, for_write: true)
+        c.set_value value
+        self
+      end
+
+      protected
+
+      def element(index, for_write: false)
+        return nil if is_nil?
+
+        value = bare_value
+        if value.length > index
+          value[index]
+        elsif value.length == index && for_write
+          value << prototype.create
+          value[index]
+        else
+          nil
+        end
+      end
+
+      def init_value
+        @value = []
+      end
+    end
+
+    class ArrayParameterBuilder < Builder
+      module ArrayLike
+        def prototype(input, name = nil, *args, altn: nil, **opts, &block)
+          name ||= :element
+          altn ||= :elm
+          definition = self.class.resolve(input, name, *args, altn: altn, **opts, &block)
+          @definition.set_prototype definition
+        end
+      end
+
+      include ArrayLike
+      register :array
+      include Marshaller::BuilderModule
+
+      def self.instance(name, altn: nil)
+        new ArrayParameterDefinition.new(name, altn: altn)
+      end
+
+      def compact
+        @definition.set_compact true
+      end
+    end
+
+    class ArrayParameterDefinition < Definition
+      name_for_formatter :array
+      include Marshaller::DefinitionModule[Marshaller::ArrayMarshallers.collection]
+
+      module ArrayLike
+        def duplicate_value(value)
+          value.map do |param|
+            param.dup
+          end
+        end
+
+        def freeze_value(value)
+          value.each(&:freeze)
+          value.freeze
+        end
+      end
+
+      include ArrayLike
+
+      parameter_class ArrayParameter
+
+      def initialize(*args, prototype: nil, **options)
+        raise ParamsReadyError, "Not a definition: #{prototype.class.name}" unless (prototype.is_a?(Definition) || prototype.nil?)
+        @prototype = prototype
+        super *args, **options
+      end
+
+      def set_default(args)
+        raise ParamsReadyError, "Can't set default before prototype has been defined" if @prototype.nil?
+        super
+      end
+
+      late_init :prototype do |prototype|
+        raise ParamsReadyError, "Can't set prototype after default has been set" if default_defined?
+        prototype
+      end
+
+      late_init :compact, obligatory: false, boolean: true, getter: false
+
+      def ensure_canonical(array)
+        raise "Not a canonical value, array expected, got: '#{array.class.name}'" unless array.is_a? Array
+        context = Format.instance(:backend)
+        value, _validator = try_canonicalize(array, context, nil, freeze: true)
+        value
+      end
+
+      def try_canonicalize(value, context, validator = nil, freeze: false)
+        if freeze
+          marshaller = marshallers.instance(Array)
+          marshaller.canonicalize self, value, context, validator, freeze: freeze
+        else
+          super value, context, validator
+        end
+      end
+
+      def finish
+        if compact? && (prototype&.default_defined?)
+          raise ParamsReadyError, 'Prototype must not be optional nor have default in compact array parameter'
+        end
+        super
+      end
+    end
+  end
+end

data/lib/params_ready/parameter/definition.rb

@@ -0,0 +1,272 @@
+require_relative '../extensions/freezer'
+require_relative '../extensions/finalizer'
+require_relative '../error'
+require_relative '../extensions/class_reader_writer'
+require_relative '../extensions/collection'
+require_relative '../extensions/delegation'
+require_relative '../extensions/late_init'
+require_relative '../extensions/undefined'
+require_relative '../input_context'
+require_relative '../result'
+require_relative '../helpers/conditional_block'
+require_relative '../helpers/callable'
+
+module ParamsReady
+  module Parameter
+    class AbstractDefinition
+      extend Extensions::Freezer
+      include Extensions::Freezer::InstanceMethods
+      extend Extensions::Finalizer
+      include Extensions::Finalizer::InstanceMethods
+      extend Extensions::ClassReaderWriter
+      extend Extensions::LateInit
+      extend Extensions::Collection
+
+      attr_reader :name, :altn
+
+      def parameter_class
+        self.class.parameter_class
+      end
+
+      def initialize(name, altn: nil)
+        @name = name.to_sym
+        @altn = normalize_alternative_name(altn || name)
+      end
+
+      def normalize_alternative_name(name)
+        if name.is_a? Array
+          name.map(&:to_sym)
+        else
+          name.to_sym
+        end
+      end
+
+      class_reader_writer :parameter_class
+      collection :helpers, :helper
+
+      def create
+        raise ParamsReadyError, "Can't create '#{name}' using unfrozen definition" unless frozen?
+        instance = parameter_class.new self
+        if @helpers
+          singleton = class << instance; self; end
+          @helpers.each do |(name, block)|
+            if singleton.method_defined? name
+              raise ParamsReadyError, "Helper '#{name}' overrides existing method"
+            end
+
+            singleton.send :define_method, name, &block
+          end
+        end
+        instance
+      end
+
+      def from_hash(hash, context: nil, validator: Result.new(name))
+        context = InputContext.resolve(context)
+        instance = create
+        result = instance.set_from_hash(hash, context: context, validator: validator)
+        [result, instance]
+      end
+
+      def from_input(input, context: nil, validator: nil)
+        validator ||= Result.new(name)
+        context = InputContext.resolve(context)
+        instance = create
+        result = instance.set_from_input(input, context, validator)
+        [result, instance]
+      end
+
+      def finish
+        super
+        freeze
+      end
+    end
+
+    class Definition < AbstractDefinition
+      attr_reader :default
+
+      class_reader_writer :name_for_formatter
+
+      def name_for_formatter
+        self.class.name_for_formatter
+      end
+
+      def initialize(
+        *args,
+        default: Extensions::Undefined,
+        optional: false,
+        preprocessor: nil,
+        populator: nil,
+        postprocessor: nil,
+        no_input: nil,
+        no_output: nil,
+        **opts
+      )
+        super *args, **opts
+        @default = Extensions::Undefined
+        @optional = optional
+        @preprocessor = preprocessor
+        @postprocessor = postprocessor
+        @populator = populator
+        @no_input = no_input
+        @no_output = no_output
+
+        set_default(default) unless default == Extensions::Undefined
+      end
+
+      def default_defined?
+        return false unless defined? @default
+        return false if @default == Extensions::Undefined
+        true
+      end
+
+      def canonical_default(value)
+        return value if value.nil?
+        ensure_canonical value
+      rescue => e
+        raise ParamsReadyError, "Invalid default: #{e.message}"
+      end
+
+      late_init :populator, getter: true, once: true, obligatory: false
+      late_init :no_input, getter: false, once: false
+      late_init :no_output, getter: false, once: false
+      late_init :memoize, getter: true, obligatory: false
+
+      def memoize?
+        return false if @memoize.nil?
+
+        @memoize > 0
+      end
+
+      def set_preprocessor(rule: nil, &block)
+        raise "Preprocesser already set in '#{name}'" unless @preprocessor.nil?
+        @preprocessor = Helpers::ConditionalBlock.new(rule: rule, &block)
+      end
+
+      def set_postprocessor(rule: nil, &block)
+        raise "Postprocessor already set in '#{name}'" unless @postprocessor.nil?
+        @postprocessor = Helpers::ConditionalBlock.new(rule: rule, &block)
+      end
+
+      def preprocess(input, context, validator)
+        return input if @preprocessor.nil?
+        return input unless @preprocessor.perform?(!context.local?, context.name)
+        @preprocessor.block.call input, context, self
+      rescue => error
+        preprocessor_error = PreprocessorError.new(error)
+        if validator.nil?
+          raise preprocessor_error
+        else
+          validator.error! preprocessor_error
+          Extensions::Undefined
+        end
+      end
+
+      def postprocess(param, context, validator)
+        return if @postprocessor.nil?
+        return unless @postprocessor.perform?(!context.local?, context.name)
+        @postprocessor.block.call param, context
+      rescue => error
+        postprocessor_error = PostprocessorError.new(error)
+        if validator.nil?
+          raise postprocessor_error
+        else
+          validator.error! postprocessor_error
+        end
+        validator
+      end
+
+      def set_no_input(*arr, rule: nil)
+        @no_input = Helpers::Rule(rule) || true
+        raise ParamsReadyError, "Default not expected: #{arr}" if rule == false
+
+        set_default *arr unless arr.empty?
+      end
+
+      def set_local(*arr, rule: nil)
+        rule = Helpers::Rule(rule)
+        set_no_input(*arr, rule: rule)
+        set_no_output(rule || true)
+      end
+
+      def no_input?(format)
+        restricted_for_format?(@no_input, format)
+      end
+
+      def no_output?(format)
+        restricted_for_format?(@no_output, format)
+      end
+
+      def restricted_for_format?(rule, format)
+        case rule
+        when nil, false
+          false
+        when true
+          !format.local?
+        when Helpers::Rule
+          rule.include?(format.name)
+        else
+          raise ParamsReadyError, "Unexpected rule: #{rule}"
+        end
+      end
+
+      late_init :optional, boolean: true, getter: false, once: false
+
+      late_init :default, once: false, definite: false do |value|
+        next value if value == Extensions::Undefined
+        next value if value.is_a? Helpers::Callable
+
+        canonical = canonical_default(value)
+        next canonical if canonical.nil?
+
+        freeze_value(canonical)
+      end
+
+      def fetch_default(duplicate: true)
+        return Extensions::Undefined unless default_defined?
+        return nil if @default.nil?
+
+        if @default.is_a?(Helpers::Callable)
+          fetch_callable_default
+        else
+          return @default unless duplicate
+          duplicate_value(@default)
+        end
+      end
+
+      def fetch_callable_default
+        value = @default.call
+        value = ensure_canonical(value)
+        duplicate_value(value)
+      rescue StandardError => e
+        raise ParamsReadyError, "Invalid default: #{e.message}"
+      end
+
+
+      def finish
+        if @populator && !@no_input
+          raise ParamsReadyError, "Populator set for input parameter '#{name}'"
+        end
+
+        if @preprocessor && @no_input == true
+          raise ParamsReadyError, "Preprocessor set for no-input parameter '#{name}'"
+        end
+
+        if @postprocessor && @no_input == true
+          raise ParamsReadyError, "Postprocessor set for no-input parameter '#{name}'"
+        end
+
+        super
+      end
+    end
+
+    module DelegatingDefinition
+      def self.[](delegee_name)
+        mod = Module.new
+        Extensions::Delegation.delegate(mod) do
+          instance_variable_get(:"@#{delegee_name}")
+        end
+        mod
+      end
+    end
+  end
+end