ama-entity-mapper 0.1.0.beta.2

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative '../../type'
+require_relative '../../mixin/errors'
+
+module AMA
+  module Entity
+    class Mapper
+      class Type
+        module BuiltIn
+          # Rational type description
+          class RationalType < Type
+            def initialize
+              super(Rational)
+
+              normalizer_block do |entity, *|
+                entity.to_s
+              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?(Rational)
+                input = input.to_s if input.is_a?(Symbol)
+                break Rational(input) if input.is_a?(String)
+                singleton_class.send(:include, Mixin::Errors)
+                message = "String input expected (like '2.3'), " \
+                  "#{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 = 'Rational 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/set_type.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'set'
+
+require_relative '../../type'
+require_relative '../../path/segment'
+require_relative '../../mixin/errors'
+
+module AMA
+  module Entity
+    class Mapper
+      class Type
+        module BuiltIn
+          # Predefined type for Set class
+          class SetType < Type
+            def initialize
+              super(::Set)
+              attribute!(:_value, parameter!(:T), virtual: true)
+
+              define_factory
+              define_normalizer
+              define_denormalizer
+              define_enumerator
+              define_injector
+            end
+
+            private
+
+            def define_factory
+              factory_block do |*|
+                Set.new([])
+              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 Set from #{data.class}"
+                  type.mapping_error(message, context: context)
+                end
+                Set.new(data)
+              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, *|
+                entity.add(value)
+              end
+            end
+
+            INSTANCE = new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ama-entity-mapper/type/parameter.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative '../mixin/errors'
+
+module AMA
+  module Entity
+    class Mapper
+      class Type
+        # This class represents parameter type - an unknown-until-runtime type
+        # that belongs to particular other type. For example,
+        # Hash<Symbol, Integer> may be described as Type(Hash) with
+        # parameters _key: Symbol and _value: Integer
+        class Parameter
+          include Mixin::Errors
+
+          # @!attribute type
+          #   @return [AMA::Entity::Mapper::Type]
+          attr_reader :owner
+          # @!attribute id
+          #   @return [Symbol]
+          attr_reader :id
+
+          # @param [AMA::Entity::Mapper::Type] owner
+          # @param [Symbol] id
+          def initialize(owner, id)
+            @owner = owner
+            @id = id
+          end
+
+          def instance?(_)
+            false
+          end
+
+          def resolve_parameter(*)
+            self
+          end
+
+          def resolved?
+            false
+          end
+
+          def resolved!(context = nil)
+            compliance_error("Type #{self} is not resolved", context: context)
+          end
+
+          def to_s
+            "Parameter #{owner.type}.#{id}"
+          end
+
+          def to_def
+            "#{owner.type}.#{id}"
+          end
+
+          def hash
+            @owner.hash ^ @id.hash
+          end
+
+          def eql?(other)
+            return false unless other.is_a?(self.class)
+            @id == other.id && @owner == other.owner
+          end
+
+          def ==(other)
+            eql?(other)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ama-entity-mapper/type/registry.rb

