params_ready 0.0.1

data/lib/params_ready/marshaller/builder_module.rb

@@ -0,0 +1,9 @@
+module ParamsReady
+  module Marshaller
+    module BuilderModule
+      def marshal(to: nil, using: nil, **opts)
+        @definition.set_marshaller(to: to, using: using, **opts)
+      end
+    end
+  end
+end

data/lib/params_ready/marshaller/collection.rb

@@ -0,0 +1,165 @@
+require_relative '../error'
+require_relative '../extensions/hash'
+
+module ParamsReady
+  module Marshaller
+    class InstanceCollection
+      attr_reader :default, :instances
+
+      def initialize(canonical, default = nil, instances = {})
+        @canonical = canonical
+        @default = default
+        @instances = instances
+      end
+
+      def canonicalize(definition, input, context, validator, **opts)
+        value_class = infer_class(input)
+        marshaller = instance(value_class)
+        raise ParamsReadyError, "Unexpected type for #{definition.name}: #{value_class.name}" if marshaller.nil?
+
+        marshaller.canonicalize(definition, input, context, validator, **opts)
+      end
+
+      def marshal_canonical(parameter, format, **opts)
+        marshaller = instance @canonical
+        if marshaller.nil?
+          value = parameter.send(:bare_value)
+          raise ParamsReadyError, "Value is not canonical" unless value.is_a? @canonical
+          value
+        else
+          marshaller.marshal(parameter, format, **opts)
+        end
+      end
+
+      def marshal(parameter, format, **opts)
+        default.marshal(parameter, format, **opts)
+      end
+
+      def infer_class(value)
+        if instances.key? value.class
+          value.class
+        elsif value.is_a?(Hash) || Extensions::Hash.acts_as_hash?(value)
+          Hash
+        else
+          value.class
+        end
+      end
+
+      def add_instance(value_class, instance)
+        raise ParamsReadyError, "Marshaller must be frozen" unless instance.frozen?
+
+        @instances[value_class] = instance
+      end
+
+      def instance(value_class)
+        @instances[value_class]
+      end
+
+      def instance?(value_class)
+        @instances.key?(value_class)
+      end
+
+      def default=(instance)
+        raise ParamsReadyError, "Default already defined" if default?
+        raise ParamsReadyError, "Marshaller must be frozen" unless instance.frozen?
+
+        @default = instance
+      end
+
+      def default!(value_class)
+        instance = instance(value_class)
+        raise ParamsReadyError, "No marshaller for class '#{value_class.name}'" if instance.nil?
+        self.default = instance
+      end
+
+      def default?
+        !@default.nil?
+      end
+
+      def reverse_merge(other)
+        clone = self.class.new(@canonical, @default, @instances.dup)
+        populate_clone(clone, other)
+      end
+
+      def populate_clone(clone, other)
+        if other.default? && !clone.default?
+          clone.default = other.default
+        end
+
+        other.instances.each do |value_class, i|
+          next if clone.instance?(value_class)
+
+          clone.add_instance value_class, i
+        end
+
+        clone
+      end
+
+      def freeze
+        @instance.freeze
+        super
+      end
+    end
+
+    class ClassCollection < InstanceCollection
+      attr_reader :factories
+
+      def initialize(canonical, default = nil, instances = {}, factories = {})
+        @factories = factories
+        super canonical, default, instances
+      end
+
+      def instance_collection
+        InstanceCollection.new(@canonical, nil, @instances.dup)
+      end
+
+      def add_factory(name, factory)
+        name = name.to_sym
+        raise ParamsReadyError, "Name '#{name}' already taken" if factory?(name)
+        raise ParamsReadyError, "Factory must be frozen" unless factory.frozen?
+
+        @factories[name] = factory
+      end
+
+      def add_instance(value_class, instance)
+        raise ParamsReadyError, "Marshaller for '#{value_class.name}' already exists" if instance?(value_class)
+
+        super
+      end
+
+      def build_instance(name, **opts)
+        factory(name).instance(**opts)
+      end
+
+      def factory(name)
+        @factories[name]
+      end
+
+      def factory?(name)
+        @factories.key? name
+      end
+
+      def freeze
+        @factories.freeze
+        super
+      end
+
+      def reverse_merge(other)
+        clone = self.class.new(@canonical, @default, @instances.dup, @factories.dup)
+        populate_clone(clone, other)
+      end
+
+      def populate_clone(clone, other)
+        merged = super
+
+        other.factories.each do |value_class, f|
+          next if merged.factory?(value_class)
+
+          clone.add_factory value_class, f
+        end
+
+        merged
+      end
+    end
+  end
+end

