rom 0.4.2 → 0.5.0

data/spec/integration/mappers/embedded_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe 'Mappers / embedded' do
+  let(:setup) { ROM.setup('memory://test') }
+  let(:rom) { setup.finalize }
+
+  it 'allows mapping embedded tuples' do
+    setup.schema do
+      base_relation(:users) do
+        repository :default
+        attribute 'name'
+        attribute 'tasks'
+      end
+    end
+
+    setup.relation(:users)
+
+    setup.mappers do
+      define(:users) do
+        model name: 'User'
+
+        attribute :name, from: 'name'
+
+        embedded :tasks, from: 'tasks' do
+          attribute :title, from: 'title'
+        end
+      end
+    end
+
+    rom.schema.users << {
+      'name' => 'Jane',
+      'tasks' => [{ 'title' => 'Task One' }, { 'title' => 'Task Two' }]
+    }
+
+    jane = rom.read(:users).to_a.first
+
+    expect(rom.read(:users).mapper.header.map(&:name)).to eql([:name, :tasks])
+
+    expect(jane.name).to eql('Jane')
+    expect(jane.tasks).to eql([{ title: 'Task One' }, { title: 'Task Two' }])
+  end
+
+  it 'allows mapping embedded tuple' do
+    setup.schema do
+      base_relation(:users) do
+        repository :default
+        attribute 'name'
+        attribute 'address'
+      end
+    end
+
+    setup.relation(:users)
+
+    setup.mappers do
+      define(:users) do
+        model name: 'User'
+
+        attribute :name, from: 'name'
+
+        embedded :address, from: 'address', type: :hash do
+          model name: 'Address'
+          attribute :street, from: 'street'
+          attribute :city, from: 'city'
+        end
+      end
+    end
+
+    rom.schema.users << {
+      'name' => 'Jane',
+      'address' => { 'street' => 'Somewhere 1', 'city' => 'NYC' }
+    }
+
+    jane = rom.read(:users).to_a.first
+
+    expect(rom.read(:users).mapper.header.map(&:name)).to eql([:name, :address])
+
+    Address.send(:include, Equalizer.new(:street, :city))
+
+    expect(jane.name).to eql('Jane')
+    expect(jane.address).to eql(Address.new(street: 'Somewhere 1', city: 'NYC'))
+  end
+end

data/spec/integration/mappers/group_spec.rb

@@ -0,0 +1,170 @@
+require 'spec_helper'
+
+describe 'Mapper definition DSL' do
+  include_context 'users and tasks'
+
+  let(:header) { mapper.header }
+
+  before do
+    setup.relation(:users) do
+      def email_index
+        project(:email)
+      end
+    end
+  end
+
+  describe 'grouped relation mapper' do
+    before do
+      setup.relation(:tasks) do
+        def with_users
+          join(users)
+        end
+      end
+
+      setup.relation(:users) do
+        def with_tasks
+          join(tasks)
+        end
+      end
+
+      setup.mappers do
+        define(:users) do
+          model name: 'User'
+
+          attribute :name
+          attribute :email
+        end
+      end
+    end
+
+    it 'allows defining grouped attributes via options hash' do
+      setup.mappers do
+        define(:with_tasks, parent: :users) do
+          model name: 'UserWithTasks'
+
+          attribute :name
+          attribute :email
+
+          group tasks: [:title, :priority]
+        end
+      end
+
+      rom = setup.finalize
+
+      UserWithTasks.send(:include, Equalizer.new(:name, :email, :tasks))
+
+      jane = rom.read(:users).with_tasks.to_a.last
+
+      expect(jane).to eql(
+        UserWithTasks.new(
+          name: 'Jane',
+          email: 'jane@doe.org',
+          tasks: [{ title: 'be cool', priority: 2 }]
+        )
+      )
+    end
+
+    it 'allows defining grouped attributes via block' do
+      setup.mappers do
+        define(:with_tasks, parent: :users) do
+          model name: 'UserWithTasks'
+
+          attribute :name
+          attribute :email
+
+          group :tasks do
+            attribute :title
+            attribute :priority
+          end
+        end
+      end
+
+      rom = setup.finalize
+
+      UserWithTasks.send(:include, Equalizer.new(:name, :email, :tasks))
+
+      jane = rom.read(:users).with_tasks.to_a.last
+
+      expect(jane).to eql(
+        UserWithTasks.new(
+          name: 'Jane',
+          email: 'jane@doe.org',
+          tasks: [{ title: 'be cool', priority: 2 }]
+        )
+      )
+    end
+
+    it 'allows defining grouped attributes mapped to a model via block' do
+      setup.mappers do
+        define(:with_tasks, parent: :users) do
+          model name: 'UserWithTasks'
+
+          attribute :name
+          attribute :email
+
+          group :tasks do
+            model name: 'Task'
+
+            attribute :title
+            attribute :priority
+          end
+        end
+      end
+
+      rom = setup.finalize
+
+      UserWithTasks.send(:include, Equalizer.new(:name, :email, :tasks))
+      Task.send(:include, Equalizer.new(:title, :priority))
+
+      jane = rom.read(:users).with_tasks.to_a.last
+
+      expect(jane).to eql(
+        UserWithTasks.new(
+          name: 'Jane',
+          email: 'jane@doe.org',
+          tasks: [Task.new(title: 'be cool', priority: 2)]
+        )
+      )
+    end
+
+    it 'allows defining nested grouped attributes mapped to a model via block' do
+      setup.mappers do
+        define(:tasks)
+
+        define(:with_users, parent: :tasks, inherit_header: false) do
+          model name: 'TaskWithUsers'
+
+          attribute :title
+          attribute :priority
+
+          group :users do
+            model name: 'TaskUser'
+
+            attribute :name
+
+            group :contacts do
+              model name: 'Contact'
+              attribute :email
+            end
+          end
+        end
+      end
+
+      rom = setup.finalize
+
+      TaskWithUsers.send(:include, Equalizer.new(:title, :priority, :users))
+      TaskUser.send(:include, Equalizer.new(:name, :contacts))
+      Contact.send(:include, Equalizer.new(:email))
+
+      task = rom.read(:tasks).with_users.to_a.first
+
+      expect(task).to eql(
+        TaskWithUsers.new(title: 'be nice', priority: 1, users: [
+          TaskUser.new(name: 'Joe', contacts: [
+            Contact.new(email: 'joe@doe.org')
+          ])
+        ])
+      )
+    end
+  end
+end

