rom 0.4.2 → 0.5.0

data/spec/unit/rom/mapper_spec.rb

@@ -4,7 +4,7 @@ require 'ostruct'
 
 describe ROM::Mapper do
   subject(:mapper) do
-    ROM::Mapper.build(ROM::Header.coerce(relation.header.zip), user_model)
+    ROM::Mapper.build(ROM::Header.coerce(relation.header.zip, user_model))
   end
 
   let(:relation) do
@@ -13,7 +13,7 @@ describe ROM::Mapper do
 
   let(:dataset) do
     ROM::Adapter::Memory::Dataset.new(
-      [{id: 1, name: 'Jane'}, {id: 2, name: 'Joe'}], [:id, :name]
+      [{ id: 1, name: 'Jane' }, { id: 2, name: 'Joe' }], [:id, :name]
     )
   end
 
@@ -28,12 +28,11 @@ describe ROM::Mapper do
     it "yields all mapped objects" do
       result = []
 
-      relation.each do |tuple|
-        result << mapper.load(tuple)
+      mapper.process(relation).each do |tuple|
+        result << tuple
       end
 
       expect(result).to eql([jane, joe])
     end
   end
-
 end

data/spec/unit/rom/model_builder_spec.rb

@@ -5,7 +5,7 @@ describe ROM::ModelBuilder do
     it 'builds a class with a constructor accepting attributes' do
       builder = ROM::ModelBuilder::PORO.new
 
-      klass = builder.call(name: :user_name)
+      klass = builder.call([:name])
 
       object = klass.new(name: 'Jane')
 
@@ -13,7 +13,7 @@ describe ROM::ModelBuilder do
 
       expect { object.name = 'Jane' }.to raise_error(NoMethodError)
 
-      klass = builder.call(name: :user_name, email: :user_email)
+      klass = builder.call([:name, :email])
 
       object = klass.new(name: 'Jane', email: 'jane@doe.org')
 
@@ -21,23 +21,25 @@ describe ROM::ModelBuilder do
       expect(object.email).to eql('jane@doe.org')
     end
 
-    it 'defines a constant for the model when :name option is present' do
-      builder = ROM::ModelBuilder::PORO.new(name: 'User')
+    context 'when :name option is present' do
+      it 'defines a constant for the model' do
+        builder = ROM::ModelBuilder::PORO.new(name: 'User')
 
-      builder.call(name: :user_name, email: :user_email)
+        builder.call([:name, :email])
 
-      expect(Object.const_defined?(:User)).to be(true)
-    end
+        expect(Object.const_defined?(:User)).to be(true)
+      end
 
-    it 'defines a constant within a namespace for the model when :name option is present' do
-      module MyApp; module Entities; end; end
+      it 'defines a constant within a namespace for the model' do
+        module MyApp; module Entities; end; end
 
-      builder = ROM::ModelBuilder::PORO.new(name: 'MyApp::Entities::User')
+        builder = ROM::ModelBuilder::PORO.new(name: 'MyApp::Entities::User')
 
-      builder.call(name: :user_name, email: :user_email)
+        builder.call([:name, :email])
 
-      expect(MyApp::Entities.const_defined?(:User)).to be(true)
-      expect(Object.const_defined?(:User)).to be(false)
+        expect(MyApp::Entities.const_defined?(:User)).to be(true)
+        expect(Object.const_defined?(:User)).to be(false)
+      end
     end
   end
 end

data/spec/unit/rom/processor/transproc_spec.rb

