params_ready 0.0.1

data/lib/params_ready/parameter/hash_parameter.rb

@@ -0,0 +1,63 @@
+require_relative 'parameter'
+require_relative '../builder'
+require_relative 'abstract_hash_parameter'
+require_relative '../marshaller/parameter_module'
+
+
+module ParamsReady
+  module Parameter
+    class HashParameter < AbstractHashParameter
+      include Marshaller::ParameterModule
+    end
+
+    class HashParameterBuilder < Builder
+      include AbstractHashParameterBuilder::HashLike
+      include Marshaller::BuilderModule
+      register :hash
+
+      def self.instance(name, altn: nil)
+        new HashParameterDefinition.new(name, altn: altn)
+      end
+
+      def map(hash)
+        @definition.add_map(hash, **{})
+      end
+    end
+
+    class HashParameterDefinition < AbstractHashParameterDefinition
+      include Marshaller::DefinitionModule[Marshaller::HashMarshallers.collection]
+
+      name_for_formatter :hash
+      parameter_class HashParameter
+      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/hash_set_parameter.rb

@@ -0,0 +1,101 @@
+require 'set'
+require_relative 'hash_parameter'
+require_relative 'value_parameter'
+require_relative '../intent'
+require_relative '../marshaller/hash_set_marshallers'
+require_relative '../marshaller/parameter_module'
+
+module ParamsReady
+  module Parameter
+    class HashSetParameter < AbstractHashParameter
+      include Marshaller::ParameterModule
+
+      def self.intent_for_set(intent)
+        Intent.new(
+          intent.format.update(
+            omit: [],
+            remap: false
+          ),
+          intent.restriction
+        )
+      end
+
+      def member?(key)
+        raise ParamsReadyError, "Key not defined: '#{key}'" unless definition.has_child? key
+
+        if is_definite?
+          bare_value[key].unwrap == true
+        else
+          false
+        end
+      end
+    end
+
+    class HashSetParameterBuilder < Builder
+      include Marshaller::BuilderModule
+
+      register :hash_set
+
+      def self.instance(name, altn: nil, type: :boolean)
+        new HashSetParameterDefinition.new(name, altn: altn, type: type)
+      end
+
+      def add(input, *args, val: nil, **opts, &block)
+        type = @definition.type
+        definition = self.class.resolve(type, input, *args, **opts, &block)
+        @definition.add_child definition, value: val
+      end
+
+
+      def self.resolve(type, input, *args, **opts, &block)
+        if input.is_a? AbstractDefinition
+          input
+        else
+          define_registered_parameter(type, input, *args, **opts, &block)
+        end
+      end
+    end
+
+    class HashSetParameterDefinition < AbstractHashParameterDefinition
+      attr_reader :type, :values
+      freeze_variable :values
+      name_for_formatter :hash_set
+      parameter_class HashSetParameter
+      include Marshaller::DefinitionModule[Marshaller::HashSetMarshallers.collection]
+
+      def initialize(*args, type: :boolean, **opts)
+        @type = type
+        @values = {}
+        super *args, **opts
+      end
+
+      def ensure_canonical(set)
+        raise ParamsReadyError, "Unexpected default type: #{set.class.name}" unless set.is_a?(Set)
+
+        context = Format.instance(:backend)
+        value, _validator = try_canonicalize set, context, nil, freeze: true
+        return value if value.length == set.length
+
+        extra_keys = set.reject do |key|
+          value.key?(key) || value.key?(key.to_s)
+        end.map do |key|
+          "'#{key.to_s}'"
+        end.join(", ")
+        raise ParamsReadyError, "extra elements found -- #{extra_keys}" if extra_keys.length > 0
+
+        value
+      end
+
+      def add_child(child, value:)
+        value = value.nil? ? child.name : value
+
+        if @values.key(value).nil?
+          @values[child.name] = value
+        else
+          raise ParamsReadyError, "Value '#{value}' already taken by '#{@values.key(value)}'"
+        end
+        super child
+      end
+    end
+  end
+end

data/lib/params_ready/parameter/parameter.rb