data/spec/integration/mappers/prefixing_attributes_spec.rb

@@ -32,11 +32,11 @@ describe 'Mappers / Prefixing attributes' do
 
     User.send(:include, Equalizer.new(:id, :name, :email))
 
-    rom.schema.users << { user_id: 123, user_name: 'Jane', user_email: 'jane@doe.org' }
+    rom.schema.users << { user_id: 123, user_name: 'Jane',
+                          user_email: 'jane@doe.org' }
 
     jane = rom.read(:users).to_a.first
 
     expect(jane).to eql(User.new(id: 123, name: 'Jane', email: 'jane@doe.org'))
   end
-
 end

data/spec/integration/mappers/renaming_attributes_spec.rb

@@ -23,8 +23,6 @@ describe 'Mappers / Renaming attributes' do
     setup.relation(:addresses)
 
     setup.relation(:users) do
-      include ROM::RA
-
       def with_address
         join(addresses)
       end
@@ -83,12 +81,14 @@ describe 'Mappers / Renaming attributes' do
     UserWithAddress.send(:include, Equalizer.new(:id, :name, :address))
 
     rom.schema.users << { _id: 123, user_name: 'Jane' }
-    rom.schema.addresses << { _id: 123, address_id: 321, address_street: 'Street 1' }
+    rom.schema.addresses << { _id: 123, address_id: 321,
+                              address_street: 'Street 1' }
 
     jane = rom.read(:users).with_address.first
 
     expect(jane).to eql(
-      UserWithAddress.new(id: 123, name: 'Jane', address: { id: 321, street: 'Street 1' })
+      UserWithAddress.new(id: 123, name: 'Jane',
+                          address: { id: 321, street: 'Street 1' })
     )
   end
 
@@ -119,8 +119,10 @@ describe 'Mappers / Renaming attributes' do
     UserWithAddresses.send(:include, Equalizer.new(:id, :name, :addresses))
 
     rom.schema.users << { _id: 123, user_name: 'Jane' }
-    rom.schema.addresses << { _id: 123, address_id: 321, address_street: 'Street 1' }
-    rom.schema.addresses << { _id: 123, address_id: 654, address_street: 'Street 2' }
+    rom.schema.addresses << { _id: 123, address_id: 321,
+                              address_street: 'Street 1' }
+    rom.schema.addresses << { _id: 123, address_id: 654,
+                              address_street: 'Street 2' }
 
     jane = rom.read(:users).with_addresses.first
 

