ama-entity-mapper 0.1.0.beta.2

data/lib/ama-entity-mapper/type/aux/hash_tuple.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module AMA
+  module Entity
+    class Mapper
+      class Type
+        module Aux
+          # Simple class to store paired data items
+          class HashTuple
+            attr_accessor :key
+            attr_accessor :value
+
+            def initialize(key: nil, value: nil)
+              @key = key
+              @value = value
+            end
+
+            def hash
+              @key.hash ^ @value.hash
+            end
+
+            def eql?(other)
+              return false unless other.is_a?(HashTuple)
+              @key == other.key && @value == other.value
+            end
+
+            def ==(other)
+              eql?(other)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ama-entity-mapper/type/builtin/array_type.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'enumerable_type'
+
+module AMA
+  module Entity
+    class Mapper
+      class Type
+        module BuiltIn
+          # Even though it is functionally unnecessary, end users are more
+          # likely to call `Mapper.map(input, Array)` rather than
+          # `Mapper.map(input, Enumerable)`. Because mapper has no right to
+          # make assumptions about type children, it would have to back off to
+          # standard hash-based normalization/denormalization, and that would
+          # cause end-user frustration
+          class ArrayType < EnumerableType
+            def initialize
+              super
+              self.type = Array
+            end
+
+            INSTANCE = new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ama-entity-mapper/type/builtin/datetime_type.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'date'
+
+require_relative '../../type'
+require_relative '../../mixin/errors'
+
+module AMA
+  module Entity
+    class Mapper
+      class Type
+        module BuiltIn
+          # DateTime type description
+          class DateTimeType < Type
+            def initialize
+              super(DateTime)
+
+              normalizer_block do |entity, *|
+                entity.iso8601(3)
+              end
+
+              define_denormalizer
+              define_factory
+
+              enumerator_block do |*|
+                ::Enumerator.new { |*| }
+              end
+
+              injector_block { |*| }
+            end
+
+            private
+
+            def define_denormalizer
+              denormalizer_block do |input, _, ctx|
+                break input if input.is_a?(DateTime)
+                input = input.to_s if input.is_a?(Symbol)
+                break DateTime.iso8601(input, 3) if input.is_a?(String)
+                if input.is_a?(Integer)
+                  break DateTime.strptime(input.to_s, '%s')
+                end
+                singleton_class.send(:include, Mixin::Errors)
+                message = 'String input expected (like ' \
+                  "'2001-02-03T04:05:06.123+04:00'), " \
+                  "#{input.class} received: #{input}"
+                mapping_error(message, context: ctx)
+              end
+            end
+
+            def define_factory
+              factory_block do |_, _, ctx|
+                singleton_class.send(:include, Mixin::Errors)
+                message = 'DateTime type could not be instantiated directly, ' \
+                  'it only supports normalization and denormalization'
+                compliance_error(message, context: ctx)
+              end
+            end
+
+            INSTANCE = new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ama-entity-mapper/type/builtin/enumerable_type.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative '../../type'
+require_relative '../../path/segment'
+require_relative '../../mixin/errors'
+
+module AMA
+  module Entity
+    class Mapper
+      class Type
+        module BuiltIn
+          # Default Enumerable handler
+          class EnumerableType < Type
+            include Mixin::Errors
+
+            def initialize
+              super(::Enumerable)
+              attribute!(:_value, parameter!(:T), virtual: true)
+
+              define_factory
+              define_normalizer
+              define_denormalizer
+              define_enumerator
+              define_injector
+            end
+
+            private
+
+            def define_factory
+              factory_block do |*|
+                []
+              end
+            end
+
+            def define_normalizer
+              normalizer_block do |input, *|
+                input.map(&:itself)
+              end
+            end
+
+            def define_denormalizer
+              denormalizer_block do |data, type, context = nil, *|
+                if data.is_a?(Hash) || !data.is_a?(Enumerable)
+                  message = "Can't denormalize Enumerable from #{data.class}"
+                  type.mapping_error(message, context: context)
+                end
+                data.map(&:itself)
+              end
+            end
+
+            def define_enumerator
+              enumerator_block do |entity, type, *|
+                ::Enumerator.new do |yielder|
+                  attribute = type.attributes[:_value]
+                  entity.each_with_index do |value, index|
+                    yielder << [attribute, value, Path::Segment.index(index)]
+                  end
+                end
+              end
+            end
+
+            def define_injector
+              injector_block do |entity, _, _, value, context|
+                entity[context.path.current.name] = value
+              end
+            end
+
+            INSTANCE = new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ama-entity-mapper/type/builtin/hash_tuple_type.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative '../../type'
+require_relative '../aux/hash_tuple'
+
+module AMA
+  module Entity
+    class Mapper
+      class Type
+        module BuiltIn
+          # Pair class definition
+          class HashTupleType < Type
+            def initialize
+              super(Aux::HashTuple, virtual: true)
+
+              attribute!(:key, parameter!(:K))
+              attribute!(:value, parameter!(:V))
+
+              enumerator_block do |entity, type, *|
+                ::Enumerator.new do |yielder|
+                  yielder << [type.attributes[:key], entity.key, nil]
+                  yielder << [type.attributes[:value], entity.value, nil]
+                end
+              end
+            end
+
+            INSTANCE = new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ama-entity-mapper/type/builtin/hash_type.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative '../../type'
+require_relative '../../path/segment'
+require_relative '../../mixin/errors'
+require_relative '../../mixin/reflection'
+require_relative 'hash_tuple_type'
+require_relative '../aux/hash_tuple'
+
+module AMA
+  module Entity
+    class Mapper
+      class Type
+        module BuiltIn
+          # Predefined type for Hash class
+          class HashType < Type
+            include Mixin::Errors
+            extend Mixin::Errors
+
+            def initialize
+              super(::Hash)
+              define_attribute
+              define_enumerator
+              define_injector
+              define_normalizer
+              define_denormalizer
+            end
+
+            private
+
+            def define_attribute
+              type = HashTupleType.new
+              type = type.resolve(
+                type.parameter!(:K) => parameter!(:K),
+                type.parameter!(:V) => parameter!(:V)
+              )
+              attribute!(:_tuple, type, virtual: true)
+            end
+
+            def define_enumerator
+              enumerator_block do |entity, type, *|
+                ::Enumerator.new do |yielder|
+                  entity.each do |key, value|
+                    tuple = Aux::HashTuple.new(key: key, value: value)
+                    attribute = type.attributes[:_tuple]
+                    yielder << [attribute, tuple, Path::Segment.index(key)]
+                  end
+                end
+              end
+            end
+
+            def define_injector
+              injector_block do |entity, _, _, tuple, *|
+                entity[tuple.key] = tuple.value
+              end
+            end
+
+            def define_denormalizer
+              denormalizer_block do |input, type, context = nil, *|
+                input = input.to_h if input.respond_to?(:to_h)
+                break input if input.is_a?(Hash)
+                message = "Expected to receive hash, #{input.class} received"
+                type.mapping_error(message, context: context)
+              end
+            end
+
+            def define_normalizer
+              normalizer_block do |entity, *|
+                intermediate = entity.map do |key, value|
+                  [key, value]
+                end
+                Hash[intermediate]
+              end
+            end
+
+            INSTANCE = new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ama-entity-mapper/type/builtin/primitive_type.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative '../../type'
+require_relative '../../mixin/errors'
+require_relative 'primitive_type/denormalizer'
+
+module AMA
+  module Entity
+    class Mapper
+      class Type
+        module BuiltIn
+          # Predefined type for Set class
+          class PrimitiveType < Type
+            include Mixin::Errors
+
+            def initialize(type, method_map)
+              super(type)
+              this = self
+
+              factory_block do |*|
+                this.compliance_error("#{this} factory should never be called")
+              end
+              normalizer_block do |entity, *|
+                entity
+              end
+              self.denormalizer = Denormalizer.new(method_map)
+              enumerator_block do |*|
+                Enumerator.new { |*| }
+              end
+              injector_block { |*| }
+            end
+
+            # This hash describes which helper methods may be used for which
+            # type to extract target primitive. During the run inheritance chain
+            # is unwrapped, and first matching entry (topmost one) is used.
+            primitives = {
+              Symbol => { Object => [], String => %i[to_sym] },
+              String => { Object => [], Symbol => %i[to_s] },
+              Numeric => { Object => %i[to_i to_f], String => [] },
+              Integer => { Object => %i[to_i], String => [] },
+              Float => { Object => %i[to_f], String => [] },
+              TrueClass => { Object => %i[to_b to_bool], String => [] },
+              FalseClass => { Object => %i[to_b to_bool], String => [] },
+              NilClass => { Object => [] }
+            }
+
+            # rubocop:disable Lint/UnifiedInteger
+            if defined?(Fixnum)
+              primitives[Fixnum] = { Object => %i[to_i], String => [] }
+            end
+            # rubocop:enable Lint/UnifiedInteger
+
+            ALL = primitives.map do |klass, method_map|
+              const_set(klass.to_s.upcase, new(klass, method_map))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ama-entity-mapper/type/builtin/primitive_type/denormalizer.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative '../../../type'
+require_relative '../../../mixin/errors'
+
+module AMA
+  module Entity
+    class Mapper
+      class Type
+        module BuiltIn
+          class PrimitiveType < Type
+            # Standard denormalizer for primitive type
+            class Denormalizer
+              include Mixin::Errors
+
+              # @param [Hash{Class, Array<Symbol>}] method_map
+              def initialize(method_map)
+                @method_map = method_map
+              end
+
+              # @param [Object] source
+              # @param [AMA::Entity::Mapper::Type] type
+              # @param [AMA::Entity::Mapper::Context] context
+              def denormalize(source, type, context)
+                return source if type.valid?(source, context)
+                find_candidate_methods(source.class).each do |candidate|
+                  begin
+                    next unless source.respond_to?(candidate)
+                    value = source.send(candidate)
+                    return value if type.valid?(value, context)
+                  rescue StandardError => e
+                    message = "Method #{candidate} failed with error when " \
+                      "denormalizing #{type.type} out of #{source.class}: " \
+                      "#{e.message}"
+                    context.logger.warn(message)
+                  end
+                end
+                message = "Can't create #{type} instance from #{source.class}"
+                mapping_error(message, context: context)
+              end
+
+              private
+
+              def find_candidate_methods(klass)
+                chain = []
+                cursor = klass
+                until cursor.nil?
+                  chain.push(cursor)
+                  cursor = cursor.superclass
+                end
+                winner = chain.find do |entry|
+                  @method_map.key?(entry)
+                end
+                winner.nil? ? [] : @method_map[winner]
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end