rom 0.7.1 → 0.8.0

data/spec/integration/mappers/combine_spec.rb

@@ -17,9 +17,13 @@ describe 'Mapper definition DSL' do
       end
 
       setup.relation(:users) do
-        def addresses(_users_)
+        def addresses(_users)
           [{ city: 'NYC', user: 'Jane' }, { city: 'Boston', user: 'Joe' }]
         end
+
+        def books(_users)
+          [{ title: 'Book One', user: 'Jane' }, { title: 'Book Two', user: 'Joe' }]
+        end
       end
 
       setup.mappers do
@@ -53,6 +57,8 @@ describe 'Mapper definition DSL' do
 
             attribute :city
           end
+
+          combine :book, on: { name: :user }, type: :hash
         end
       end
     end
@@ -70,7 +76,8 @@ describe 'Mapper definition DSL' do
           Test::Task.new(title: 'sleep well', meta: { user: 'Joe', priority: 2 },
                          tags: [])
         ],
-        address: Test::Address.new(city: 'Boston')
+        address: Test::Address.new(city: 'Boston'),
+        book: { title: 'Book Two', user: 'Joe' }
       )
     }
 
@@ -85,20 +92,22 @@ describe 'Mapper definition DSL' do
             tags: [Test::Tag.new(name: 'blue')]
           )
         ],
-        address: Test::Address.new(city: 'NYC')
+        address: Test::Address.new(city: 'NYC'),
+        book: { title: 'Book One', user: 'Jane' }
       )
     }
 
     it 'works' do
       rom
 
-      Test::User.send(:include, Equalizer.new(:name, :email, :tasks, :address))
+      Test::User.send(:include, Equalizer.new(:name, :email, :tasks, :address, :book))
       Test::Task.send(:include, Equalizer.new(:title, :meta))
       Test::Address.send(:include, Equalizer.new(:city))
 
       result = users.combine(
         tasks.for_users.combine(tasks.tags),
-        users.addresses
+        users.addresses,
+        users.books
       ).as(:entity)
 
       expect(result).to match_array([joe, jane])

data/spec/integration/mappers/definition_dsl_spec.rb

@@ -84,7 +84,12 @@ describe 'Mapper definition DSL' do
     end
 
     it 'inherits the attributes from the parent by default' do
-      expect(header.keys).to eql([:email])
+      expect(header.keys).to eql([:name, :email])
+    end
+
+    it 'excludes an inherited attribute when requested' do
+      name = header.attributes[:name]
+      expect(name).to be_kind_of ROM::Header::Exclude
     end
 
     it 'builds a new model' do

data/spec/integration/mappers/exclude_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+require 'rom/memory'
+
+describe 'Mapper definition DSL' do
+  let(:setup) { ROM.setup(:memory) }
+  let(:rom)   { ROM.finalize.env   }
+
+  before do
+    setup.relation(:users)
+
+    users = setup.default.dataset(:users)
+
+    users.insert(name: 'Joe', email: 'joe@doe.com')
+    users.insert(name: 'Jane', email: 'jane@doe.com')
+  end
+
+  describe 'exclude' do
+    let(:mapped_users) { rom.relation(:users).as(:users).to_a }
+
+    it 'removes the attribute' do
+      setup.mappers do
+        define(:users) { exclude :email }
+      end
+
+      expect(mapped_users).to eql [{ name: 'Joe' }, { name: 'Jane' }]
+    end
+  end
+end

data/spec/integration/mappers/fold_spec.rb

@@ -50,5 +50,21 @@ describe 'Mapper definition DSL' do
         { name: 'Jane', email: 'jane@doe.org', priorities: [2] }
       ]
     end
+
+    it 'accepts the block syntax' do
+      setup.mappers do
+        define(:users) do
+          fold :priorities do
+            attribute :priority
+            attribute :title
+          end
+        end
+      end
+
+      expect(actual).to eql [
+        { name: 'Joe', email: 'joe@doe.org', priorities: [1, 2] },
+        { name: 'Jane', email: 'jane@doe.org', priorities: [2] }
+      ]
+    end
   end
 end

data/spec/integration/mappers/group_spec.rb

@@ -158,27 +158,5 @@ describe 'Mapper definition DSL' do
         ])
       )
     end
-
-    it 'allows defining grouped attributes with the same name as their keys' do
-      setup.mappers do
-        define(:with_tasks, parent: :users) do
-
-          attribute :name
-          attribute :email
-
-          group title: [:title, :priority]
-        end
-      end
-
-      rom = setup.finalize
-
-      jane = rom.relation(:users).with_tasks.map_with(:with_tasks).to_a.last
-
-      expect(jane).to eql(
-        name: 'Jane',
-        email: 'jane@doe.org',
-        title: [{ title: 'be cool', priority: 2 }]
-      )
-    end
   end
 end

