ama-team / ruby-entity-mapper

          class Enumerable

            include ::AMA::Entity::Mapper::Mixin::Reflection

            include ::AMA::Entity::Mapper::Mixin::Errors

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

            def supports(type)

              type.type.included_modules.include?(::Enumerable)

            end

            # @param [Object] source

            # @param [AMA::Entity::Mapper::Engine::Context] _context

            # @param [AMA::Entity::Mapper::Type::Concrete] target_type

            def denormalize(source, _context, target_type)

              return source if source.is_a?(target_type.type)

              # TODO: this is cool and would probably work, however, provided

              # factory should be used instead

              target_type.type.new(source)

            rescue ArgumentError => e

              message = "Failed to instantiate #{target_type}: #{e.message}." \

                'Does it follow standard convention accepting enumerable as ' \

                '#initialize() argument?'

              mapping_error(message, nil)

            rescue StandardError => e

              mapping_error("Failed to instantiate #{target_type}", e)

            end

            private

            def instantiate(type)

              type.type.new

            rescue ArgumentError => e

              message = "Failed to instantiate object of type #{type}: " \

                "#{e.message}. Have you passed class with " \

                'mandatory parameters in #initialize method?'

              mapping_error(message, nil)

            rescue StandardError => e

              message = "Failed to instantiate object of type #{type}"

              mapping_error(message, e)

            end

          end