@@ -0,0 +1,331 @@
+require 'spec_helper'
+
+describe ROM::Processor::Transproc do
+  subject(:transproc) { ROM::Processor::Transproc.build(header) }
+
+  let(:header) { ROM::Header.coerce(attributes) }
+
+  context 'no mapping' do
+    let(:attributes) { [[:name]] }
+    let(:relation) { [{ name: 'Jane' }, { name: 'Joe' }] }
+
+    it 'returns tuples' do
+      expect(transproc[relation]).to eql(relation)
+    end
+  end
+
+  context 'coercing values' do
+    let(:attributes) { [[:name, type: :string], [:age, type: :integer]] }
+    let(:relation) { [{ name: :Jane, age: '1' }, { name: :Joe, age: '2' }] }
+
+    it 'returns tuples' do
+      expect(transproc[relation]).to eql([
+        { name: 'Jane', age: 1 }, { name: 'Joe', age: 2 }
+      ])
+    end
+  end
+
+  context 'mapping to object' do
+    let(:header) { ROM::Header.coerce(attributes, model) }
+
+    let(:model) do
+      Class.new do
+        include Virtus.value_object
+        values { attribute :name }
+      end
+    end
+
+    let(:attributes) { [[:name]] }
+    let(:relation) { [{ name: 'Jane' }, { name: 'Joe' }] }
+
+    it 'returns tuples' do
+      expect(transproc[relation]).to eql([
+        model.new(name: 'Jane'), model.new(name: 'Joe')
+      ])
+    end
+  end
+
+  context 'renaming keys' do
+    let(:attributes) { [[:name, from: 'name']] }
+    let(:relation) { [{ 'name' => 'Jane' }, { 'name' => 'Joe' }] }
+
+    it 'returns tuples with renamed keys' do
+      expect(transproc[relation]).to eql([{ name: 'Jane' }, { name: 'Joe' }])
+    end
+  end
+
+  context 'mapping nested hash' do
+    let(:relation) do
+      [
+        { 'name' => 'Jane', 'task' => { 'title' => 'Task One' } },
+        { 'name' => 'Joe', 'task' => { 'title' => 'Task Two' } }
+      ]
+    end
+
+    context 'when no mapping is needed' do
+      let(:attributes) { [['name'], ['task', type: :hash, header: [[:title]]]] }
+
+      it 'returns tuples' do
+        expect(transproc[relation]).to eql(relation)
+      end
+    end
+
+    context 'with deeply nested hashes' do
+      context 'when no renaming is required' do
+        let(:relation) do
+          [
+            { 'user' => { 'name' => 'Jane', 'task' => { 'title' => 'Task One' } } },
+            { 'user' => { 'name' => 'Joe', 'task' => { 'title' => 'Task Two' } } }
+          ]
+        end
+
+        let(:attributes) do
+          [[
+            'user', type: :hash, header: [
+              ['name'],
+              ['task', type: :hash, header: [['title']]]
+            ]
+          ]]
+        end
+
+        it 'returns tuples' do
+          expect(transproc[relation]).to eql(relation)
+        end
+      end
+
+      context 'when renaming is required' do
+        let(:relation) do
+          [
+            { user: { name: 'Jane', task: { title: 'Task One' } } },
+            { user: { name: 'Joe', task: { title: 'Task Two' } } }
+          ]
+        end
+
+        let(:attributes) do
+          [[
+            'user', type: :hash, header: [
+              ['name'],
+              ['task', type: :hash, header: [['title']]]
+            ]
+          ]]
+        end
+
+        it 'returns tuples' do
+          expect(transproc[relation]).to eql(relation)
+        end
+      end
+    end
+
+    context 'renaming keys' do
+      context 'when only hash needs renaming' do
+        let(:attributes) do
+          [
+            ['name'],
+            [:task, from: 'task', type: :hash, header: [[:title, from: 'title']]]
+          ]
+        end
+
+        it 'returns tuples with key renamed in the nested hash' do
+          expect(transproc[relation]).to eql([
+            { 'name' => 'Jane', :task => { title: 'Task One' } },
+            { 'name' => 'Joe', :task => { title: 'Task Two' } }
+          ])
+        end
+      end
+
+      context 'when all attributes need renaming' do
+        let(:attributes) do
+          [
+            [:name, from: 'name'],
+            [:task, from: 'task', type: :hash, header: [[:title, from: 'title']]]
+          ]
+        end
+
+        it 'returns tuples with key renamed in the nested hash' do
+          expect(transproc[relation]).to eql([
+            { name: 'Jane', task: { title: 'Task One' } },
+            { name: 'Joe', task: { title: 'Task Two' } }
+          ])
+        end
+      end
+    end
+  end
+
+  context 'wrapping tuples' do
+    let(:relation) do
+      [
+        { 'name' => 'Jane', 'title' => 'Task One' },
+        { 'name' => 'Joe', 'title' => 'Task Two' }
+      ]
+    end
+
+    context 'when no mapping is needed' do
+      let(:attributes) do
+        [
+          ['name'],
+          ['task', type: :hash, wrap: true, header: [['title']]]
+        ]
+      end
+
+      it 'returns wrapped tuples' do
+        expect(transproc[relation]).to eql([
+          { 'name' => 'Jane', 'task' => { 'title' => 'Task One' } },
+          { 'name' => 'Joe', 'task' => { 'title' => 'Task Two' } }
+        ])
+      end
+    end
+
+    context 'with deeply wrapped tuples' do
+      let(:attributes) do
+        [
+          ['user', type: :hash, wrap: true, header: [
+            ['name'],
+            ['task', type: :hash, wrap: true, header: [['title']]]
+          ]]
+        ]
+      end
+
+      it 'returns wrapped tuples' do
+        expect(transproc[relation]).to eql([
+          { 'user' => { 'name' => 'Jane', 'task' => { 'title' => 'Task One' } } },
+          { 'user' => { 'name' => 'Joe', 'task' => { 'title' => 'Task Two' } } }
+        ])
+      end
+    end
+
+    context 'renaming keys' do
+      context 'when only wrapped tuple requires renaming' do
+        let(:attributes) do
+          [
+            ['name'],
+            ['task', type: :hash, wrap: true, header: [[:title, from: 'title']]]
+          ]
+        end
+
+        it 'returns wrapped tuples with renamed keys' do
+          expect(transproc[relation]).to eql([
+            { 'name' => 'Jane', 'task' => { title: 'Task One' } },
+            { 'name' => 'Joe', 'task' => { title: 'Task Two' } }
+          ])
+        end
+      end
+
+      context 'when all attributes require renaming' do
+        let(:attributes) do
+          [
+            [:name, from: 'name'],
+            [:task, type: :hash, wrap: true, header: [[:title, from: 'title']]]
+          ]
+        end
+
+        it 'returns wrapped tuples with all keys renamed' do
+          expect(transproc[relation]).to eql([
+            { name: 'Jane', task: { title: 'Task One' } },
+            { name: 'Joe', task: { title: 'Task Two' } }
+          ])
+        end
+      end
+    end
+  end
+
+  context 'grouping tuples' do
+    let(:relation) do
+      [
+        { 'name' => 'Jane', 'title' => 'Task One' },
+        { 'name' => 'Jane', 'title' => 'Task Two' },
+        { 'name' => 'Joe', 'title' => 'Task One' }
+      ]
+    end
+
+    context 'when no mapping is needed' do
+      let(:attributes) do
+        [
+          ['name'],
+          ['tasks', type: :array, group: true, header: [['title']]]
+        ]
+      end
+
+      it 'returns wrapped tuples with all keys renamed' do
+        expect(transproc[relation]).to eql([
+          { 'name' => 'Jane',
+            'tasks' => [{ 'title' => 'Task One' }, { 'title' => 'Task Two' }] },
+          { 'name' => 'Joe',
+            'tasks' => [{ 'title' => 'Task One' }] }
+        ])
+      end
+    end
+
+    context 'renaming keys' do
+      context 'when only grouped tuple requires renaming' do
+        let(:attributes) do
+          [
+            ['name'],
+            ['tasks', type: :array, group: true, header: [[:title, from: 'title']]]
+          ]
+        end
+
+        it 'returns grouped tuples with renamed keys' do
+          expect(transproc[relation]).to eql([
+            { 'name' => 'Jane',
+              'tasks' => [{ title: 'Task One' }, { title: 'Task Two' }] },
+            { 'name' => 'Joe',
+              'tasks' => [{ title: 'Task One' }] }
+          ])
+        end
+      end
+
+      context 'when all attributes require renaming' do
+        let(:attributes) do
+          [
+            [:name, from: 'name'],
+            [:tasks, type: :array, group: true, header: [[:title, from: 'title']]]
+          ]
+        end
+
+        it 'returns grouped tuples with all keys renamed' do
+          expect(transproc[relation]).to eql([
+            { name: 'Jane',
+              tasks: [{ title: 'Task One' }, { title: 'Task Two' }] },
+            { name: 'Joe',
+              tasks: [{ title: 'Task One' }] }
+          ])
+        end
+      end
+    end
+
+    context 'nested grouping' do
+      let(:relation) do
+        [
+          { name: 'Jane', title: 'Task One', tag: 'red' },
+          { name: 'Jane', title: 'Task One', tag: 'green' },
+          { name: 'Joe', title: 'Task One', tag: 'blue' }
+        ]
+      end
+
+      let(:attributes) do
+        [
+          [:name],
+          [:tasks, type: :array, group: true, header: [
+            [:title],
+            [:tags, type: :array, group: true, header: [[:tag]]]
+          ]]
+        ]
+      end
+
+      it 'returns deeply grouped tuples' do
+        expect(transproc[relation]).to eql([
+          { name: 'Jane',
+            tasks: [
+              { title: 'Task One', tags: [{ tag: 'red' }, { tag: 'green' }] }
+            ]
+          },
+          { name: 'Joe',
+            tasks: [
+              { title: 'Task One', tags: [{ tag: 'blue' }] }
+            ]
+          }
+        ])
+      end
+    end
+  end
+end

