rom 0.9.1 → 1.0.0.beta1

data/spec/integration/multi_env_spec.rb

@@ -1,27 +1,21 @@
 require 'spec_helper'
+require 'rom/memory'
 
 describe 'Setting up ROM with multiple environments' do
-  let(:environment) do
+  let(:configuration) do
     {
-      one: ROM::Environment.new,
-      two: ROM::Environment.new
-    }
-  end
-  let(:setup) do
-    {
-      one: environment[:one].setup(:memory),
-      two: environment[:two].setup(:memory)
+      one: ROM::Configuration.new(:memory),
+      two: ROM::Configuration.new(:memory)
     }
   end
+
   let(:container) do
     {
-      one: setup[:one].finalize,
-      two: setup[:two].finalize
+      one: ROM.container(configuration[:one]),
+      two: ROM.container(configuration[:two]),
     }
   end
 
-  before { setup }
-
   context 'without :auto_registration plugin' do
     before do
       module Test
@@ -43,9 +37,9 @@ describe 'Setting up ROM with multiple environments' do
     end
 
     it 'registers items independently of other environments' do
-      environment[:one].register_relation(Test::Users)
-      environment[:one].register_command(Test::CreateUser)
-      environment[:one].register_mapper(Test::UserMapper)
+      configuration[:one].register_relation(Test::Users)
+      configuration[:one].register_command(Test::CreateUser)
+      configuration[:one].register_mapper(Test::UserMapper)
 
       expect(container[:one].relations[:users]).to be_kind_of Test::Users
       expect(container[:one].commands[:users].create).to be_kind_of Test::CreateUser
@@ -63,115 +57,13 @@ describe 'Setting up ROM with multiple environments' do
     end
 
     it 'allows use of the same identifiers in different environments' do
-      environment[:one].register_relation(Test::Users)
-      environment[:one].register_command(Test::CreateUser)
-      environment[:one].register_mapper(Test::UserMapper)
-
-      expect { environment[:two].register_relation(Test::Users) }.to_not raise_error
-      expect { environment[:two].register_command(Test::CreateUser) }.to_not raise_error
-      expect { environment[:two].register_mapper(Test::UserMapper) }.to_not raise_error
-    end
-  end
-
-  context 'with :auto_registration plugin' do
-    context 'without if option' do
-      before do
-        environment[:one].use :auto_registration
-
-        module Test
-          class Users < ROM::Relation[:memory]
-            dataset :users
-          end
-
-          class CreateUser < ROM::Commands::Create[:memory]
-            register_as :create
-            relation :users
-            result :one
-          end
-
-          class UserMapper < ROM::Mapper
-            relation :users
-            register_as :entity
-          end
-        end
-      end
-
-      it 'registers all classes that are defined with the given environment' do
-        expect(container[:one].relations[:users]).to be_kind_of Test::Users
-        expect(container[:one].commands[:users].create).to be_kind_of Test::CreateUser
-        expect(container[:one].mappers[:users].entity).to be_kind_of Test::UserMapper
-      end
+      configuration[:one].register_relation(Test::Users)
+      configuration[:one].register_command(Test::CreateUser)
+      configuration[:one].register_mapper(Test::UserMapper)
 
-      it 'works independently of other environments' do
-        expect { container[:two].relations[:users] }.to raise_error(
-          ROM::Registry::ElementNotFoundError
-        )
-        expect { container[:two].commands[:users].create }.to raise_error(
-          ROM::Registry::ElementNotFoundError
-        )
-        expect { container[:two].commands[:users].create }.to raise_error(
-          ROM::Registry::ElementNotFoundError
-        )
-      end
-    end
-
-    context 'with if option' do
-      before do
-        environment[:one].use :auto_registration, if: ->(item) do
-          item.to_s[/(.*)(?=::)/] == 'Test'
-        end
-
-        environment[:two].use :auto_registration, if: ->(item) do
-          item.to_s[/(.*)(?=::)/] == 'Test::API'
-        end
-
-        module Test
-          class Users < ROM::Relation[:memory]
-            dataset :users
-          end
-
-          class CreateUser < ROM::Commands::Create[:memory]
-            register_as :create
-            relation :users
-            result :one
-          end
-
-          class UserMapper < ROM::Mapper
-            relation :users
-            register_as :entity
-          end
-
-          module API
-            class Users < ROM::Relation[:memory]
-              dataset :users
-            end
-
-            class CreateUser < ROM::Commands::Create[:memory]
-              register_as :create
-              relation :users
-              result :one
-            end
-
-            class UserMapper < ROM::Mapper
-              relation :users
-              register_as :entity
-            end
-          end
-        end
-      end
-
-      it 'registers all classes that are defined where proc returns true' do
-        expect(container[:one].relations[:users]).to be_kind_of Test::Users
-        expect(container[:one].commands[:users].create).to be_kind_of Test::CreateUser
-        expect(container[:one].mappers[:users].entity).to be_kind_of Test::UserMapper
-        expect(container[:two].relations[:users]).to be_kind_of Test::API::Users
-        expect(container[:two].commands[:users].create).to be_kind_of(
-          Test::API::CreateUser
-        )
-        expect(container[:two].mappers[:users].entity).to be_kind_of(
-          Test::API::UserMapper
-        )
-      end
+      expect { configuration[:two].register_relation(Test::Users) }.to_not raise_error
+      expect { configuration[:two].register_command(Test::CreateUser) }.to_not raise_error
+      expect { configuration[:two].register_mapper(Test::UserMapper) }.to_not raise_error
     end
   end
 end

