rom-mapper 0.1.0

data/lib/rom/mapper/attribute.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+module ROM
+  class Mapper
+
+    # Represents a mapping attribute
+    #
+    # @private
+    class Attribute < Struct.new(:name, :field)
+      include Adamantium, Equalizer.new(:name, :field)
+
+      # @api private
+      def self.coerce(input, mapping = nil)
+        field = Axiom::Attribute.coerce(input)
+        new(mapping || field.name, field)
+      end
+
+      # @api private
+      def tuple_key
+        field.name
+      end
+
+    end # Attribute
+
+  end # Mapper
+end # ROM

data/lib/rom/mapper/dumper.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+module ROM
+  class Mapper
+
+    # Dumps an object back into a tuple
+    #
+    # @private
+    class Dumper
+      include Concord::Public.new(:header), Adamantium
+
+      # @api private
+      def call(object)
+        header.each_with_object([]) { |attribute, tuple|
+          tuple << object.send(attribute.name)
+        }
+      end
+
+      # @api private
+      def identity(object)
+        header.keys.map { |key| object.send("#{key.name}") }
+      end
+
+    end # Dumper
+
+  end # Mapper
+end # ROM

data/lib/rom/mapper/header.rb

@@ -0,0 +1,78 @@
+# encoding: utf-8
+
+module ROM
+  class Mapper
+
+    # Mapper header wrapping axiom header and providing mapping information
+    #
+    # @private
+    class Header
+      include Enumerable, Concord.new(:header, :attributes), Adamantium
+
+      # Build a header
+      #
+      # @api private
+      def self.build(input, options = {})
+        return input if input.is_a?(self)
+
+        keys       = options.fetch(:keys, [])
+        header     = Axiom::Relation::Header.coerce(input, keys: keys)
+
+        mapping    = options.fetch(:map, {})
+        attributes = header.each_with_object({}) { |field, object|
+          attribute = Attribute.coerce(field, mapping[field.name])
+          object[attribute.name] = attribute
+        }
+
+        new(header, attributes)
+      end
+
+      # Return attribute mapping
+      #
+      # @api private
+      def mapping
+        each_with_object({}) { |attribute, hash|
+          hash[attribute.tuple_key] = attribute.name
+        }
+      end
+      memoize :mapping
+
+      # Return all key attributes
+      #
+      # @return [Array<Attribute>]
+      #
+      # @api public
+      def keys
+        # FIXME: find a way to simplify this
+        header.keys.flat_map { |key_header|
+          key_header.flat_map { |key|
+            attributes.values.select { |attribute|
+              attribute.tuple_key == key.name
+            }
+          }
+        }
+      end
+      memoize :keys
+
+      # Return attribute with the given name
+      #
+      # @return [Attribute]
+      #
+      # @api public
+      def [](name)
+        attributes.fetch(name)
+      end
+
+      # Iterate over attributes
+      #
+      # @api private
+      def each(&block)
+        return to_enum unless block_given?
+        attributes.each_value(&block)
+        self
+      end
+
+    end # Header
+
+  end # Mapper
+end # ROM

data/lib/rom/mapper/loader.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+module ROM
+  class Mapper
+
+    # Abstract loader class
+    #
+    # @private
+    class Loader
+      include Concord::Public.new(:header, :model), Adamantium, AbstractType
+
+      abstract_method :call
+
+      # @api public
+      def identity(tuple)
+        header.keys.map { |key| tuple[key.name] }
+      end
+
+    end # Loader
+
+  end # Mapper
+end # ROM

data/lib/rom/mapper/loader/allocator.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+module ROM
+  class Mapper
+    class Loader
+
+      # Loader class which doesn't call initialize
+      #
+      # @private
+      class Allocator < self
+
+        # @api private
+        def call(tuple)
+          allocate { |attribute, object|
+            object.instance_variable_set(
+              "@#{attribute.name}", tuple[attribute.name]
+            )
+          }
+        end
+
+        private
+
+        # @api private
+        def allocate(&block)
+          header.each_with_object(model.allocate, &block)
+        end
+
+      end # Allocator
+
+    end # Loader
+  end # Mapper
+end # ROM