@@ -0,0 +1,456 @@
+require 'forwardable'
+require_relative '../extensions/freezer'
+require_relative '../error'
+require_relative '../helpers/memo'
+require_relative '../helpers/find_in_hash'
+
+module ParamsReady
+  module Parameter
+    module FromHash
+      def set_from_hash(hash, context: nil, validator: Result.new(name))
+        _, input = find_in_hash hash, context
+        set_from_input(input, context, validator)
+      end
+    end
+
+    module ComplexParameter
+      def update_child(value, path)
+        child, child_name, child_path = child_for_update(path)
+        changed, updated = child.update_if_applicable(value, child_path)
+
+        if frozen? && !changed
+          [false, self]
+        else
+          clone = updated_clone(child_name, updated)
+          [true, clone]
+        end
+      end
+    end
+
+    module DelegatingParameter
+      include ComplexParameter
+      include FromHash
+
+      def self.included(recipient)
+        recipient.freeze_variable :data
+      end
+
+      def method_missing(name, *args)
+        if @data.respond_to?(name)
+          @data.send name, *args
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        if @data.respond_to?(name, include_private)
+          true
+        else
+          super
+        end
+      end
+
+      def set_value(input, context = Format.instance(:backend), validator = nil)
+        if self.match?(input)
+          super input.unwrap, context, validator
+        else
+          super
+        end
+      end
+
+      def hash
+        [definition, data].hash
+      end
+
+      def ==(other)
+        return false unless self.match?(other)
+        data == other.data
+      end
+
+      alias_method :eql?, :==
+
+      protected
+
+      def child_for_update(path)
+        [@data, nil, *path]
+      end
+
+      def updated_clone(_child_name, updated)
+        clone = definition.create
+        clone.instance_variable_set :@data, updated
+        clone.freeze if frozen?
+        clone
+      end
+
+      def set_from_input(input, context, validator)
+        if self.match?(input)
+          super input.unwrap, context, validator
+        else
+          super
+        end
+      end
+
+      def populate_other(other)
+        data.populate_other(other.data)
+      end
+    end
+
+    class AbstractParameter
+      attr_reader :definition
+      extend Forwardable
+      extend Extensions::Freezer
+      include Extensions::Freezer::InstanceMethods
+      include FromHash
+
+      def_delegators :@definition, :name, :altn, :name_for_formatter
+
+      def self.intent_for_children(method, &block)
+        case method
+        when :restriction
+          raise ParamsReadyError, "Block unexpected for '#{method}' method" unless block.nil?
+          define_method :intent_for_children do |intent|
+            intent.for_children(self)
+          end
+        when :delegate
+          define_method :intent_for_children do |intent|
+            delegate_name, *others = self.instance_eval(&block)
+            intent.delegate(self, delegate_name, *others)
+          end
+        when :pass
+          raise ParamsReadyError, "Block unexpected for '#{method}' method" unless block.nil?
+          define_method :intent_for_children do |intent|
+            intent
+          end
+        else
+          raise ParamsReadyError, "Unimplemented permission method: '#{method}'"
+        end
+      end
+
+      intent_for_children :pass
+
+      def initialize(definition, **options)
+        raise ParamsReadyError, "Unexpected options: #{options}" unless options.empty?
+        @definition = definition
+      end
+
+      def update_in(value, path)
+        _, updated = update_if_applicable(value, path)
+        updated
+      end
+
+      def update_if_applicable(value, path)
+        if path.empty?
+          update_self(value)
+        elsif respond_to? :update_child
+          update_child(value, path)
+        else
+          raise ParamsReadyError, "Expected path to be terminated in '#{name}'"
+        end
+      end
+
+      def populate(context, validator)
+        return if definition.populator.nil?
+
+        definition.populator.call(context, self)
+        validator
+      rescue => error
+        populator_error = PopulatorError.new(error)
+        if validator.nil?
+          raise populator_error
+        else
+          validator.error! populator_error
+        end
+        validator
+      end
+
+      def match?(other)
+        return false unless other.instance_of?(self.class)
+        definition == other.definition
+      end
+
+      def ==(other)
+        return false unless self.match?(other)
+
+        bare_value == other.bare_value
+      rescue
+        false
+      end
+
+      def to_hash(format = Format.instance(:backend), restriction: nil, data: nil)
+        restriction ||= Restriction.blanket_permission
+        intent = Intent.new(format, restriction, data: data)
+        to_hash_if_eligible(intent) || {}
+      end
+
+      def inspect
+        "#{self.class.name.split("::").last} #{self.name}: { #{inspect_content} }"
+      end
+
+      def dup
+        clone = definition.create
+        populate_other clone
+        clone
+      end
+
+      protected
+
+      def update_self(value)
+        clone = definition.create
+        clone.set_value value
+        clone.freeze if frozen?
+        [true, clone]
+      end
+    end
+
+    class Parameter < AbstractParameter
+      def_delegators :@definition,
+                     :default, :optional?, :default_defined?, :constraints, :no_output?, :local?
+
+      def initialize(definition)
+        @value = Extensions::Undefined
+        super definition
+      end
+
+      def set_value(input, context = Format.instance(:backend), validator = nil)
+        if Extensions::Undefined.value_indefinite?(input)
+          handle_indefinite_input(input, validator)
+        elsif self.match? input
+          @value = input.bare_value
+        else
+          begin
+            value, validator = definition.try_canonicalize(input, context, validator)
+            if validator.nil? || validator.ok?
+              if Extensions::Undefined.value_indefinite?(value)
+                handle_indefinite_input(value, validator)
+              else
+                @value = value
+              end
+            end
+          rescue StandardError => e
+            if validator.nil?
+              raise e
+            else
+              validator.error! e
+            end
+          end
+        end
+        validator
+      end
+
+      def definite_default?
+        default_defined? && !default.nil?
+      end
+
+      def nil_default?
+        default_defined? && default.nil?
+      end
+
+      def is_definite?
+        return true if @value != Extensions::Undefined && !@value.nil?
+
+        definite_default?
+      end
+
+      def is_default?
+        return false unless default_defined?
+
+        @value == Extensions::Undefined || @value == default
+      end
+
+      def is_nil?
+        return false if is_definite?
+        return true if optional?
+        return true if nil_default?
+
+        false
+      end
+
+      def is_undefined?
+        @value == Extensions::Undefined && !default_defined?
+      end
+
+      def eligible_for_output?(intent)
+        intent.preserve?(self)
+      end
+
+      def hash_key(format)
+        format.hash_key(self)
+      end
+
+      def set_from_hash(hash, context: nil, validator: Result.new(name))
+        if local?(context)
+          populate(context, validator)
+        else
+          super
+        end
+      end
+
+      def set_from_input(input, context, validator)
+        preprocessed = definition.preprocess(input, context, validator)
+        set_value preprocessed, context, validator
+        definition.postprocess(self, context, validator)
+        validator
+      end
+
+      def to_hash_if_eligible(intent = Intent.instance(:backend))
+        return nil unless eligible_for_output? intent
+
+        formatted = format_self_permitted(intent)
+        wrap_output(formatted, intent)
+      end
+
+      def format_self_permitted(intent)
+        intent = intent_for_children(intent)
+        format(intent)
+      end
+
+      def format(intent)
+        value = memo(intent)
+        return value if value != Extensions::Undefined
+
+        value = marshal(intent)
+        memo!(value, intent)
+        value
+      end
+
+      def memo(intent)
+        return Extensions::Undefined if @memo.nil?
+
+        @memo.cached_value(intent)
+      end
+
+      def memo!(value, intent)
+        return if @memo.nil? || !frozen?
+
+        @memo.cache_value(value, intent)
+      end
+
+      def wrap_output(output, intent)
+        name_or_path = hash_key(intent)
+        if name_or_path.is_a? Array
+          *path, name = name_or_path
+          result = {}
+          Helpers::KeyMap::Mapping::Path.store(name, output, result, path)
+          result
+        else
+          { name_or_path => output }
+        end
+      end
+
+      def unwrap
+        format(Intent.instance(:backend))
+      end
+
+      def unwrap_or(default)
+        if is_definite?
+          unwrap
+        else
+          default
+        end
+      rescue StandardError => _
+        default
+      end
+
+      def find_in_hash(hash, context)
+        Helpers::FindInHash.find_in_hash hash, hash_key(context)
+      end
+
+      def populate_other(other)
+        raise ParamsReadyError, "Not a matching param: #{other.class.name}" unless match? other
+        return other unless is_definite?
+
+        value = bare_value
+        other.populate_with(value)
+        other
+      end
+
+      def inspect_content
+        @value.inspect
+      end
+
+      freeze_variable :value
+
+      def freeze
+        if definition.memoize? and !frozen?
+          @memo = Helpers::Memo.new(definition.memoize)
+        end
+        init_for_read true
+        super
+      end
+
+      def hash
+        [definition, @value].hash
+      end
+
+      alias_method :eql?, :==
+
+      protected
+
+      def handle_indefinite_input(input, validator)
+        value_missing validator
+        if optional?
+          # if value_missing doesn't crash,
+          # and the parameter is optional
+          # it's safe to set to nil or Extensions::Undefined
+          @value = input
+        elsif default_defined?
+          # Clear possible previous state,
+          # will be set to default on read
+          @value = Extensions::Undefined
+        else
+          raise ParamsReadyError, "Unexpected state in #handle_indefinite_input" if validator.ok?
+        end
+      end
+
+      def value_missing(validator = nil)
+        if !nil_allowed?
+          e = ValueMissingError.new self.name
+          if validator
+            validator.error!(e)
+          else
+            raise e
+          end
+        end
+        validator
+      end
+
+      def nil_allowed?
+        optional? || default_defined?
+      end
+
+      def bare_value
+        init_for_read
+        return @value if is_definite?
+
+        value_missing
+        nil
+      end
+
+      def init_for_read(to_be_frozen = false)
+        return unless @value == Extensions::Undefined
+        return unless default_defined?
+
+        @value = if to_be_frozen
+          definition.default
+        else
+          definition.duplicate_default
+        end
+      end
+
+      def init_for_write
+        return if is_definite?
+
+        if default_defined? && !default.nil?
+          @value = definition.duplicate_default
+        else
+          init_value
+        end
+      end
+
+      def init_value
+        # NOOP
+      end
+    end
+  end
+end