data/spec/integration/multi_repo_spec.rb

@@ -2,29 +2,29 @@ require 'spec_helper'
 require 'rom/memory'
 
 describe 'Using in-memory gateways for cross-repo access' do
-  let(:setup) do
-    ROM.setup(left: :memory, right: :memory, main: :memory)
+  let(:configuration) do
+    ROM::Configuration.new(left: :memory, right: :memory, main: :memory).use(:macros)
   end
 
-  let(:gateways) { rom.gateways }
-  let(:rom) { setup.finalize }
+  let(:container) { ROM.container(configuration) }
+  let(:gateways) { container.gateways }
 
   it 'works' do
-    setup.relation(:users, gateway: :left) do
+    configuration.relation(:users, gateway: :left) do
       def by_name(name)
         restrict(name: name)
       end
     end
 
-    setup.relation(:tasks, gateway: :right)
+    configuration.relation(:tasks, gateway: :right)
 
-    setup.relation(:users_and_tasks, gateway: :main) do
+    configuration.relation(:users_and_tasks, gateway: :main) do
       def by_user(name)
         join(users.by_name(name), tasks)
       end
     end
 
-    setup.mappers do
+    configuration.mappers do
       define(:users_and_tasks) do
         group tasks: [:title]
       end
@@ -35,7 +35,7 @@ describe 'Using in-memory gateways for cross-repo access' do
     gateways[:right][:tasks] << { user_id: 1, title: 'Have fun' }
     gateways[:right][:tasks] << { user_id: 2, title: 'Have fun' }
 
-    user_and_tasks = rom.relation(:users_and_tasks)
+    user_and_tasks = container.relation(:users_and_tasks)
       .by_user('Jane')
       .as(:users_and_tasks)
 

data/spec/integration/relations/default_dataset_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe ROM::Relation, '.dataset' do
+  include_context 'container'
+
+  it 'injects configured dataset when block was provided' do
+    configuration.relation(:users) do
+      dataset { restrict(name: 'Jane') }
+    end
+
+    expect(container.relation(:users).dataset).to eql(
+      container.relation(:users).dataset.restrict(name: 'Jane')
+    )
+  end
+end

data/spec/integration/relations/inheritance_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
 RSpec.describe 'Inheritance relation hierarchy' do
-  before do
-    ROM.setup(:memory)
+  include_context 'container'
 
+  before do
     module Test
       class Users < ROM::Relation[:memory]
         dataset :users
@@ -18,14 +18,12 @@ RSpec.describe 'Inheritance relation hierarchy' do
       end
     end
 
-    ROM.finalize
+    configuration.register_relation(Test::Users, Test::OtherUsers)
   end
 
   it 'registers parent and descendant relations' do
-    rom = ROM.env
-
-    users = rom.relations.users
-    other_users = rom.relations.other_users
+    users = container.relation(:users)
+    other_users = container.relation(:other_users)
 
     expect(users).to be_instance_of(Test::Users)
     expect(other_users).to be_instance_of(Test::OtherUsers)

data/spec/integration/relations/reading_spec.rb

@@ -1,22 +1,34 @@
 require 'spec_helper'
 
 describe 'Reading relations' do
+  include_context 'container'
   include_context 'users and tasks'
 
-  it 'exposes a relation reader' do
-    setup.relation(:tasks)
+  before do
+    configuration.relation(:tasks)
 
-    setup.relation(:users) do
+    configuration.relation(:users) do
       def by_name(name)
         restrict(name: name)
       end
 
+      def with_task
+        join(tasks)
+      end
+
+      def with_tasks
+        join(tasks)
+      end
+
       def sorted
         order(:name, :email)
       end
     end
+  end
+
 
-    setup.mappers do
+  it 'exposes a relation reader' do
+    configuration.mappers do
       define(:users) do
         model name: 'Test::User'
 
