ama-entity-mapper 0.1.0.beta.2

data/lib/ama-entity-mapper/engine/recursive_normalizer.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative '../type'
+require_relative '../type/analyzer'
+
+module AMA
+  module Entity
+    class Mapper
+      class Engine
+        # Helper and self-explanatory engine class
+        class RecursiveNormalizer
+          # @param [AMA::Entity::Mapper::Type::Registry] registry
+          def initialize(registry)
+            @registry = registry
+          end
+
+          # @param [Object] entity
+          # @param [AMA::Entity::Mapper::Context] ctx
+          # @param [AMA::Entity::Mapper::Type, NilClass] type
+          def normalize(entity, ctx, type = nil)
+            type ||= find_type(entity.class)
+            target = entity
+            ctx.logger.debug("Normalizing #{entity.class} as #{type.type}")
+            if type.virtual
+              message = "Type #{type.type} is virtual, skipping to attributes"
+              ctx.logger.debug(message)
+            else
+              target = type.normalizer.normalize(entity, type, ctx)
+            end
+            target_type = find_type(target.class)
+            process_attributes(target, target_type, ctx)
+          end
+
+          private
+
+          # @param [Object] entity
+          # @param [AMA::Entity::Mapper::Type] type
+          # @param [AMA::Entity::Mapper::Context] ctx
+          def process_attributes(entity, type, ctx)
+            if type.attributes.empty?
+              message = "No attributes found on #{type.type}, returning " \
+                "#{entity.class} as is"
+              ctx.logger.debug(message)
+              return entity
+            end
+            normalize_attributes(entity, type, ctx)
+          end
+
+          # @param [Object] entity
+          # @param [AMA::Entity::Mapper::Type] type
+          # @param [AMA::Entity::Mapper::Context] ctx
+          def normalize_attributes(entity, type, ctx)
+            message = "Normalizing attributes of #{entity.class} " \
+              "(as #{type.type})"
+            ctx.logger.debug(message)
+            enumerator = type.enumerator.enumerate(entity, type, ctx)
+            enumerator.each do |attribute, value, segment|
+              local_ctx = ctx.advance(segment)
+              value = normalize(value, local_ctx)
+              type.injector.inject(entity, type, attribute, value, local_ctx)
+            end
+            entity
+          end
+
+          # @param [Class, Module] klass
+          # @return [AMA::Entity::Mapper::Type]
+          def find_type(klass)
+            @registry.find(klass) || Type::Analyzer.analyze(klass)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module AMA
+  module Entity
+    class Mapper
+      # Marker module to allow easy library error processing
+      module Error
+      end
+    end
+  end
+end

data/lib/ama-entity-mapper/error/compliance_error.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module AMA
+  module Entity
+    class Mapper
+      module Error
+        # This error is supposed to be thrown whenever end user provides
+        # malformed input - too many types, not enough types, not a type, etc.
+        class ComplianceError < RuntimeError
+          include Error
+        end
+      end
+    end
+  end
+end

data/lib/ama-entity-mapper/error/mapping_error.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module AMA
+  module Entity
+    class Mapper
+      module Error
+        # Made to be thrown whenever mapping can't be done
+        class MappingError < RuntimeError
+          include Error
+        end
+      end
+    end
+  end
+end

data/lib/ama-entity-mapper/error/validation_error.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module AMA
+  module Entity
+    class Mapper
+      module Error
+        # Made to be thrown if validation fails
+        class ValidationError < RuntimeError
+          include Error
+        end
+      end
+    end
+  end
+end

