rom 3.3.3 → 4.0.0.beta1

data/spec/integration/mappers/definition_dsl_spec.rb

@@ -1,206 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe 'Mapper definition DSL' do
-  include_context 'container'
-  include_context 'users and tasks'
-
-  let(:header) { mapper.header }
-
-  before do
-    configuration.relation(:users) do
-      def email_index
-        project(:email)
-      end
-    end
-  end
-
-  describe 'default PORO mapper' do
-    subject(:mapper) { container.mappers.users.entity }
-
-    before do
-      configuration.mappers do
-        define(:users) do
-          model name: 'Test::User'
-
-          register_as :entity
-
-          attribute :name
-          attribute :email
-        end
-      end
-    end
-
-    it 'defines a constant for the model class' do
-      expect(mapper.model).to be(Test::User)
-    end
-
-    it 'defines header with attributes' do
-      expect(header.keys).to eql([:name, :email])
-    end
-  end
-
-  describe 'excluding attributes' do
-    context 'by setting :inherit_header to false' do
-      subject(:mapper) { container.mappers.users.email_index }
-
-      before do
-        configuration.mappers do
-          define(:users) do
-            model name: 'Test::User'
-
-            attribute :name
-            attribute :email
-          end
-
-          define(:email_index, parent: :users, inherit_header: false) do
-            model name: 'Test::UserWithoutName'
-            attribute :email
-          end
-        end
-      end
-
-      it 'only maps provided attributes' do
-        expect(header.keys).to eql([:email])
-      end
-    end
-  end
-
-  describe 'virtual relation mapper' do
-    subject(:mapper) { container.mappers.users.email_index }
-
-    before do
-      configuration.mappers do
-        define(:users) do
-          model name: 'Test::User'
-
-          attribute :name
-          attribute :email
-        end
-
-        define(:email_index, parent: :users) do
-          model name: 'Test::UserWithoutName'
-          exclude :name
-        end
-      end
-    end
-
-    it 'inherits the attributes from the parent by default' do
-      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
-      expect(mapper.model).to be(Test::UserWithoutName)
-    end
-  end
-
-  describe 'wrapped relation mapper' do
-    before do
-      configuration.relation(:tasks) do
-        def with_user
-          join(users)
-        end
-      end
-
-      configuration.mappers do
-        define(:tasks) do
-          model name: 'Test::Task'
-
-          attribute :title
-          attribute :priority
-        end
-      end
-    end
-
-    it 'allows defining wrapped attributes via options hash' do
-      configuration.mappers do
-        define(:with_user, parent: :tasks) do
-          model name: 'Test::TaskWithUser'
-
-          attribute :title
-          attribute :priority
-
-          wrap user: [:email]
-        end
-      end
-
-      container
-
-      Test::TaskWithUser.send(:include, Dry::Equalizer(:title, :priority, :user))
-
-      jane = container.relation(:tasks).with_user.as(:with_user).to_a.last
-
-      expect(jane).to eql(
-        Test::TaskWithUser.new(
-          title: 'be cool',
-          priority: 2,
-          user: { email: 'jane@doe.org' }
-        )
-      )
-    end
-
-    it 'allows defining wrapped attributes via options block' do
-      configuration.mappers do
-        define(:with_user, parent: :tasks) do
-          model name: 'Test::TaskWithUser'
-
-          attribute :title
-          attribute :priority
-
-          wrap :user do
-            attribute :email
-          end
-        end
-      end
-
-      container
-
-      Test::TaskWithUser.send(:include, Dry::Equalizer(:title, :priority, :user))
-
-      jane = container.relation(:tasks).with_user.as(:with_user).to_a.last
-
-      expect(jane).to eql(
-        Test::TaskWithUser.new(
-          title: 'be cool',
-          priority: 2,
-          user: { email: 'jane@doe.org' }
-        )
-      )
-    end
-
-    it 'allows defining wrapped attributes mapped to a model' do
-      configuration.mappers do
-        define(:with_user, parent: :tasks) do
-          model name: 'Test::TaskWithUser'
-
-          attribute :title
-          attribute :priority
-
-          wrap :user do
-            model name: 'Test::User'
-            attribute :email
-          end
-        end
-      end
-
-      container
-
-      Test::TaskWithUser.send(:include, Dry::Equalizer(:title, :priority, :user))
-      Test::User.send(:include, Dry::Equalizer(:email))
-
-      jane = container.relation(:tasks).with_user.as(:with_user).to_a.last
-
-      expect(jane).to eql(
-        Test::TaskWithUser.new(
-          title: 'be cool',
-          priority: 2,
-          user: Test::User.new(email: 'jane@doe.org')
-        )
-      )
-    end
-  end
-end

data/spec/integration/mappers/embedded_spec.rb