data/spec/integration/mappers/prefix_separator_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'rom/memory'
+
+describe 'Mapper definition DSL' do
+  let(:setup) { ROM.setup(:memory) }
+  let(:rom)   { ROM.finalize.env   }
+
+  before do
+    setup.relation(:users)
+
+    users = setup.default.dataset(:users)
+    users.insert(
+      user_id: 1,
+      user_name: 'Joe',
+      user_email: 'joe@doe.com',
+      'user.skype' => 'joe',
+      :'user.phone' => '1234567890'
+    )
+  end
+
+  describe 'prefix' do
+    subject(:mapped_users) { rom.relation(:users).as(:users).to_a }
+
+    it 'applies new separator to the attributes following it' do
+      setup.mappers do
+        define(:users) do
+
+          prefix :user
+          attribute :id
+          attribute :name
+          wrap :contacts do
+            attribute :email
+
+            prefix_separator '.'
+            attribute 'skype'
+            attribute :phone
+          end
+        end
+      end
+
+      expect(mapped_users).to eql [
+        {
+          id: 1,
+          name: 'Joe',
+          contacts: {
+            email: 'joe@doe.com',
+            'skype' => 'joe',
+            phone: '1234567890'
+          }
+        }
+      ]
+    end
+  end
+end

data/spec/integration/mappers/prefix_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+require 'rom/memory'
+
+describe 'Mapper definition DSL' do
+  let(:setup) { ROM.setup(:memory) }
+  let(:rom)   { ROM.finalize.env   }
+
+  before do
+    setup.relation(:users)
+
+    users = setup.default.dataset(:users)
+    users.insert(
+      user_id: 1,
+      user_name: 'Joe',
+      user_email: 'joe@doe.com',
+      contact_skype: 'joe',
+      contact_phone: '1234567890'
+    )
+  end
+
+  describe 'prefix' do
+    subject(:mapped_users) { rom.relation(:users).as(:users).to_a }
+
+    it 'applies new prefix to the attributes following it' do
+      setup.mappers do
+        define(:users) do
+
+          prefix :user
+          attribute :id
+          attribute :name
+          wrap :contacts do
+            attribute :email
+
+            prefix :contact
+            attribute :skype
+            attribute :phone
+          end
+        end
+      end
+
+      expect(mapped_users).to eql [
+        {
+          id: 1,
+          name: 'Joe',
+          contacts: { email: 'joe@doe.com', skype: 'joe', phone: '1234567890' }
+        }
+      ]
+    end
+  end
+end

data/spec/integration/mappers/reusing_mappers_spec.rb

@@ -19,4 +19,25 @@ describe 'Reusing mappers' do
       { name: 'Jane', tasks: [{ title: 'One' }, { title: 'Two' }] }
     ])
   end
+
+  it 'allows using another mapper in an embbedded hash' do
+    class Test::PriorityMapper < ROM::Mapper
+      attribute :value, type: :integer
+      attribute :desc
+    end
+
+    class Test::TaskMapper < ROM::Mapper
+      attribute :title
+      embedded :priority, type: :hash, mapper: Test::PriorityMapper
+    end
+
+    mapper = Test::TaskMapper.build
+    relation = [{ title: 'Task One', priority: { value: '1' } }, { title: 'Task Two', priority: { value: '2' } }]
+    result = mapper.call(relation)
+
+    expect(result).to eql([
+      { title: 'Task One', priority: { value: 1 } },
+      { title: 'Task Two', priority: { value: 2 } }
+    ])
+  end
 end