data/spec/unit/rom/reader_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe ROM::Reader do
+  subject(:reader) { ROM::Reader.new(name, relation, mappers) }
+
+  let(:name) { :users }
+  let(:relation) { [jane, joe] }
+  let(:jane) { { name: 'Jane' } }
+  let(:joe) { { name: 'Joe' } }
+  let(:mappers) { ROM::MapperRegistry.new(users: mapper) }
+  let(:mapper) { double('mapper', header: []) }
+
+  describe '#initialize' do
+    it 'raises error when mapper cannot be found' do
+      expect { ROM::Reader.new(:not_here, relation, mappers) }
+        .to raise_error(ROM::Reader::MapperMissingError, /not_here/)
+    end
+  end
+
+  describe '#each' do
+    it 'yields mapped tuples from relations' do
+      expect(mapper).to receive(:process)
+        .with(relation)
+        .and_yield(jane).and_yield(joe)
+
+      result = []
+      reader.each { |user| result << user }
+      expect(result).to eql([jane, joe])
+    end
+  end
+
+  describe '.build' do
+    subject(:reader) { ROM::Reader.build(name, relation, mappers, [:all]) }
+
+    before do
+      relation.instance_exec do
+        def name
+          'users'
+        end
+
+        def all(*_args)
+          find_all
+        end
+      end
+    end
+
+    it 'sets reader class name' do
+      expect(reader.class.name).to eql("ROM::Reader[Users]")
+    end
+
+    it 'defines methods from relation' do
+      block = proc {}
+
+      expect(relation).to receive(:all)
+        .with(1, &block)
+        .and_return([joe])
+
+      expect(mapper).to receive(:process)
+        .with([joe])
+        .and_yield(joe)
+
+      result = reader.all(1, &block)
+
+      expect(result.path).to eql('users.all')
+      expect(result.to_a).to eql([joe])
+    end
+
+    it 'raises error when relation does not respond to the method' do
+      expect { reader.not_here }
+        .to raise_error(ROM::NoRelationError, /not_here/)
+    end
+  end
+end