@@ -1,62 +0,0 @@
-require 'spec_helper'
-require 'rom/memory'
-
-RSpec.describe 'Mappers / embedded' do
-  include_context 'container'
-
-  before do
-    configuration.relation(:users)
-  end
-
-  it 'allows mapping embedded tuples' do
-    configuration.mappers do
-      define(:users) do
-        model name: 'Test::User'
-
-        attribute :name, from: 'name'
-
-        embedded :tasks, from: 'tasks' do
-          attribute :title, from: 'title'
-        end
-      end
-    end
-
-    container.relations.users << {
-      'name' => 'Jane',
-      'tasks' => [{ 'title' => 'Task One' }, { 'title' => 'Task Two' }]
-    }
-
-    jane = container.relation(:users).map_with(:users).first
-
-    expect(jane.name).to eql('Jane')
-    expect(jane.tasks).to eql([{ title: 'Task One' }, { title: 'Task Two' }])
-  end
-
-  it 'allows mapping embedded tuple' do
-    configuration.mappers do
-      define(:users) do
-        model name: 'Test::User'
-
-        attribute :name, from: 'name'
-
-        embedded :address, from: 'address', type: :hash do
-          model name: 'Test::Address'
-          attribute :street, from: 'street'
-          attribute :city, from: 'city'
-        end
-      end
-    end
-
-    container.relations.users << {
-      'name' => 'Jane',
-      'address' => { 'street' => 'Somewhere 1', 'city' => 'NYC' }
-    }
-
-    jane = container.relation(:users).as(:users).first
-
-    Test::Address.send(:include, Dry::Equalizer(:street, :city))
-
-    expect(jane.name).to eql('Jane')
-    expect(jane.address).to eql(Test::Address.new(street: 'Somewhere 1', city: 'NYC'))
-  end
-end

data/spec/integration/mappers/exclude_spec.rb

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

@@ -1,71 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe 'Mapper definition DSL' do
-  include_context 'container'
-  include_context 'users and tasks'
-
-  let(:header) { mapper.header }
-
-  describe 'folded relation mapper' do
-    before do
-      configuration.relation(:tasks) do
-        def with_users
-          join(users)
-        end
-      end
-
-      configuration.relation(:users) do
-        def with_tasks
-          join(tasks)
-        end
-      end
-    end
-
-    let(:container) { ROM.container(configuration) }
-    let(:actual) do
-      container.relation(:users).with_tasks.map_with(:users).to_a
-    end
-
-    it 'groups all attributes and folds the first key' do
-      configuration.mappers do
-        define(:users) do
-          fold tasks: [:title, :priority]
-        end
-      end
-
-      expect(actual).to eql [
-        { name: 'Joe', email: 'joe@doe.org', tasks: ['be nice', 'sleep well'] },
-        { name: 'Jane', email: 'jane@doe.org', tasks: ['be cool'] }
-      ]
-    end
-
-    it 'is sensitive to the order of keys' do
-      configuration.mappers do
-        define(:users) do
-          fold priorities: [:priority, :title]
-        end
-      end
-
-      expect(actual).to eql [
-        { name: 'Joe', email: 'joe@doe.org', priorities: [1, 2] },
-        { name: 'Jane', email: 'jane@doe.org', priorities: [2] }
-      ]
-    end
-
-    it 'accepts the block syntax' do
-      configuration.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

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

data/spec/integration/mappers/overwrite_attributes_value_spec.rb

@@ -1,51 +0,0 @@
-require 'spec_helper'
-require 'rom/memory'
-
-RSpec.describe 'Mappers / Attributes value' do
-  include_context 'container'
-
-  before do
-    configuration.relation(:users)
-  end
-
-  it 'allows to manipulate attribute value' do
-    class Test::UserMapper < ROM::Mapper
-      relation :users
-
-      attribute :id
-      attribute :name, from: :first_name do
-        'John'
-      end
-      attribute :age do
-        9+9
-      end
-      attribute :weight do |t|
-        t+15
-      end
-    end
-
-    configuration.register_mapper(Test::UserMapper)
-
-    container.relations.users << {
-      id: 123,
-      first_name: 'Jane',
-      weight: 75
-    }
-
-    jane = container.relation(:users).as(:users).first
-
-    expect(jane).to eql(id: 123, name: 'John', weight: 90, age: 18)
-  end
-
-  it 'raise ArgumentError if type and block used at the same time' do
-    expect {
-      class Test::UserMapper < ROM::Mapper
-        relation :users
-
-        attribute :name, type: :string do
-          'John'
-        end
-      end
-    }.to raise_error(ArgumentError, "can't specify type and block at the same time")
-  end
-end

data/spec/integration/mappers/prefix_separator_spec.rb

@@ -1,52 +0,0 @@
-require 'spec_helper'
-require 'rom/memory'
-
-RSpec.describe 'Mapper definition DSL' do
-  include_context 'container'
-
-  before do
-    configuration.relation(:users)
-
-    users = configuration.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) { container.relation(:users).as(:users).to_a }
-
-    it 'applies new separator to the attributes following it' do
-      configuration.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

@@ -1,48 +0,0 @@
-require 'spec_helper'
-require 'rom/memory'
-
-RSpec.describe 'Mapper definition DSL' do
-  include_context 'container'
-
-  before do
-    configuration.relation(:users)
-
-    users = configuration.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) { container.relation(:users).as(:users).to_a }
-
-    it 'applies new prefix to the attributes following it' do
-      configuration.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