@@ -25,9 +37,7 @@ describe 'Reading relations' do
       end
     end
 
-    rom = setup.finalize
-
-    users = rom.relation(:users).sorted.by_name('Jane').as(:users)
+    users = users_relation.sorted.by_name('Jane').as(:users)
     user = users.first
 
     expect(user).to be_an_instance_of(Test::User)
@@ -36,19 +46,7 @@ describe 'Reading relations' do
   end
 
   it 'maps grouped relations' do
-    setup.relation(:tasks)
-
-    setup.relation(:users) do
-      def with_tasks
-        join(tasks)
-      end
-
-      def sorted
-        order(:name)
-      end
-    end
-
-    setup.mappers do
+    configuration.mappers do
       define(:users) do
         model name: 'Test::User'
 
@@ -63,18 +61,18 @@ describe 'Reading relations' do
       end
     end
 
-    rom = setup.finalize
+    container
 
     Test::User.send(:include, Equalizer.new(:name, :email))
     Test::UserWithTasks.send(:include, Equalizer.new(:name, :email, :tasks))
 
-    user = rom.relation(:users).sorted.as(:users).first
+    user = container.relation(:users).sorted.as(:users).first
 
     expect(user).to eql(
       Test::User.new(name: "Jane", email: "jane@doe.org")
     )
 
-    user = rom.relation(:users).with_tasks.sorted.as(:with_tasks).first
+    user = container.relation(:users).with_tasks.sorted.as(:with_tasks).first
 
     expect(user).to eql(
       Test::UserWithTasks.new(
@@ -85,19 +83,7 @@ describe 'Reading relations' do
   end
 
   it 'maps wrapped relations' do
-    setup.relation(:tasks)
-
-    setup.relation(:users) do
-      def with_task
-        join(tasks)
-      end
-
-      def sorted
-        order(:name)
-      end
-    end
-
-    setup.mappers do
+    configuration.mappers do
       define(:users) do
         model name: 'Test::User'
 
@@ -112,12 +98,12 @@ describe 'Reading relations' do
       end
     end
 
-    rom = setup.finalize
+    container
 
     Test::User.send(:include, Equalizer.new(:name, :email))
     Test::UserWithTask.send(:include, Equalizer.new(:name, :email, :task))
 
-    user = rom.relation(:users).sorted.with_task.as(:with_task).first
+    user = container.relation(:users).sorted.with_task.as(:with_task).first
 
     expect(user).to eql(
       Test::UserWithTask.new(name: "Jane", email: "jane@doe.org",
@@ -126,27 +112,17 @@ describe 'Reading relations' do
   end
 
   it 'maps hashes' do
-    setup.relation(:users) do
-      def by_name(name)
-        restrict(name: name)
-      end
-    end
-
-    setup.mappers do
+    configuration.mappers do
       define(:users)
     end
 
-    rom = setup.finalize
-
-    user = rom.relation(:users).by_name("Jane").as(:users).first
+    user = container.relation(:users).by_name("Jane").as(:users).first
 
     expect(user).to eql(name: "Jane", email: "jane@doe.org")
   end
 
   it 'allows cherry-picking of a mapper' do
-    setup.relation(:users)
-
-    setup.mappers do
+    configuration.mappers do
       define(:users) do
         attribute :name
         attribute :email
@@ -158,20 +134,13 @@ describe 'Reading relations' do
       end
     end
 
-    rom = setup.finalize
-    user = rom.relation(:users).map_with(:prefixer).first
+    user = container.relation(:users).map_with(:prefixer).first
 
     expect(user).to eql(user_name: 'Joe', user_email: "joe@doe.org")
   end
 
   it 'allows passing a block to retrieve relations for mapping' do
-    setup.relation(:users) do
-      def by_name(name)
-        restrict(name: name)
-      end
-    end
-
-    setup.mappers do
+    configuration.mappers do
       define(:users) do
         attribute :name
         attribute :email
@@ -183,17 +152,15 @@ describe 'Reading relations' do
       end
     end
 
-    rom = setup.finalize
-
     expect {
-      rom.relation(:users) { |users| users.not_here }
+      container.relation(:users, &:not_here)
     }.to raise_error(NoMethodError, /not_here/)
 
     expect {
-      rom.relation(:users) { |users| users.by_name('Joe') }.as(:not_here)
+      container.relation(:users) { |users| users.by_name('Joe') }.as(:not_here)
     }.to raise_error(ROM::MapperMissingError, /not_here/)
 
-    user = rom.relation(:users) { |users|
+    user = container.relation(:users) { |users|
       users.by_name('Joe')
     }.map_with(:prefixer).call.first