rom-mapper 0.1.1 → 0.2.0

data/lib/rom/mapper/attribute.rb

@@ -1,31 +0,0 @@
-# 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 mapping
-        { tuple_key => name }
-      end
-
-      # @api private
-      def tuple_key
-        field.name
-      end
-
-    end # Attribute
-
-  end # Mapper
-end # ROM

data/lib/rom/mapper/dumper.rb

@@ -1,27 +0,0 @@
-# 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/loader.rb

@@ -1,22 +0,0 @@
-# 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

@@ -1,32 +0,0 @@
-# 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

@@ -1,23 +0,0 @@
-# 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

@@ -1,28 +0,0 @@
-# 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.attribute_names.map { |name| [name, tuple[name]] }]
-        end
-
-      end # ObjectBuilder
-
-    end # Loader
-  end # Mapper
-end # ROM

data/spec/shared/unit/loader_call.rb

@@ -1,13 +0,0 @@
-# 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

@@ -1,13 +0,0 @@
-# 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

@@ -1,13 +0,0 @@
-# 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/unit/rom/mapper/call_spec.rb

@@ -1,32 +0,0 @@
-# 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

@@ -1,64 +0,0 @@
-# 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

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

@@ -1,15 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mapper, '#dump' do
-  include_context 'Mapper'
-
-  it 'dumps the object into data tuple' do
-    stub(dumper).call(object) { data }
-
-    expect(mapper.dump(object)).to be(data)
-
-    dumper.should have_received.call(object)
-  end
-end

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

@@ -1,29 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mapper::Dumper, '#call' do
-  subject(:dumper) { described_class.new(header) }
-
-  let(:header) { Mapper::Header.build([[:uid, Integer], [:name, String]], map: { uid: :id }, keys: [:uid]) }
-  let(:data)   { Hash[id: 1, name: 'Jane'] }
-  let(:model)  { mock_model(:id, :name) }
-  let(:object) { model.new(data) }
-
-  context 'with public attribute readers' do
-    it 'returns dumped tuple' do
-      expect(dumper.call(object)).to eq([1, 'Jane'])
-    end
-  end
-
-  context 'with private attribute readers' do
-    before do
-      model.send(:private, :id)
-      model.send(:private, :name)
-    end
-
-    it 'returns dumped tuple' do
-      expect(dumper.call(object)).to eq([1, 'Jane'])
-    end
-  end
-end

data/spec/unit/rom/mapper/dumper/identity_spec.rb

@@ -1,28 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mapper::Dumper, '#identity' do
-  subject(:dumper) { described_class.new(header) }
-
-  let(:header) { Mapper::Header.build([[:uid, Integer], [:name, String]], map: { uid: :id }, keys: [:uid]) }
-  let(:data)   { Hash[id: 1, name: 'Jane'] }
-  let(:model)  { mock_model(:id, :name) }
-  let(:object) { model.new(data) }
-
-  context 'with public attribute readers' do
-    it "returns object's identity" do
-      expect(dumper.identity(object)).to eq([1])
-    end
-  end
-
-  context 'with private attribute readers' do
-    before do
-      model.send(:private, :id)
-    end
-
-    it "returns object's identity" do
-      expect(dumper.identity(object)).to eq([1])
-    end
-  end
-end

data/spec/unit/rom/mapper/header/each_spec.rb

@@ -1,28 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mapper::Header, '#each' do
-  let(:object)     { Mapper::Header.build(attributes) }
-  let(:attributes) { [[:id, Integer], [:name, String]] }
-  let(:id)         { object[:id] }
-  let(:name)       { object[:name] }
-
-  context 'with a block' do
-    subject { object.each { |attribute| result << attribute } }
-
-    let(:result) { [] }
-
-    it { should be(object) }
-
-    specify do
-      expect { subject }.to change { result }.from([]).to([id, name])
-    end
-  end
-
-  context 'without a block' do
-    subject { object.each }
-
-    it { should be_instance_of(Enumerator) }
-  end
-end

data/spec/unit/rom/mapper/header/element_reader_spec.rb

@@ -1,25 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mapper::Header, '#[]' do
-  subject { object[name] }
-
-  let(:object)     { Mapper::Header.build(attributes) }
-  let(:attributes) { [[:id, Integer]] }
-
-  context 'when attribute exists' do
-    let(:name) { :id }
-    let(:id)   { Mapper::Attribute.coerce(attributes.first) }
-
-    it { should eql(id) }
-  end
-
-  context 'when attribute does not exist' do
-    let(:name) { :not_here }
-
-    specify do
-      expect { subject }.to raise_error(KeyError)
-    end
-  end
-end