data/lib/ama-entity-mapper/handler/attribute/validator.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require_relative '../../mixin/reflection'
+require_relative '../../mixin/errors'
+
+module AMA
+  module Entity
+    class Mapper
+      module Handler
+        module Attribute
+          # Default validator for single attribute
+          class Validator
+            INSTANCE = new
+
+            # @param [Object] value Attribute value
+            # @param [AMA::Entity::Mapper::Type::Attribute] attribute
+            # @param [AMA::Entity::Mapper::Context] _context
+            # @return [Array<String>] Single violation, list of violations
+            def validate(value, attribute, _context)
+              violation = validate_internal(value, attribute)
+              violation.nil? ? [] : [violation]
+            end
+
+            private
+
+            def validate_internal(value, attribute)
+              if illegal_nil?(value, attribute)
+                return "Attribute #{attribute} could not be nil"
+              end
+              if invalid_type?(value, attribute)
+                return "Provided value doesn't conform to " \
+                  "any of attribute #{attribute} types " \
+                  "(#{attribute.types.map(&:to_def).join(', ')})"
+              end
+              return unless illegal_value?(value, attribute)
+              "Provided value doesn't match default value (#{value})" \
+                " or any of allowed values (#{attribute.values})"
+            end
+
+            # @param [Object] value Attribute value
+            # @param [AMA::Entity::Mapper::Type::Attribute] attribute
+            # @return [TrueClass, FalseClass]
+            def illegal_nil?(value, attribute)
+              return false unless value.nil? && !attribute.nullable
+              attribute.types.none? { |type| type.instance?(value) }
+            end
+
+            # @param [Object] value Attribute value
+            # @param [AMA::Entity::Mapper::Type::Attribute] attribute
+            # @return [TrueClass, FalseClass]
+            def invalid_type?(value, attribute)
+              attribute.types.all? do |type|
+                !type.respond_to?(:instance?) || !type.instance?(value)
+              end
+            end
+
+            # @param [Object] value Attribute value
+            # @param [AMA::Entity::Mapper::Type::Attribute] attribute
+            # @return [TrueClass, FalseClass]
+            def illegal_value?(value, attribute)
+              return false if value == attribute.default
+              return false if attribute.values.empty? || attribute.values.nil?
+              !attribute.values.include?(value)
+            end
+
+            class << self
+              include Mixin::Reflection
+
+              # @param [Validator] validator
+              # @return [Validator]
+              def wrap(validator)
+                handler = handler_factory(validator, INSTANCE)
+                description = "Safety wrapper for #{validator}"
+                wrapper = method_object(:validate, to_s: description, &handler)
+                wrapper.singleton_class.instance_eval do
+                  include Mixin::Errors
+                end
+                wrapper
+              end
+
+              private
+
+              # @param [Validator] validator
+              # @param [Validator] fallback
+              # @return [Proc]
+              def handler_factory(validator, fallback)
+                lambda do |val, attr, ctx|
+                  begin
+                    validator.validate(val, attr, ctx) do |v, a, c|
+                      fallback.validate(v, a, c)
+                    end
+                  rescue StandardError => e
+                    raise_if_internal(e)
+                    message = "Unexpected error from validator #{validator}"
+                    signature = '(value, attribute, context)'
+                    options = { parent: e, context: ctx, signature: signature }
+                    compliance_error(message, **options)
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ama-entity-mapper/handler/entity/denormalizer.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require_relative '../../mixin/reflection'
+require_relative '../../mixin/errors'
+
+module AMA
+  module Entity
+    class Mapper
+      module Handler
+        module Entity
+          # Default denormalization processor
+          class Denormalizer
+            include Mixin::Reflection
+            include Mixin::Errors
+
+            INSTANCE = new
+
+            # @param [Hash] source
+            # @param [AMA::Entity::Mapper::Type] type
+            # @param [AMA::Entity::Mapper::Context] context
+            def denormalize(source, type, context = nil)
+              validate_source!(source, type, context)
+              entity = type.factory.create(type, source, context)
+              type.attributes.values.each do |attribute|
+                next if attribute.virtual
+                candidate_names(attribute).each do |name|
+                  next unless source.key?(name)
+                  value = source[name]
+                  break set_object_attribute(entity, attribute.name, value)
+                end
+              end
+              entity
+            end
+
+            private
+
+            # @param [AMA::Entity::Mapper::Type::Attribute] attribute
+            # @return [Array<Symbol, String>]
+            def candidate_names(attribute)
+              [attribute.name, *attribute.aliases].flat_map do |candidate|
+                [candidate, candidate.to_s]
+              end
+            end
+
+            # @param [Hash] source
+            # @param [AMA::Entity::Mapper::Type] type
+            # @param [AMA::Entity::Mapper::Context] context
+            def validate_source!(source, type, context)
+              return if source.is_a?(Hash)
+              message = "Expected Hash, #{source.class} provided " \
+                "(while denormalizing #{type})"
+              mapping_error(message, context: context)
+            end
+
+            class << self
+              include Mixin::Reflection
+
+              # @param [Denormalizer] implementation
+              # @return [Denormalizer]
+              def wrap(implementation)
+                handler = handler_factory(implementation, INSTANCE)
+                depiction = "Safety wrapper for #{implementation}"
+                wrapper = method_object(:denormalize, to_s: depiction, &handler)
+                wrapper.singleton_class.instance_eval do
+                  include Mixin::Errors
+                end
+                wrapper
+              end
+
+              private
+
+              # @param [Denormalizer] implementation
+              # @param [Denormalizer] fallback
+              # @return [Denormalizer]
+              def handler_factory(implementation, fallback)
+                lambda do |source, type, ctx|
+                  begin
+                    implementation.denormalize(source, type, ctx) do |s, t, c|
+                      fallback.denormalize(s, t, c)
+                    end
+                  rescue StandardError => e
+                    raise_if_internal(e)
+                    message = 'Unexpected error from denormalizer ' \
+                      "#{implementation}"
+                    signature = '(source, type, context)'
+                    options = { parent: e, context: ctx, signature: signature }
+                    compliance_error(message, **options)
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ama-entity-mapper/handler/entity/enumerator.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative '../../mixin/reflection'
+require_relative '../../path/segment'
+
+module AMA
+  module Entity
+    class Mapper
+      module Handler
+        module Entity
+          # Default attribute enumerator
+          class Enumerator
+            include Mixin::Reflection
+
+            INSTANCE = new
+
+            # @param [Object] entity
+            # @param [AMA::Entity::Mapper::Type] type
+            # @param [AMA::Entity::Mapper::Context] _context
+            def enumerate(entity, type, _context)
+              ::Enumerator.new do |yielder|
+                type.attributes.values.each do |attribute|
+                  next if attribute.virtual
+                  value = attribute.default
+                  if object_variable_exists(entity, attribute.name)
+                    value = object_variable(entity, attribute.name)
+                  end
+                  segment = Path::Segment.attribute(attribute.name)
+                  yielder << [attribute, value, segment]
+                end
+              end
+            end
+
+            class << self
+              include Mixin::Reflection
+
+              # @param [Enumerator] implementation
+              # @return [Enumerator]
+              def wrap(implementation)
+                handler = handler_factory(implementation, INSTANCE)
+                description = "Safety wrapper for #{implementation}"
+                wrapper = method_object(:enumerate, to_s: description, &handler)
+                wrapper.singleton_class.instance_eval do
+                  include Mixin::Errors
+                end
+                wrapper
+              end
+
+              private
+
+              # @param [Enumerator] implementation
+              # @param [Enumerator] fallback
+              # @return [Enumerator]
+              def handler_factory(implementation, fallback)
+                lambda do |entity, type, ctx|
+                  begin
+                    implementation.enumerate(entity, type, ctx) do |e, t, c|
+                      fallback.enumerate(e, t, c)
+                    end
+                  rescue StandardError => e
+                    raise_if_internal(e)
+                    message = 'Unexpected error from enumerator ' \
+                      "#{implementation}"
+                    signature = '(entity, type, context)'
+                    options = { parent: e, context: ctx, signature: signature }
+                    compliance_error(message, **options)
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ama-entity-mapper/handler/entity/factory.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative '../../mixin/errors'
+require_relative '../../mixin/reflection'
+require_relative '../../path/segment'
+
+module AMA
+  module Entity
+    class Mapper
+      module Handler
+        module Entity
+          # Default entity factory
+          class Factory
+            include Mixin::Errors
+
+            INSTANCE = new
+
+            # @param [AMA::Entity::Mapper::Type] type
+            # @param [Object] _data
+            # @param [AMA::Entity::Mapper::Context] context
+            def create(type, _data, context)
+              create_internal(type)
+            rescue StandardError => e
+              message = "Failed to instantiate #{type} directly from class"
+              if e.is_a?(ArgumentError)
+                message += '. Does it have parameterless #initialize() method?'
+              end
+              mapping_error(message, parent: e, context: context)
+            end
+
+            private
+
+            # @param [AMA::Entity::Mapper::Type] type
+            def create_internal(type)
+              entity = type.type.new
+              type.attributes.values.each do |attribute|
+                next if attribute.default.nil? || attribute.virtual
+                segment = Path::Segment.attribute(attribute.name)
+                value = attribute.default
+                type.injector.inject(entity, type, attribute, value, segment)
+              end
+              entity
+            end
+
+            class << self
+              include Mixin::Reflection
+
+              # @param [Factory] implementation
+              # @return [Factory]
+              def wrap(implementation)
+                handler = handler_factory(implementation, INSTANCE)
+                description = "Safety wrapper for #{implementation}"
+                wrapper = method_object(:create, to_s: description, &handler)
+                wrapper.singleton_class.instance_eval do
+                  include Mixin::Errors
+                end
+                wrapper
+              end
+
+              private
+
+              # @param [Factory] implementation
+              # @param [Factory] fallback
+              # @return [Factory]
+              def handler_factory(implementation, fallback)
+                lambda do |type, data, ctx|
+                  begin
+                    implementation.create(type, data, ctx) do |t, d, c|
+                      fallback.create(t, d, c)
+                    end
+                  rescue StandardError => e
+                    raise_if_internal(e)
+                    message = "Unexpected error from factory #{implementation}"
+                    signature = '(type, data, context)'
+                    options = { parent: e, context: ctx, signature: signature }
+                    compliance_error(message, options)
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end