data/lib/params_ready/marshaller/definition_module.rb

@@ -0,0 +1,63 @@
+module ParamsReady
+  module Marshaller
+    module DefinitionModule
+      def self.[](collection)
+        mod = Module.new
+        mod.include self
+        mod.define_method :class_marshallers do
+          collection
+        end
+        mod
+      end
+
+      attr_reader :marshallers
+
+      def initialize(*args, marshaller: nil, **options)
+        @marshallers = class_marshallers.instance_collection
+        set_marshaller(**marshaller) unless marshaller.nil?
+
+        super *args, **options
+      end
+
+      def set_marshaller(to: nil, using: nil, **opts)
+        if using.is_a? Symbol
+          raise ParamsReadyError, "Expected ':to' argument to be nil, got #{to.class.name}" unless to.nil?
+          default_class, instance = class_marshallers.build_instance(using, **opts)
+          @marshallers.add_instance(default_class, instance)
+          @marshallers.default!(default_class)
+        elsif using.nil?
+          @marshallers.default!(to)
+        else
+          @marshallers.add_instance(to, using)
+          @marshallers.default!(to)
+        end
+      end
+
+      def marshal(parameter, intent, **opts)
+        if intent.marshal?(name_for_formatter)
+          @marshallers.marshal(parameter, intent, **opts)
+        else
+          @marshallers.marshal_canonical(parameter, intent, **opts)
+        end
+      end
+
+      def try_canonicalize(input, context, validator = nil, **opts)
+        @marshallers.canonicalize(self, input, context, validator, **opts)
+      end
+
+      def finish
+        unless @marshallers.default?
+          if class_marshallers.default?
+            @marshallers.default = class_marshallers.default
+          end
+        end
+        super
+      end
+
+      def freeze
+        @marshallers.freeze
+        super
+      end
+    end
+  end
+end

data/lib/params_ready/marshaller/hash_marshallers.rb

@@ -0,0 +1,100 @@
+require 'json'
+require 'base64'
+require_relative 'collection'
+
+module ParamsReady
+  module Marshaller
+    class HashMarshallers
+      module AbstractMarshaller
+        def extract_bare_value(parameter, intent)
+          parameter.names.keys.reduce({}) do |result, name|
+            c = parameter[name]
+            hash = c.to_hash_if_eligible(intent)
+            if hash.nil?
+              result
+            else
+              result.deep_merge(hash)
+            end
+          end
+        end
+      end
+
+      module Base64Marshaller
+        def self.instance
+          [String, self]
+        end
+
+        def self.canonicalize(definition, string, context, validator)
+          json = Base64.urlsafe_decode64(string)
+          hash = JSON.parse(json)
+          HashMarshaller.canonicalize(definition, hash, context, validator)
+        end
+
+        def self.marshal(parameter, intent)
+          hash = HashMarshaller.marshal(parameter, intent)
+          json = JSON.generate(hash)
+          Base64.urlsafe_encode64(json)
+        end
+
+        freeze
+      end
+
+      module HashMarshaller
+        extend AbstractMarshaller
+
+        def self.canonicalize(definition, hash, context, validator, freeze: false)
+          hash = if definition.respond_to?(:remap?) && definition.remap?(context)
+            definition.key_map.to_standard(hash)
+          else
+            hash
+          end
+
+          value = definition.names.each_with_object({}) do |(name, child_def), result|
+            child = child_def.create
+            child.set_from_hash(hash, validator: validator&.for_child(name), context: context)
+            child.freeze if freeze
+            result[name] = child
+          end
+          [value, validator]
+        end
+
+        def self.marshal(parameter, intent)
+          value = extract_bare_value(parameter, intent)
+
+          definition = parameter.definition
+
+          if value == {}
+            if intent.marshal?(definition.name_for_formatter)
+              if definition.optional? || definition.default_defined?
+                parameter.class::EMPTY_HASH
+              elsif intent.omit?(parameter)
+                nil
+              else
+                value
+              end
+            else
+              value
+            end
+          elsif definition.respond_to?(:remap?) && definition.remap?(intent)
+            definition.key_map.to_alternative(value)
+          else
+            value
+          end
+        end
+
+        freeze
+      end
+
+      def self.collection
+        @collection ||= begin
+          c = ClassCollection.new Hash
+          c.add_instance Hash, HashMarshaller
+          c.add_factory :base64, Base64Marshaller
+          c.default!(Hash)
+          c.freeze
+          c
+        end
+      end
+    end
+  end
+end

