ama-team / ruby-entity-mapper

module AMA

  module Entity

    class Mapper

      module API

        module Wrapper

          # Factory safety wrapper

          class Factory < API::Factory

            include Mixin::Errors

            # @param [AMA::Entity::Mapper::API::Factory] processor

            def initialize(processor)

              @processor = processor

              @fallback = Default::Factory::INSTANCE

            end

            # @param [AMA::Entity::Mapper::Type] type

            # @param [Object] data

            # @param [AMA::Entity::Mapper::Context] context

            def create(type, data = nil, context = nil)

              context ||= Context.new

              @processor.create(type, data, context) do |t, d, c|

                @fallback.create(t, d, c)

              end

            rescue StandardError => e

              raise_if_internal(e)

              message = "Error while creatin #{type} instance " \

                "(type: #{type}) attributes using #{@processor}"

              if e.is_a?(ArgumentError)

                message += "Does #{@processor}#create have signature " \

                  '(entity, type, context = nil)?'

              end

              mapping_error(message, parent: e, context: context)

            end

          end

        end

      end

    end

  end

end

module AMA

  module Entity

    class Mapper

      module API

        module Wrapper

          # Default attribute injector

          class Normalizer < API::Normalizer

            include Mixin::Errors

            # @param [AMA::Entity::Mapper::API::Normalizer] processor

            def initialize(processor)

              @processor = processor

              @fallback = Default::Normalizer::INSTANCE

            end

            # @param [Object] entity

            # @param [AMA::Entity::Mapper::Type] type

            # @param [AMA::Entity::Mapper::Context] context

            def normalize(entity, type, context = nil)

              ctx = context || Context.new

              @processor.normalize(entity, type, ctx) do |e, t, c|

                @fallback.normalize(e, t, c)

              end

            rescue StandardError => e

              raise_if_internal(e)

              message = "Error while normalizing #{entity} (type: #{type}) " \

                "using #{@processor}"

              if e.is_a?(ArgumentError)

                message += "Does #{@processor}#normalize have signature " \

                  '(entity, type, context = nil)?'

              end

              mapping_error(message, parent: e, context: ctx)

            end

          end

        end

      end

    end

  end

end

module AMA

  module Entity

    class Mapper

      module API

        module Wrapper

          # Denormalizer safety wrapper

          class Denormalizer < API::Denormalizer

            include Mixin::Errors

            # @param [AMA::Entity::Mapper::API::Denormalizer] processor

            def initialize(processor)

              @processor = processor

              @fallback = Default::Denormalizer::INSTANCE

            end

            # @param [Hash] source

            # @param [AMA::Entity::Mapper::Type] type

            # @param [AMA::Entity::Mapper::Context] context

            def denormalize(source, type, context = nil)

              ctx = context || Context.new

              @processor.denormalize(source, type, ctx) do |s, t, c|

                @fallback.denormalize(s, t, c)

              end

            rescue StandardError => e

              raise_if_internal(e)

              message = "Error while denormalizing #{type} " \

                "(type: #{type}) from #{source.class} using #{@processor}"

              if e.is_a?(ArgumentError)

                message += "Does #{@processor}#denormalize have signature " \

                  '(entity, source, type, context = nil)?'

              end

              mapping_error(message, parent: e, context: ctx)

            end

          end

        end

      end

    end

  end

end

module AMA

  module Entity

    class Mapper

      module API

        module Wrapper

          # Denormalizer safety wrapper

          class Enumerator < API::Enumerator

            include Mixin::Errors

            # @param [AMA::Entity::Mapper::API::Enumerator] processor

            def initialize(processor)

              @processor = processor

              @fallback = Default::Enumerator::INSTANCE

            end

            # @param [Object] entity

            # @param [AMA::Entity::Mapper::Type] type

            # @param [AMA::Entity::Mapper::Context] context

            def enumerate(entity, type, context = nil)

              context ||= Context.new

              @processor.enumerate(entity, type, context) do |e, t, c|

                @fallback.enumerate(e, t, c)

              end

            rescue StandardError => e

              raise_if_internal(e)

              message = "Error while enumerating #{entity.class} " \

                "(type: #{type}) attributes using #{@processor}"

              if e.is_a?(ArgumentError)

                message += "Does #{@processor}#enumerate have signature " \

                  '(entity, type, context = nil)?'

              end

              mapping_error(message, parent: e, context: context)

            end

          end

        end

      end

    end

  end

end