data/spec/integration/mappers/step_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+describe 'Mapper definition DSL' do
+  let(:setup) { ROM.setup(:memory) }
+  let(:rom)   { ROM.finalize.env   }
+
+  before do
+    setup.relation(:lists)
+
+    setup.default.dataset(:lists).insert(
+      list_id: 1,
+      list_tasks: [
+        { user: 'Jacob', task_id: 1, task_title: 'be nice'    },
+        { user: 'Jacob', task_id: 2, task_title: 'sleep well' }
+      ]
+    )
+  end
+
+  describe 'step' do
+    let(:mapped) { rom.relation(:lists).as(:lists).to_a }
+
+    it 'applies transformations one by one' do
+      setup.mappers do
+        define(:lists) do
+          step do
+            prefix 'list'
+            attribute :id
+            unfold :tasks
+          end
+
+          step do
+            unwrap :tasks do
+              attribute :task_id
+              attribute :name, from: :user
+              attribute :task_title
+            end
+          end
+
+          step do
+            group :tasks do
+              prefix 'task'
+              attribute :id
+              attribute :title
+            end
+          end
+
+          step do
+            wrap :user do
+              attribute :name
+              attribute :tasks
+            end
+          end
+        end
+      end
+
+      expect(mapped).to eql [
+        {
+          id: 1,
+          user: {
+            name: 'Jacob',
+            tasks: [
+              { id: 1, title: 'be nice'    },
+              { id: 2, title: 'sleep well' }
+            ]
+          }
+        }
+      ]
+    end
+
+    it 'applies settings from root' do
+      setup.mappers do
+        define(:lists) do
+
+          prefix 'list'
+
+          step do
+            attribute :id
+            attribute :tasks
+          end
+        end
+      end
+
+      expect(mapped).to eql [
+        {
+          id: 1,
+          tasks: [
+            { user: 'Jacob', task_id: 1, task_title: 'be nice'    },
+            { user: 'Jacob', task_id: 2, task_title: 'sleep well' }
+          ]
+        }
+      ]
+    end
+
+    it 'cannot precede attributes' do
+      setup.mappers do
+        define(:lists) do
+          step do
+            unfold :tasks, from: :list_tasks
+          end
+          attribute :id, from: :list_id
+        end
+      end
+
+      expect { rom }.to raise_error ROM::MapperMisconfiguredError
+    end
+
+    it 'cannot succeed attributes' do
+      setup.mappers do
+        define(:lists) do
+          attribute :id, from: :list_id
+          step do
+            unfold :tasks, from: :list_tasks
+          end
+        end
+      end
+
+      expect { rom }.to raise_error ROM::MapperMisconfiguredError
+    end
+  end
+end

data/spec/integration/mappers/unfold_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+require 'rom/memory'
+
+describe 'Mapper definition DSL' do
+  let(:setup) { ROM.setup(:memory) }
+  let(:rom)   { ROM.finalize.env   }
+
+  before do
+    setup.relation(:users)
+
+    users = setup.default.dataset(:users)
+
+    users.insert(name: 'Joe',  roles: ['admin', 'user', 'user', nil])
+    users.insert(name: 'Jane', roles: 'user')
+    users.insert(name: 'John')
+  end
+
+  describe 'unfold' do
+    let(:mapped_users) { rom.relation(:users).as(:users).to_a }
+
+    it 'splits the attribute' do
+      setup.mappers do
+        define(:users) { unfold :roles }
+      end
+
+      expect(mapped_users).to eql [
+        { name: 'Joe',  roles: 'admin' },
+        { name: 'Joe',  roles: 'user'  },
+        { name: 'Joe',  roles: 'user'  },
+        { name: 'Joe',  roles: nil     },
+        { name: 'Jane', roles: 'user'  },
+        { name: 'John'                 }
+      ]
+    end
+
+    it 'renames unfolded attribute when necessary' do
+      setup.mappers do
+        define(:users) { unfold :role, from: :roles }
+      end
+
+      expect(mapped_users).to eql [
+        { name: 'Joe',  role: 'admin' },
+        { name: 'Joe',  role: 'user'  },
+        { name: 'Joe',  role: 'user'  },
+        { name: 'Joe',  role: nil     },
+        { name: 'Jane', role: 'user'  },
+        { name: 'John'                }
+      ]
+    end
+
+    it 'rewrites the existing attribute' do
+      setup.mappers do
+        define(:users) { unfold :name, from: :roles }
+      end
+
+      expect(mapped_users).to eql [
+        { name: 'admin' },
+        { name: 'user'  },
+        { name: 'user'  },
+        { name: nil     },
+        { name: 'user'  },
+        {}
+      ]
+    end
+
+    it 'ignores the absent attribute' do
+      setup.mappers do
+        define(:users) { unfold :foo, from: :absent }
+      end
+
+      expect(mapped_users).to eql [
+        { name: 'Joe',  roles: ['admin', 'user', 'user', nil] },
+        { name: 'Jane', roles: 'user' },
+        { name: 'John' }
+      ]
+    end
+
+    it 'accepts block' do
+      setup.mappers do
+        define(:users) { unfold(:role, from: :roles) {} }
+      end
+
+      expect(mapped_users).to eql [
+        { name: 'Joe',  role: 'admin' },
+        { name: 'Joe',  role: 'user'  },
+        { name: 'Joe',  role: 'user'  },
+        { name: 'Joe',  role: nil     },
+        { name: 'Jane', role: 'user'  },
+        { name: 'John'                }
+      ]
+    end
+  end
+end