@@ -0,0 +1,117 @@
+# frozen_String_literal: true
+
+require_relative '../mixin/errors'
+require_relative 'parameter'
+require_relative 'builtin/enumerable_type'
+require_relative 'builtin/array_type'
+require_relative 'builtin/hash_type'
+require_relative 'builtin/hash_tuple_type'
+require_relative 'builtin/set_type'
+require_relative 'builtin/primitive_type'
+require_relative 'builtin/rational_type'
+require_relative 'builtin/datetime_type'
+
+module AMA
+  module Entity
+    class Mapper
+      class Type
+        # Holds all registered types
+        class Registry
+          include Mixin::Errors
+
+          attr_accessor :types
+
+          def initialize
+            @types = {}
+          end
+
+          # @return [AMA::Entity::Mapper::Type::Registry]
+          def with_default_types
+            register(BuiltIn::EnumerableType::INSTANCE)
+            register(BuiltIn::ArrayType::INSTANCE)
+            register(BuiltIn::HashType::INSTANCE)
+            register(BuiltIn::SetType::INSTANCE)
+            register(BuiltIn::HashTupleType::INSTANCE)
+            register(BuiltIn::RationalType::INSTANCE)
+            register(BuiltIn::DateTimeType::INSTANCE)
+            BuiltIn::PrimitiveType::ALL.each do |type|
+              register(type)
+            end
+            self
+          end
+
+          # @param [Class, Module] klass
+          def [](klass)
+            @types[klass]
+          end
+
+          # @param [AMA::Entity::Mapper::Type] type
+          def register(type)
+            @types[type.type] = type
+          end
+
+          # @param [Class] klass
+          def key?(klass)
+            @types.key?(klass)
+          end
+
+          alias registered? key?
+
+          # @param [Class, Module] klass
+          # @return [Array<AMA::Entity::Mapper::Type>]
+          def select(klass)
+            types = class_hierarchy(klass).map do |entry|
+              @types[entry]
+            end
+            types.reject(&:nil?)
+          end
+
+          # @param [Class, Module] klass
+          # @return [AMA::Entity::Mapper::Type, NilClass]
+          def find(klass)
+            candidates = select(klass)
+            candidates.empty? ? nil : candidates.first
+          end
+
+          # @param [Class, Module] klass
+          # @return [AMA::Entity::Mapper::Type]
+          def find!(klass)
+            candidate = find(klass)
+            return candidate if candidate
+            message = "Could not find any registered type for class #{klass}"
+            compliance_error(message)
+          end
+
+          # @param [Class, Module] klass
+          # @return [TrueClass, FalseClass]
+          def resolvable?(klass)
+            !select(klass).empty?
+          end
+
+          private
+
+          # @param [Class, Module] klass
+          def class_hierarchy(klass)
+            ptr = klass
+            chain = []
+            loop do
+              chain.push(*class_with_modules(ptr))
+              break if !ptr.respond_to?(:superclass) || ptr.superclass.nil?
+              ptr = ptr.superclass
+            end
+            chain
+          end
+
+          def class_with_modules(klass)
+            if klass.superclass.nil?
+              parent_modules = []
+            else
+              parent_modules = klass.superclass.included_modules
+            end
+            [klass, *(klass.included_modules - parent_modules)]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ama-entity-mapper/type/resolver.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative '../mixin/errors'
+require_relative '../type'
+require_relative 'parameter'
+
+module AMA
+  module Entity
+    class Mapper
+      class Type
+        # This class is responsible for resolution of simple type definitions,
+        # converting definitions like
+        # [Array, T: [NilClass, [Hash, K: Symbol, V: Integer]]]
+        # into real type hierarchy
+        class Resolver
+          include Mixin::Errors
+
+          # @param [Registry] registry
+          def initialize(registry)
+            @registry = registry
+          end
+
+          def resolve(definition)
+            definition = [definition] unless definition.is_a?(Enumerable)
+            resolve_definition(definition)
+          rescue StandardError => parent
+            message = "Definition #{definition} resolution resulted " \
+              "in error: #{parent}"
+            compliance_error(message)
+          end
+
+          private
+
+          def resolve_definitions(definitions)
+            definitions = [definitions] unless definitions.is_a?(Array)
+            if definitions.size == 2 && definitions.last.is_a?(Hash)
+              definitions = [definitions]
+            end
+            definitions.map do |definition|
+              resolve_definition(definition)
+            end
+          end
+
+          def resolve_definition(definition)
+            definition = [definition] unless definition.is_a?(Array)
+            type = definition.first
+            parameters = definition[1] || {}
+            resolve_type(type, parameters)
+          rescue StandardError => e
+            message = "Unexpected error during definition #{definition} " \
+              "resolution: #{e.message}"
+            compliance_error(message)
+          end
+
+          def resolve_type(type, parameters)
+            type = find_type(type)
+            unless parameters.is_a?(Hash)
+              message = "Type parameters were passed not as hash: #{parameters}"
+              compliance_error(message)
+            end
+            parameters.each do |parameter, replacements|
+              parameter = resolve_type_parameter(type, parameter)
+              replacements = resolve_definitions(replacements)
+              type = type.resolve_parameter(parameter, replacements)
+            end
+            type
+          end
+
+          def find_type(type)
+            return type if type.is_a?(Type)
+            return Type::Any::INSTANCE if [:*, '*'].include?(type)
+            if type.is_a?(Class) || type.is_a?(Module)
+              return @registry[type] || Type::Analyzer.analyze(type)
+            end
+            message = 'Invalid type provided for resolution, expected Type, ' \
+              "Class or Module: #{type}"
+            compliance_error(message)
+          end
+
+          def resolve_type_parameter(type, parameter)
+            unless parameter.is_a?(Parameter)
+              parameter = find_parameter(type, parameter)
+            end
+            return parameter if parameter.owner.type == type.type
+            message = "Parameter #{parameter} belongs to different type " \
+              'rather one it is resolved against'
+            compliance_error(message)
+          end
+
+          def find_parameter(type, parameter)
+            parameter = parameter.to_sym if parameter.respond_to?(:to_sym)
+            unless parameter.is_a?(Symbol)
+              message = "#{parameter} is not a valid parameter identifier " \
+                '(Symbol expected)'
+              compliance_error(message)
+            end
+            return type.parameters[parameter] if type.parameters.key?(parameter)
+            message = "Type #{type} has no requested parameter #{parameter}"
+            compliance_error(message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ama-entity-mapper/version.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module AMA
+  module Entity
+    class Mapper
+      class Version
+        MAJOR = 0
+        MINOR = 1
+        PATCH = 0
+        CLASSIFIER = 'beta'.freeze
+        PRERELEASE_NUMBER = 2
+        CHUNKS = [MAJOR, MINOR, PATCH, CLASSIFIER, PRERELEASE_NUMBER].freeze
+        VERSION = CHUNKS.reject(&:nil?).join('.').freeze
+      end
+    end
+  end
+end