rom 2.0.2 → 4.2.1

data/spec/integration/mappers/prefixing_attributes_spec.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-require 'rom/memory'
-
-describe 'Mappers / Prefixing attributes' do
-  include_context 'container'
-
-  before do
-    configuration.relation(:users)
-  end
-
-  it 'automatically maps all attributes using the provided prefix' do
-    class Test::UserMapper < ROM::Mapper
-      relation :users
-      prefix :user
-
-      model name: 'Test::User'
-
-      attribute :id
-      attribute :name
-      attribute :email
-    end
-
-    configuration.register_mapper(Test::UserMapper)
-
-    container.relations.users << {
-      user_id: 123,
-      user_name: 'Jane',
-      user_email: 'jane@doe.org'
-    }
-
-    Test::User.send(:include, Dry::Equalizer(:id, :name, :email))
-
-    jane = container.relation(:users).as(:users).first
-
-    expect(jane).to eql(Test::User.new(id: 123, name: 'Jane', email: 'jane@doe.org'))
-  end
-end

data/spec/integration/mappers/registering_custom_mappers_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-describe 'Registering Custom Mappers' do
-  include_context 'container'
-  include_context 'users and tasks'
-
-  it 'allows registering arbitrary objects as mappers' do
-    model = Struct.new(:name, :email)
-
-    mapper = -> users {
-      users.map { |tuple| model.new(*tuple.values_at(:name, :email)) }
-    }
-
-    configuration.relation(:users) do
-      def by_name(name)
-        restrict(name: name)
-      end
-    end
-
-    configuration.mappers do
-      register(:users, entity: mapper)
-    end
-
-    users = container.relation(:users).by_name('Jane').as(:entity)
-
-    expect(users).to match_array([model.new('Jane', 'jane@doe.org')])
-  end
-end

data/spec/integration/mappers/renaming_attributes_spec.rb

@@ -1,125 +0,0 @@
-require 'spec_helper'
-require 'rom/memory'
-
-describe 'Mappers / Renaming attributes' do
-  include_context 'container'
-
-  before do
-    configuration.relation(:addresses)
-
-    configuration.relation(:users) do
-      def with_address
-        join(addresses)
-      end
-
-      def with_addresses
-        join(addresses)
-      end
-    end
-  end
-
-  it 'maps renamed attributes for a base relation' do
-    configuration.mappers do
-      define(:users) do
-        model name: 'Test::User'
-
-        attribute :id, from: :_id
-        attribute :name, from: :user_name
-      end
-    end
-
-    container
-
-    Test::User.send(:include, Dry::Equalizer(:id, :name))
-
-    container.relations.users << { _id: 123, user_name: 'Jane' }
-
-    jane = container.relation(:users).as(:users).first
-
-    expect(jane).to eql(Test::User.new(id: 123, name: 'Jane'))
-  end
-
-  it 'maps renamed attributes for a wrapped relation' do
-    configuration.mappers do
-      define(:users) do
-        model name: 'Test::User'
-
-        attribute :id, from: :_id
-        attribute :name, from: :user_name
-      end
-
-      define(:with_address, parent: :users) do
-        model name: 'Test::UserWithAddress'
-
-        attribute :id, from: :_id
-        attribute :name, from: :user_name
-
-        wrap :address do
-          attribute :id, from: :address_id
-          attribute :street, from: :address_street
-        end
-      end
-    end
-
-    container
-
-    Test::UserWithAddress.send(:include, Dry::Equalizer(:id, :name, :address))
-
-    container.relations.users << { _id: 123, user_name: 'Jane' }
-
-    container.relations.addresses <<
-      { _id: 123, address_id: 321, address_street: 'Street 1' }
-
-    jane = container.relation(:users).with_address.as(:with_address).first
-
-    expect(jane).to eql(
-      Test::UserWithAddress.new(id: 123, name: 'Jane',
-                                address: { id: 321, street: 'Street 1' })
-    )
-  end
-
-  it 'maps renamed attributes for a grouped relation' do
-    configuration.mappers do
-      define(:users) do
-        model name: 'Test::User'
-
-        attribute :id, from: :_id
-        attribute :name, from: :user_name
-      end
-
-      define(:with_addresses, parent: :users) do
-        model name: 'Test::UserWithAddresses'
-
-        attribute :id, from: :_id
-        attribute :name, from: :user_name
-
-        group :addresses do
-          attribute :id, from: :address_id
-          attribute :street, from: :address_street
-        end
-      end
-    end
-
-    container
-
-    Test::UserWithAddresses.send(:include, Dry::Equalizer(:id, :name, :addresses))
-
-    container.relations.users << { _id: 123, user_name: 'Jane' }
-
-    container.relations.addresses <<
-      { _id: 123, address_id: 321, address_street: 'Street 1' }
-    container.relations.addresses <<
-      { _id: 123, address_id: 654, address_street: 'Street 2' }
-
-    jane = container.relation(:users).with_addresses.as(:with_addresses).first
-
-    expect(jane).to eql(
-      Test::UserWithAddresses.new(
-        id: 123,
-        name: 'Jane',
-        addresses: [{ id: 321, street: 'Street 1' },
-                    { id: 654, street: 'Street 2' }]
-      )
-    )
-  end
-end