data/spec/integration/mappers/symbolizing_attributes_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe 'Mappers / Symbolizing atributes' do
+  let(:setup) { ROM.setup(memory: 'memory://test') }
+  let(:rom) { setup.finalize }
+
+  before do
+    setup.schema do
+      base_relation(:users) do
+        repository :memory
+
+        attribute 'user_id'
+        attribute 'first_name'
+        attribute 'email'
+      end
+
+      base_relation(:tasks) do
+        repository :memory
+
+        attribute 'title'
+        attribute 'task_priority'
+        attribute 'task_description'
+      end
+    end
+  end
+
+  it 'automatically maps all attributes using top-level settings' do
+    setup.mappers do
+      define(:users, symbolize_keys: true, inherit_header: false, prefix: 'user') do
+        attribute :id
+
+        wrap :details, prefix: 'first' do
+          attribute :name
+        end
+
+        wrap :contact, prefix: false do
+          attribute :email
+        end
+      end
+    end
+
+    rom.schema.users << {
+      'user_id' => 123,
+      'first_name' => 'Jane',
+      'email' => 'jane@doe.org'
+    }
+
+    jane = rom.read(:users).first
+
+    expect(jane).to eql(
+      id: 123, details: { name: 'Jane' }, contact: { email: 'jane@doe.org' }
+    )
+  end
+
+  it 'automatically maps all attributes using settings for wrap block' do
+    setup.mappers do
+      define(:tasks, symbolize_keys: true) do
+        attribute :title
+
+        wrap :details, prefix: 'task' do
+          attribute :priority
+          attribute :description
+        end
+      end
+    end
+
+    rom.schema.tasks << {
+      'title' => 'Task One',
+      'task_priority' => 1,
+      'task_description' => 'It is a task'
+    }
+
+    task = rom.read(:tasks).first
+
+    expect(task).to eql(
+      title: 'Task One',
+      details: { priority: 1, description: 'It is a task' }
+    )
+  end
+end

data/spec/integration/mappers/wrap_spec.rb

@@ -0,0 +1,162 @@
+require 'spec_helper'
+
+describe 'Mapper definition DSL' do
+  include_context 'users and tasks'
+
+  let(:header) { mapper.header }
+
+  before do
+    setup.relation(:users) do
+      def email_index
+        project(:email)
+      end
+    end
+  end
+
+  describe 'wrapped relation mapper' do
+    before do
+      setup.relation(:tasks) do
+        def with_user
+          join(users)
+        end
+      end
+
+      setup.relation(:users)
+
+      setup.mappers do
+        define(:tasks) do
+          model name: 'Task'
+
+          attribute :title
+          attribute :priority
+        end
+      end
+    end
+
+    it 'allows defining wrapped attributes via options hash' do
+      setup.mappers do
+        define(:with_user, parent: :tasks) do
+          model name: 'TaskWithUser'
+
+          attribute :title
+          attribute :priority
+
+          wrap user: [:email]
+        end
+      end
+
+      rom = setup.finalize
+
+      TaskWithUser.send(:include, Equalizer.new(:title, :priority, :user))
+
+      jane = rom.read(:tasks).with_user.to_a.last
+
+      expect(jane).to eql(
+        TaskWithUser.new(
+          title: 'be cool',
+          priority: 2,
+          user: { email: 'jane@doe.org' }
+        )
+      )
+    end
+
+    it 'allows defining wrapped attributes via options block' do
+      setup.mappers do
+        define(:with_user, parent: :tasks) do
+          model name: 'TaskWithUser'
+
+          attribute :title
+          attribute :priority
+
+          wrap :user do
+            attribute :email
+          end
+        end
+      end
+
+      rom = setup.finalize
+
+      TaskWithUser.send(:include, Equalizer.new(:title, :priority, :user))
+
+      jane = rom.read(:tasks).with_user.to_a.last
+
+      expect(jane).to eql(
+        TaskWithUser.new(
+          title: 'be cool',
+          priority: 2,
+          user: { email: 'jane@doe.org' }
+        )
+      )
+    end
+
+    it 'allows defining nested wrapped attributes via a block' do
+      setup.mappers do
+        define(:with_user, parent: :tasks, inherit_header: false) do
+          model name: 'TaskWithUser'
+
+          attribute :title
+          attribute :priority
+
+          wrap :user do
+            model name: 'TaskUser'
+            attribute :name
+
+            wrap :contact do
+              model name: 'Contact'
+              attribute :email
+            end
+          end
+        end
+      end
+
+      rom = setup.finalize
+
+      TaskWithUser.send(:include, Equalizer.new(:title, :priority, :user))
+      TaskUser.send(:include, Equalizer.new(:name, :contact))
+      Contact.send(:include, Equalizer.new(:email))
+
+      jane = rom.read(:tasks).with_user.to_a.last
+
+      expect(jane).to eql(
+        TaskWithUser.new(
+          title: 'be cool',
+          priority: 2,
+          user: TaskUser.new(
+            name: 'Jane', contact: Contact.new(email: 'jane@doe.org')
+          )
+        )
+      )
+    end
+
+    it 'allows defining wrapped attributes mapped to a model' do
+      setup.mappers do
+        define(:with_user, parent: :tasks) do
+          model name: 'TaskWithUser'
+
+          attribute :title
+          attribute :priority
+
+          wrap :user do
+            model name: 'User'
+            attribute :email
+          end
+        end
+      end
+
+      rom = setup.finalize
+
+      TaskWithUser.send(:include, Equalizer.new(:title, :priority, :user))
+      User.send(:include, Equalizer.new(:email))
+
+      jane = rom.read(:tasks).with_user.to_a.last
+
+      expect(jane).to eql(
+        TaskWithUser.new(
+          title: 'be cool',
+          priority: 2,
+          user: User.new(email: 'jane@doe.org')
+        )
+      )
+    end
+  end
+end