data/lib/rom/mapper/loader/attribute_writer.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+module ROM
+  class Mapper
+    class Loader
+
+      # Special type of Allocator loader which uses attribute writers
+      #
+      # @private
+      class AttributeWriter < Allocator
+
+        # @api private
+        def call(tuple)
+          allocate { |attribute, object|
+            object.public_send("#{attribute.name}=", tuple[attribute.name])
+          }
+        end
+
+      end # AttributeWriter
+
+    end # Loader
+  end # Mapper
+end # ROM

data/lib/rom/mapper/loader/object_builder.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+module ROM
+  class Mapper
+    class Loader
+
+      # Loader class that calls initialize
+      #
+      # @private
+      class ObjectBuilder < self
+
+        # @api private
+        def call(tuple)
+          model.new(attributes(tuple))
+        end
+
+        private
+
+        # @api private
+        def attributes(tuple)
+          Hash[header.map { |attribute| [attribute.name, tuple[attribute.name]] }]
+        end
+
+      end # ObjectBuilder
+
+    end # Loader
+  end # Mapper
+end # ROM

data/lib/rom/version.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+module ROM
+
+  class Mapper
+
+    VERSION = '0.1.0'.freeze
+
+  end # Mapper
+
+end # ROM

data/rom-mapper.gemspec

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require File.expand_path('../lib/rom/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = "rom-mapper"
+  gem.description   = "rom-mapper"
+  gem.summary       = gem.description
+  gem.authors       = 'Piotr Solnica'
+  gem.email         = 'piotr.solnica@gmail.com'
+  gem.homepage      = 'http://rom-rb.org'
+  gem.require_paths = [ 'lib' ]
+  gem.version       = ROM::Mapper::VERSION.dup
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {spec}/*`.split("\n")
+  gem.license       = 'MIT'
+
+  gem.add_dependency 'concord',             '~> 0.1.4'
+  gem.add_dependency 'equalizer',           '~> 0.0.7'
+  gem.add_dependency 'descendants_tracker', '~> 0.0.1'
+  gem.add_dependency 'abstract_type',       '~> 0.0.6'
+  gem.add_dependency 'adamantium',          '~> 0.1'
+end

data/spec/shared/unit/loader_call.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+shared_examples_for 'Mapper::Loader#call' do
+  subject(:loader) { described_class.new(header, model) }
+
+  let(:header) { Mapper::Header.build([[:id, Integer], [:name, String]]) }
+  let(:tuple)  { Hash[id: 1, name: 'Jane', something: 'foo'] }
+  let(:model)  { mock_model(:id, :name) }
+
+  it 'returns loaded object' do
+    expect(loader.call(tuple)).to eq(model.new(id: 1, name: 'Jane'))
+  end
+end

data/spec/shared/unit/loader_identity.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+shared_examples_for 'Mapper::Loader#identity' do
+  subject(:loader) { described_class.new(header, model) }
+
+  let(:header) { Mapper::Header.build([[:id, Integer], [:name, String]], keys: [:id]) }
+  let(:tuple)  { Hash[id: 1, name: 'Jane'] }
+  let(:model)  { mock_model(:id, :name) }
+
+  it "returns object's identity" do
+    expect(loader.identity(tuple)).to eq([1])
+  end
+end

data/spec/shared/unit/mapper_context.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+shared_context 'Mapper' do
+  let(:mapper) { described_class.new(header, loader, dumper) }
+
+  let(:header) { fake(:header) { Mapper::Header } }
+  let(:loader) { fake(:loader, model: model) { Mapper::Loader } }
+  let(:dumper) { fake(:dumper) { Mapper::Dumper } }
+  let(:data)   { [1, 'Jane'] }
+  let(:tuple)  { Hash[id: 1, name: 'Jane'] }
+  let(:object) { model.new(id: 1, name: 'Jane') }
+  let(:model)  { mock_model(:id, :name) }
+end

data/spec/spec_helper.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+if ENV['COVERAGE'] == 'true'
+  require 'simplecov'
+  require 'coveralls'
+
+  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+    SimpleCov::Formatter::HTMLFormatter,
+    Coveralls::SimpleCov::Formatter
+  ]
+
+  SimpleCov.start do
+    command_name 'spec:unit'
+
+    add_filter 'config'
+    add_filter 'lib/rom/support'
+    add_filter 'spec'
+  end
+end
+
+require 'rom-mapper'
+require 'axiom'
+
+require 'devtools/spec_helper'
+require 'bogus/rspec'
+
+Bogus.configure do |config|
+  config.search_modules << ROM
+end
+
+RSpec.configure do |config|
+  config.mock_with Bogus::RSpecAdapter
+end
+
+include ROM
+
+def mock_model(*attributes)
+  Class.new {
+    include Equalizer.new(*attributes)
+
+    attributes.each { |attribute| attr_accessor attribute }
+
+    def initialize(attrs, &block)
+      attrs.each { |name, value| send("#{name}=", value) }
+      instance_eval(&block) if block
+    end
+  }
+end

data/spec/unit/rom/mapper/call_spec.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Mapper, '#call' do
+  subject { object.call(relation) }
+
+  let(:object) {
+    Mapper.build(header, model)
+  }
+
+  let(:header) {
+    Mapper::Header.build(
+      [[:user_id, Integer], [:user_name, String], [:age, Integer]],
+      map: { user_id: :id, user_name: :name }
+    )
+  }
+
+  let(:model) {
+    OpenStruct
+  }
+
+  let(:relation) {
+    Axiom::Relation::Base.new(:users, [
+      [:user_id, Integer], [:user_name, String], [:email, String], [:age, Integer]
+    ])
+  }
+
+  it 'renames relation' do
+    expect(subject.header.map(&:name)).to eq([:id, :name, :age])
+  end
+end

data/spec/unit/rom/mapper/class_methods/build_spec.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Mapper, '.build' do
+  subject { described_class.build(header, model, options) }
+
+  let(:model)      { mock_model(:name) }
+  let(:attributes) { [[:user_name, String]] }
+  let(:options)    { Hash[map: { user_name: :name }] }
+
+  describe 'when header is a primitive' do
+    let(:header) { attributes }
+
+    its(:model)  { should be(model) }
+    its(:loader) { should be_instance_of(Mapper::LOADERS[:allocator]) }
+    its(:dumper) { should be_instance_of(Mapper::Dumper) }
+
+    it 'builds correct header' do
+      expect(subject.header.mapping).to eql(options[:map])
+    end
+
+    let(:object) { model.new(name: 'Jane') }
+    let(:params) { Hash[name: 'Jane'] }
+
+    specify do
+      expect(subject.load(params)).to eq(object)
+    end
+
+    specify do
+      expect(subject.dump(object)).to eq(params.values)
+    end
+  end
+
+  describe 'when header is a mapper header instance' do
+    let(:header)  { Mapper::Header.build(attributes) }
+    let(:options) { Hash.new }
+
+    its(:model)  { should be(model) }
+    its(:loader) { should be_instance_of(Mapper::LOADERS[:allocator]) }
+    its(:dumper) { should be_instance_of(Mapper::Dumper) }
+    its(:header) { should be(header) }
+  end
+
+  describe 'when options has custom loader' do
+    let(:header)  { Mapper::Header.build(attributes) }
+    let(:options) { Hash[loader: :object_builder] }
+
+    its(:model)  { should be(model) }
+    its(:loader) { should be_instance_of(Mapper::LOADERS[:object_builder]) }
+    its(:dumper) { should be_instance_of(Mapper::Dumper) }
+    its(:header) { should be(header) }
+  end
+
+  describe 'loader is set to :attribute_writer' do
+    let(:header)  { Mapper::Header.build(attributes) }
+    let(:options) { Hash[loader: :attribute_writer] }
+
+    its(:model)  { should be(model) }
+    its(:loader) { should be_instance_of(Mapper::LOADERS[:attribute_writer]) }
+    its(:dumper) { should be_instance_of(Mapper::Dumper) }
+    its(:header) { should be(header) }
+  end
+end