data/spec/integration/mappers/reusing_mappers_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-
-describe 'Reusing mappers' do
-  it 'allows using another mapper in mapping definitions' do
-    class Test::TaskMapper < ROM::Mapper
-      attribute :title
-    end
-
-    class Test::UserMapper < ROM::Mapper
-      attribute :name
-      group :tasks, mapper: Test::TaskMapper
-    end
-
-    mapper = Test::UserMapper.build
-    relation = [{ name: 'Jane', title: 'One' }, { name: 'Jane', title: 'Two' }]
-    result = mapper.call(relation)
-
-    expect(result).to eql([
-      { 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

@@ -1,119 +0,0 @@
-require 'spec_helper'
-
-describe 'Mapper definition DSL' do
-  include_context 'container'
-  include_context 'users and tasks'
-
-  before do
-    configuration.relation(:lists)
-
-    configuration.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) { container.relation(:lists).as(:lists).to_a }
-
-    it 'applies transformations one by one' do
-      configuration.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
-      configuration.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
-      configuration.mappers do
-        define(:lists) do
-          step do
-            unfold :tasks, from: :list_tasks
-          end
-          attribute :id, from: :list_id
-        end
-      end
-
-      expect { container }.to raise_error ROM::MapperMisconfiguredError
-    end
-
-    it 'cannot succeed attributes' do
-      configuration.mappers do
-        define(:lists) do
-          attribute :id, from: :list_id
-          step do
-            unfold :tasks, from: :list_tasks
-          end
-        end
-      end
-
-      expect { container }.to raise_error ROM::MapperMisconfiguredError
-    end
-  end
-end

data/spec/integration/mappers/symbolizing_attributes_spec.rb

@@ -1,77 +0,0 @@
-require 'spec_helper'
-require 'rom/memory'
-
-describe 'Mappers / Symbolizing atributes' do
-  include_context 'container'
-
-  before do
-    configuration.relation(:users)
-    configuration.relation(:tasks)
-  end
-
-  it 'automatically maps all attributes using top-level settings' do
-    module Test
-      class UserMapper < ROM::Mapper
-        relation :users
-
-        symbolize_keys true
-        prefix 'user'
-
-        attribute :id
-
-        wrap :details, prefix: 'first' do
-          attribute :name
-        end
-
-        wrap :contact, prefix: false do
-          attribute :email
-        end
-      end
-    end
-
-    configuration.register_mapper(Test::UserMapper)
-
-    container.relations.users << {
-      'user_id' => 123,
-      'first_name' => 'Jane',
-      'email' => 'jane@doe.org'
-    }
-
-    jane = container.relation(:users).as(: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
-    module Test
-      class TaskMapper < ROM::Mapper
-        relation :tasks
-        symbolize_keys true
-
-        attribute :title
-
-        wrap :details, prefix: 'task' do
-          attribute :priority
-          attribute :description
-        end
-      end
-    end
-
-    configuration.register_mapper(Test::TaskMapper)
-
-    container.relations.tasks << {
-      'title' => 'Task One',
-      'task_priority' => 1,
-      'task_description' => 'It is a task'
-    }
-
-    task = container.relation(:tasks).as(:tasks).first
-
-    expect(task).to eql(
-      title: 'Task One',
-      details: { priority: 1, description: 'It is a task' }
-    )
-  end
-end

data/spec/integration/mappers/unfold_spec.rb

@@ -1,92 +0,0 @@
-require 'spec_helper'
-require 'rom/memory'
-
-describe 'Mapper definition DSL' do
-  include_context 'container'
-
-  before do
-    configuration.relation(:users)
-
-    users = configuration.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) { container.relation(:users).as(:users).to_a }
-
-    it 'splits the attribute' do
-      configuration.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
-      configuration.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
-      configuration.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
-      configuration.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
-      configuration.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

data/spec/integration/mappers/ungroup_spec.rb

@@ -1,126 +0,0 @@
-require 'spec_helper'
-require 'rom/memory'
-
-describe 'Mapper definition DSL' do
-  include_context 'container'
-
-  before do
-    configuration.relation(:users)
-
-    users = configuration.default.dataset(:users)
-    users.insert(name: 'Joe', emails: [
-      { address: 'joe@home.org', type: 'home' },
-      { address: 'joe@job.com',  type: 'job'  },
-      { address: 'joe@doe.com',  type: 'job'  },
-      { address: 'joe@thor.org'               },
-      { type: 'home' },
-      {}
-    ])
-    users.insert(name: 'Jane')
-  end
-
-  describe 'ungroup' do
-    subject(:mapped_users) { container.relation(:users).as(:users).to_a }
-
-    it 'partially ungroups attributes' do
-      configuration.mappers do
-        define(:users) { ungroup emails: [:type] }
-      end
-
-      expect(mapped_users).to eql [
-        {
-          name: 'Joe', type: 'home',
-          emails: [{ address: 'joe@home.org' }, { address: nil }]
-        },
-        {
-          name: 'Joe', type: 'job',
-          emails: [{ address: 'joe@job.com' }, { address: 'joe@doe.com' }]
-        },
-        {
-          name: 'Joe', type: nil,
-          emails: [{ address: 'joe@thor.org' }, { address: nil }]
-        },
-        { name: 'Jane' }
-      ]
-    end
-
-    it 'removes group when all attributes extracted' do
-      configuration.mappers do
-        define(:users) { ungroup emails: [:address, :type, :foo] }
-      end
-
-      expect(mapped_users).to eql [
-        { name: 'Joe',  address: 'joe@home.org', type: 'home' },
-        { name: 'Joe',  address: 'joe@job.com',  type: 'job'  },
-        { name: 'Joe',  address: 'joe@doe.com',  type: 'job'  },
-        { name: 'Joe',  address: 'joe@thor.org', type: nil    },
-        { name: 'Joe',  address: nil,            type: 'home' },
-        { name: 'Joe',  address: nil,            type: nil    },
-        { name: 'Jane'                                        }
-      ]
-    end
-
-    it 'accepts block syntax' do
-      configuration.mappers do
-        define(:users) do
-          ungroup :emails do
-            attribute :address
-            attribute :type
-          end
-        end
-      end
-
-      expect(mapped_users).to eql [
-        { name: 'Joe',  address: 'joe@home.org', type: 'home' },
-        { name: 'Joe',  address: 'joe@job.com',  type: 'job'  },
-        { name: 'Joe',  address: 'joe@doe.com',  type: 'job'  },
-        { name: 'Joe',  address: 'joe@thor.org', type: nil    },
-        { name: 'Joe',  address: nil,            type: 'home' },
-        { name: 'Joe',  address: nil,            type: nil    },
-        { name: 'Jane'                                        }
-      ]
-    end
-
-    it 'renames ungrouped attributes' do
-      configuration.mappers do
-        define(:users) do
-          ungroup :emails do
-            attribute :email, from: :address
-            attribute :type
-          end
-        end
-      end
-
-      expect(mapped_users).to eql [
-        { name: 'Joe',  email: 'joe@home.org', type: 'home' },
-        { name: 'Joe',  email: 'joe@job.com',  type: 'job'  },
-        { name: 'Joe',  email: 'joe@doe.com',  type: 'job'  },
-        { name: 'Joe',  email: 'joe@thor.org', type: nil    },
-        { name: 'Joe',  email: nil,            type: 'home' },
-        { name: 'Joe',  email: nil,            type: nil    },
-        { name: 'Jane'                                      }
-      ]
-    end
-
-    it 'skips existing attributes' do
-      configuration.mappers do
-        define(:users) do
-          ungroup :emails do
-            attribute :name, from: :address
-            attribute :type
-          end
-        end
-      end
-
-      expect(mapped_users).to eql [
-        { name: 'Joe',  type: 'home' },
-        { name: 'Joe',  type: 'job'  },
-        { name: 'Joe',  type: 'job'  },
-        { name: 'Joe',  type: nil    },
-        { name: 'Joe',  type: 'home' },
-        { name: 'Joe',  type: nil    },
-        { name: 'Jane'               }
-      ]
-    end
-  end
-end