ama-entity-mapper 0.1.0.beta.2

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative '../../mixin/reflection'
+require_relative '../../mixin/errors'
+
+module AMA
+  module Entity
+    class Mapper
+      module Handler
+        module Entity
+          # Default attribute injector
+          class Injector
+            include Mixin::Reflection
+
+            INSTANCE = new
+
+            # @param [Object] entity
+            # @param [AMA::Entity::Mapper::Type] _type
+            # @param [AMA::Entity::Mapper::Type::Attribute] attribute
+            # @param [Object] value
+            # @param [AMA::Entity::Mapper::Context] _context
+            def inject(entity, _type, attribute, value, _context = nil)
+              return entity if attribute.virtual
+              set_object_attribute(entity, attribute.name, value)
+              entity
+            end
+
+            class << self
+              include Mixin::Reflection
+
+              # @param [Injector] implementation
+              # @return [Injector]
+              def wrap(implementation)
+                handler = handler_factory(implementation, INSTANCE)
+                description = "Safety wrapper for #{implementation}"
+                wrapper = method_object(:inject, to_s: description, &handler)
+                wrapper.singleton_class.instance_eval do
+                  include Mixin::Errors
+                end
+                wrapper
+              end
+
+              private
+
+              # @param [Injector] impl
+              # @param [Injector] fallback
+              # @return [Injector]
+              def handler_factory(impl, fallback)
+                lambda do |entity, type, attr, val, ctx|
+                  begin
+                    impl.inject(entity, type, attr, val, ctx) do |e, t, a, v, c|
+                      fallback.inject(e, t, a, v, c)
+                    end
+                  rescue StandardError => e
+                    raise_if_internal(e)
+                    message = "Unexpected error from injector #{impl}"
+                    signature = '(entity, type, attr, val, ctx)'
+                    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/normalizer.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative '../../mixin/reflection'
+require_relative '../../mixin/errors'
+
+module AMA
+  module Entity
+    class Mapper
+      module Handler
+        module Entity
+          # Default normalization handler
+          class Normalizer
+            include Mixin::Reflection
+
+            INSTANCE = new
+
+            # @param [Object] entity
+            # @param [AMA::Entity::Mapper::Type] type
+            # @param [AMA::Entity::Mapper::Context] _context
+            def normalize(entity, type, _context = nil)
+              type.attributes.values.each_with_object({}) do |attribute, data|
+                next if attribute.virtual || attribute.sensitive
+                data[attribute.name] = object_variable(entity, attribute.name)
+              end
+            end
+
+            class << self
+              include Mixin::Reflection
+
+              # @param [Normalizer] implementation
+              # @return [Normalizer]
+              def wrap(implementation)
+                handler = handler_factory(implementation, INSTANCE)
+                description = "Safety wrapper for #{implementation}"
+                wrapper = method_object(:normalize, to_s: description, &handler)
+                wrapper.singleton_class.instance_eval do
+                  include Mixin::Errors
+                end
+                wrapper
+              end
+
+              private
+
+              # @param [Normalizer] impl
+              # @param [Normalizer] fallback
+              # @return [Proc]
+              def handler_factory(impl, fallback)
+                lambda do |entity, type, ctx|
+                  begin
+                    impl.normalize(entity, type, ctx) do |e, t, c|
+                      fallback.normalize(e, t, c)
+                    end
+                  rescue StandardError => e
+                    raise_if_internal(e)
+                    message = "Unexpected error from normalizer #{impl}"
+                    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/validator.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative '../../mixin/reflection'
+require_relative '../../mixin/errors'
+
+module AMA
+  module Entity
+    class Mapper
+      module Handler
+        module Entity
+          # Default entity validator
+          class Validator
+            INSTANCE = new
+
+            # @param [Object] entity
+            # @param [Mapper::Type] type
+            # @param [Mapper::Context] _context
+            # @return [Array<Array<Attribute, String, Segment>] List of
+            #   violations, combined with attribute and segment
+            def validate(entity, type, _context)
+              return [] if type.instance?(entity)
+              ["Provided object is not an instance of #{type.type}"]
+            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 |entity, type, ctx|
+                  begin
+                    validator.validate(entity, type, ctx) do |e, t, c|
+                      fallback.validate(e, t, c)
+                    end
+                  rescue StandardError => e
+                    raise_if_internal(e)
+                    message = "Unexpected error from validator #{validator}"
+                    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/mixin/errors.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative '../error'
+require_relative '../error/mapping_error'
+require_relative '../error/compliance_error'
+require_relative '../error/validation_error'
+
+module AMA
+  module Entity
+    class Mapper
+      module Mixin
+        # Simple mixin that provides shortcuts for raising common errors
+        module Errors
+          error_types = %i[Mapping Compliance Validation]
+          error_namespace = ::AMA::Entity::Mapper::Error
+
+          # @!method mapping_error(message, **options)
+          #   @param [String] message
+
+          # @!method compliance_error(message, **options)
+          #   @param [String] message
+
+          # @!method validation_error(message, **options)
+          #   @param [String] message
+          error_types.each do |type|
+            method = "#{type.to_s.downcase}_error"
+            error_class = error_namespace.const_get("#{type}Error")
+            define_method method do |message, **options|
+              parent_error = options[:parent]
+              unless parent_error.nil?
+                if options[:signature] && parent_error.is_a?(ArgumentError)
+                  message += '.' if /\w$/ =~ message
+                  message += ' Does called method have signature ' \
+                    "#{options[:signature]}?"
+                end
+                message += '.' if /\w$/ =~ message
+                message += " Parent error: #{parent_error.message}"
+              end
+              if options[:context]
+                message += " (path: #{options[:context].path})"
+              end
+              raise error_class, message
+            end
+          end
+
+          # Raises error again if this is an internal error
+          # @param [Exception] e
+          def raise_if_internal(e)
+            raise e if e.is_a?(Mapper::Error)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ama-entity-mapper/mixin/handler_support.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative 'reflection'
+
+module AMA
+  module Entity
+    class Mapper
+      module Mixin
+        # This module provides Type and Attribute classes with shortcut
+        # handler :name, :method method to register handlers
+        module HandlerSupport
+          class << self
+            def included(klass)
+              declare_namespace_method(klass)
+              declare_handler_method(klass)
+            end
+
+            def declare_namespace_method(klass)
+              klass.define_singleton_method(:handler_namespace) do |namespace|
+                @handler_namespace = namespace
+              end
+            end
+
+            def declare_handler_method(klass)
+              processor = self
+              klass.define_singleton_method(:handler) do |key, method|
+                handler_name = key.capitalize
+                handler_class = @handler_namespace.const_get(handler_name)
+                processor.declare_handler_getter(klass, key, handler_class)
+                processor.declare_handler_setter(klass, key, handler_class)
+                processor.declare_handler_block_setter(klass, key, method)
+              end
+            end
+
+            def declare_handler_getter(klass, handler_key, handler_class)
+              instance = handler_class::INSTANCE
+              klass.instance_eval do
+                define_method(handler_key) do
+                  instance_variable_get("@#{handler_key}") || instance
+                end
+              end
+            end
+
+            def declare_handler_setter(klass, handler_key, handler_class)
+              klass.instance_eval do
+                define_method("#{handler_key}=") do |handler|
+                  unless handler.class == handler_class
+                    handler = handler_class.wrap(handler)
+                  end
+                  instance_variable_set("@#{handler_key}", handler)
+                  self
+                end
+              end
+            end
+
+            def declare_handler_block_setter(klass, handler_key, method)
+              klass.instance_eval do
+                include Mixin::Reflection
+                define_method("#{handler_key}_block") do |&block|
+                  send("#{handler_key}=", method_object(method, &block))
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ama-entity-mapper/mixin/reflection.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative 'errors'
+
+module AMA
+  module Entity
+    class Mapper
+      module Mixin
+        # Collection of common methods twiddling with object internals
+        module Reflection
+          include Errors
+
+          # @param [Object] object
+          # @param [String, Symbol] name
+          # @param [Object] value
+          def set_object_attribute(object, name, value)
+            method = "#{name}="
+            return object.send(method, value) if object.respond_to?(method)
+            object.instance_variable_set("@#{name}", value)
+          rescue StandardError => e
+            message = "Failed to set attribute #{name} on #{object.class}, " \
+              "this is most likely due to `#{method}` method not following " \
+              'accessor conventions'
+            mapping_error(message, parent: e)
+          end
+
+          # @param [Object] object
+          def object_variables(object)
+            intermediate = object.instance_variables.map do |variable|
+              [variable[1..-1].to_sym, object.instance_variable_get(variable)]
+            end
+            Hash[intermediate]
+          end
+
+          # @param [Object] object
+          # @param [String, Symbol] name
+          def object_variable(object, name)
+            name = "@#{name}" unless name[0] == '@'
+            object.instance_variable_get(name)
+          end
+
+          def object_variable_exists(object, name)
+            object.instance_variables.include?("@#{name}".to_sym)
+          end
+
+          def install_object_method(object, name, handler)
+            compliance_error('Handler not provided') unless handler
+            object.define_singleton_method(name, &handler)
+            object
+          end
+
+          def method_object(method, to_s: nil, &handler)
+            object = install_object_method(Object.new, method, handler)
+            unless to_s
+              to_s = "Wrapper object for proc #{handler} " \
+                "(installed as method :#{method})"
+            end
+            object.define_singleton_method(:to_s) do
+              to_s
+            end
+            object
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ama-entity-mapper/mixin/suppression_support.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'errors'
+
+module AMA
+  module Entity
+    class Mapper
+      module Mixin
+        # Special module with method for playing with error suppression
+        module SuppressionSupport
+          include Errors
+
+          # Enumerates elements in enumerator, applying block to each one,
+          # returning result or suppressing specified error. If no element
+          # has succeeded, raises last error.
+          #
+          # @param [Enumerator] enumerator
+          # @param [Class<? extends StandardError>] error
+          # @param [AMA::Entity::Mapper::Context] ctx
+          def successful(enumerator, error = StandardError, ctx = nil)
+            suppressed = []
+            enumerator.each do |*args|
+              begin
+                return yield(*args)
+              rescue error => e
+                ctx.logger.debug("#{e.class} raised: #{e.message}") if ctx
+                suppressed.push(e)
+              end
+            end
+            compliance_error('Empty enumerator passed') if suppressed.empty?
+            raise suppressed.last
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require_relative 'path/segment'
+
+module AMA
+  module Entity
+    class Mapper
+      # Wrapper for simple array. Helps to understand where exactly processing
+      # is taking place.
+      class Path
+        attr_reader :segments
+
+        def initialize(stack = [])
+          @segments = stack
+        end
+
+        def empty?
+          @segments.empty?
+        end
+
+        # @param [String, Symbol, Integer] name
+        # @return [AMA::Entity::Mapper::Path]
+        def index(name)
+          push(Segment.index(name))
+        end
+
+        # @param [String, Symbol] name
+        # @return [AMA::Entity::Mapper::Path]
+        def attribute(name)
+          push(Segment.attribute(name))
+        end
+
+        # @param [Array<AMA::Entity::Mapper::Path::Segment>] segments
+        # @return [AMA::Entity::Mapper::Path]
+        def push(*segments)
+          segments = segments.map do |segment|
+            next segment if segment.is_a?(Segment)
+            Segment.attribute(segment)
+          end
+          self.class.new(@segments + segments)
+        end
+
+        # @return [AMA::Entity::Mapper::Path]
+        def pop
+          self.class.new(@segments[0..-2])
+        end
+
+        # @return [AMA::Entity::Mapper::Path::Segment]
+        def current
+          @segments.last
+        end
+
+        def each
+          @segments.each do |item|
+            yield(item)
+          end
+        end
+
+        def reduce(carrier)
+          @segments.reduce(carrier) do |inner_carrier, item|
+            yield(inner_carrier, item)
+          end
+        end
+
+        # @param [AMA::Entity::Mapper::Path] path
+        # @return [AMA::Entity::Mapper::Path]
+        def merge(path)
+          push(*path.segments)
+        end
+
+        def size
+          @segments.size
+        end
+
+        def segments
+          @segments.clone
+        end
+
+        # @return [Array<AMA::Entity::Mapper::Path::Segment>]
+        def to_a
+          @segments.clone
+        end
+
+        # @return [String]
+        def to_s
+          "$#{@segments.join}"
+        end
+      end
+    end
+  end
+end