data/lib/params_ready/marshaller/hash_set_marshallers.rb

@@ -0,0 +1,96 @@
+require_relative 'collection'
+require_relative 'hash_marshallers'
+
+module ParamsReady
+  module Marshaller
+    class HashSetMarshallers
+      module AbstractMarshaller
+        def canonicalize_collection(definition, context, validator, freeze: false)
+          hash = {}
+          definition.names.each do |name, definition|
+            child = definition.create
+            value = yield child
+            child.set_from_input(value, context, validator)
+            child.freeze if freeze
+            hash[name] = child
+          end
+          [hash, validator]
+        end
+      end
+
+      module HashMarshaller
+        extend AbstractMarshaller
+
+        def self.canonicalize(definition, hash, context, validator)
+          canonicalize_collection(definition, context, validator) do |child|
+            _, value = child.find_in_hash(hash, context)
+            value
+          end
+        end
+
+        def self.marshal(parameter, intent)
+          if intent.marshal? parameter.name_for_formatter
+            HashMarshallers::HashMarshaller.marshal(parameter, intent)
+          else
+            SetMarshaller.marshal(parameter, intent)
+          end
+        end
+
+        freeze
+      end
+
+      module SetMarshaller
+        extend AbstractMarshaller
+
+        def self.canonicalize(definition, set, context, validator, freeze: false)
+          canonicalize_collection(definition, context, validator, freeze: freeze) do |child|
+            value = definition.values[child.name]
+            set.member?(value) || set.member?(value.to_s)
+          end
+        end
+
+        def self.marshal(parameter, intent)
+          intent = parameter.class.intent_for_set(intent)
+
+          members = parameter.send(:bare_value).select do |_, m|
+            m.unwrap_or(false) == true && m.eligible_for_output?(intent)
+          end.map do |key, _|
+            parameter.definition.values[key]
+          end
+
+          members.to_set
+        end
+
+        freeze
+      end
+
+      module ArrayMarshaller
+        extend AbstractMarshaller
+
+        def self.canonicalize(definition, array, context, validator)
+          set = array.to_set
+          SetMarshaller.canonicalize(definition, set, context, validator)
+        end
+
+        def self.marshal(parameter, intent)
+          set = SetMarshaller.marshal(parameter, intent)
+          set.to_a
+        end
+
+        freeze
+      end
+
+      def self.collection
+        @collection ||= begin
+          c = ClassCollection.new Hash
+          c.add_instance Hash, HashMarshaller
+          c.add_instance Set, SetMarshaller
+          c.add_instance Array, ArrayMarshaller
+          c.default!(Hash)
+          c.freeze
+          c
+        end
+      end
+    end
+  end
+end

data/lib/params_ready/marshaller/parameter_module.rb

@@ -0,0 +1,11 @@
+module ParamsReady
+  module Marshaller
+    module ParameterModule
+      def marshal(intent)
+        return nil if is_nil?
+
+        definition.marshal(self, intent)
+      end
+    end
+  end
+end