rom 0.9.1 → 1.0.0.beta1

data/spec/integration/relations/registry_dsl_spec.rb

@@ -1,10 +1,11 @@
 require 'spec_helper'
 
 describe 'Relation registration DSL' do
+  include_context 'container'
   include_context 'users and tasks'
 
   it 'allows to expose chainable relations' do
-    setup.relation(:tasks) do
+    configuration.relation(:tasks) do
       def high_priority
         restrict { |tuple| tuple[:priority] < 2 }
       end
@@ -14,13 +15,13 @@ describe 'Relation registration DSL' do
       end
     end
 
-    setup.relation(:users) do
+    configuration.relation(:users) do
       def with_tasks
         join(tasks)
       end
     end
 
-    tasks = rom.relations.tasks
+    tasks = container.relations.tasks
 
     expect(tasks.class.name).to eql("ROM::Relation[Tasks]")
     expect(tasks.high_priority.inspect).to include("#<ROM::Relation[Tasks]")
@@ -33,7 +34,7 @@ describe 'Relation registration DSL' do
       [name: "Jane", title: "be cool", priority: 2]
     )
 
-    users = rom.relations.users
+    users = container.relations.users
 
     expect(users.with_tasks).to match_array(
       [{ name: "Joe", email: "joe@doe.org", title: "be nice", priority: 1 },

data/spec/integration/repositories/extending_relations_spec.rb

@@ -2,9 +2,8 @@ require 'spec_helper'
 require 'rom/memory'
 
 describe 'Repository' do
-  let!(:setup) { ROM.setup(:memory) }
-
-  let(:rom) { setup.finalize }
+  include_context 'container'
+  include_context 'users and tasks'
 
   before do
     module ROM
@@ -33,18 +32,18 @@ describe 'Repository' do
 
   shared_examples_for 'extended relation' do
     it 'can extend relation class' do
-      expect(rom.relations.users.class).to be_freaking_awesome
+      expect(container.relations.users.class).to be_freaking_awesome
     end
 
     it 'can extend relation instance' do
-      expect(rom.relations.users).to be_freaking_cool
+      expect(container.relations.users).to be_freaking_cool
     end
   end
 
   context 'using DSL' do
     it_behaves_like 'extended relation' do
       before do
-        setup.relation(:users)
+        configuration.relation(:users)
       end
     end
   end
@@ -52,7 +51,7 @@ describe 'Repository' do
   context 'using class definition' do
     it_behaves_like 'extended relation' do
       before do
-        Class.new(ROM::Relation[:memory]) { dataset :users }
+        configuration.register_relation(Class.new(ROM::Relation[:memory]) { dataset :users })
       end
     end
   end

data/spec/integration/repositories/setting_logger_spec.rb

@@ -23,13 +23,11 @@ describe 'Repositories / Setting logger' do
   end
 
   it 'sets up a logger for a given gateway' do
-    setup = ROM.setup(:memory)
-
-    setup.default.use_logger(logger)
-
-    rom = setup.finalize
-
-    rom.gateways[:default].logger.info("test")
+    container = ROM.container(:memory) do |config|
+      config.gateways[:default].use_logger(logger)
+    end
+      
+    container.gateways[:default].logger.info("test")
 
     expect(logger.messages).to eql(["test"])
   end

data/spec/integration/setup_spec.rb

@@ -1,24 +1,25 @@
 require 'spec_helper'
 require 'virtus'
 
-describe 'Setting up ROM' do
+describe 'Configuring ROM' do
   context 'with existing schema' do
+    include_context 'container'
     include_context 'users and tasks'
 
     let(:jane) { { name: 'Jane', email: 'jane@doe.org' } }
     let(:joe) { { name: 'Joe', email: 'joe@doe.org' } }
 
     before do
-      setup.relation(:users)
-      setup.relation(:tasks)
+      configuration.relation(:users)
+      configuration.relation(:tasks)
     end
 
     it 'configures schema relations' do
-      expect(rom.gateways[:default][:users]).to match_array([joe, jane])
+      expect(container.gateways[:default][:users]).to match_array([joe, jane])
     end
 
     it 'configures rom relations' do
-      users = rom.relations.users
+      users = container.relations.users
 
       expect(users).to be_kind_of(ROM::Relation)
       expect(users).to respond_to(:tasks)
@@ -29,70 +30,55 @@ describe 'Setting up ROM' do
       expect(tasks).to respond_to(:users)
       expect(tasks.users).to be(users)
     end
-
-    it 'raises on double-finalize' do
-      expect {
-        2.times { setup.finalize }
-      }.to raise_error(ROM::EnvAlreadyFinalizedError)
-    end
   end
 
   context 'without schema' do
     it 'builds empty registries if there is no schema' do
-      setup = ROM.setup(:memory)
-
-      rom = setup.finalize
-
-      expect(rom.relations).to eql(ROM::RelationRegistry.new)
-      expect(rom.mappers).to eql(ROM::Registry.new)
-    end
-  end
-
-  context 'with old syntax' do
-    it 'warns when old repository key is used' do
-      setup = ROM.setup(data: :memory)
-
-      expect {
-        setup.relation(:users, repository: :data)
-      }.to output(/use `gateway: :data`/).to_stderr
+      container = ROM.container(:memory)
+      expect(container.relations).to eql(ROM::RelationRegistry.new)
+      expect(container.mappers).to eql(ROM::Registry.new)
     end
   end
 
   describe 'defining classes' do
     it 'sets up registries based on class definitions' do
-      ROM.setup(:memory)
+      container = ROM.container(:memory) do |config|
+        config.use(:macros)
 
-      class Test::UserRelation < ROM::Relation[:memory]
-        dataset :users
+        class Test::UserRelation < ROM::Relation[:memory]
+          dataset :users
 
-        def by_name(name)
-          restrict(name: name)
+          def by_name(name)
+            restrict(name: name)
+          end
         end
-      end
 
-      class Test::TaskRelation < ROM::Relation[:memory]
-        dataset :tasks
-      end
+        class Test::TaskRelation < ROM::Relation[:memory]
+          dataset :tasks
+        end
 
-      class Test::CreateUser < ROM::Commands::Update[:memory]
-        relation :users
-        register_as :create
-      end
+        class Test::CreateUser < ROM::Commands::Update[:memory]
+          relation :users
+          register_as :create
+        end
 
-      rom = ROM.finalize.env
+        config.register_relation(Test::UserRelation, Test::TaskRelation)
+        config.register_command(Test::CreateUser)
+      end
 
-      expect(rom.relations.users).to be_kind_of(Test::UserRelation)
-      expect(rom.relations.users.tasks).to be(rom.relations.tasks)
+      expect(container.relations.users).to be_kind_of(Test::UserRelation)
+      expect(container.relations.users.tasks).to be(container.relations.tasks)
 
-      expect(rom.commands.users[:create]).to be_kind_of(Test::CreateUser)
+      expect(container.commands.users[:create]).to be_kind_of(Test::CreateUser)
 
-      expect(rom.relations.tasks).to be_kind_of(Test::TaskRelation)
-      expect(rom.relations.tasks.users).to be(rom.relations.users)
+      expect(container.relations.tasks).to be_kind_of(Test::TaskRelation)
+      expect(container.relations.tasks.users).to be(container.relations.users)
     end
   end
 
   describe 'quick setup' do
-    it 'exposes boot DSL inside the setup block' do
+    # NOTE: move to DSL tests
+    it 'exposes boot DSL inside the setup block via `macros` plugin' do
       module Test
         User = Class.new do
           include Virtus.value_object
@@ -100,27 +86,29 @@ describe 'Setting up ROM' do
         end
       end
 
-      rom = ROM.setup(:memory) {
-        relation(:users) do
+      container = ROM.container(:memory) do |rom|
+        rom.use(:macros)
+
+        rom.relation(:users) do
           def by_name(name)
             restrict(name: name)
           end
         end
 
-        commands(:users) do
+        rom.commands(:users) do
           define(:create)
         end
 
-        mappers do
+        rom.mappers do
           define(:users) do
             model Test::User
           end
         end
-      }
+      end
 
-      rom.commands.users.create.call(name: 'Jane')
+      container.commands.users.create.call(name: 'Jane')
 
-      expect(rom.relation(:users).by_name('Jane').as(:users).to_a)
+      expect(container.relation(:users).by_name('Jane').as(:users).to_a)
         .to eql([Test::User.new(name: 'Jane')])
     end
   end
@@ -134,29 +122,29 @@ describe 'Setting up ROM' do
         end
       end
 
-      ROM.setup(:memory)
+      configuration = ROM::Configuration.new(:memory).use(:macros)
 
-      ROM.relation(:users) do
+      configuration.relation(:users) do
         def by_name(name)
           restrict(name: name)
         end
       end
 
-      ROM.commands(:users) do
+      configuration.commands(:users) do
         define(:create)
       end
 
-      ROM.mappers do
+      configuration.mappers do
         define(:users) do
           model Test::User
         end
       end
 
-      rom = ROM.finalize.env
+      container = ROM.container(configuration)
 
-      rom.command(:users).create.call(name: 'Jane')
+      container.command(:users).create.call(name: 'Jane')
 
-      expect(rom.relation(:users).by_name('Jane').as(:users).to_a)
+      expect(container.relation(:users).by_name('Jane').as(:users).to_a)
         .to eql([Test::User.new(name: 'Jane')])
     end
   end

data/spec/shared/command_graph.rb

@@ -0,0 +1,50 @@
+shared_context 'command graph' do
+  include_context 'container'
+
+  before do
+    configuration.relation :users do
+      def by_name(name)
+        restrict(name: name)
+      end
+    end
+
+    configuration.relation :tasks do
+      def by_user_and_title(user, title)
+        by_user(user).by_title(title)
+      end
+
+      def by_user(user)
+        restrict(user: user)
+      end
+
+      def by_title(title)
+        restrict(title: title)
+      end
+    end
+
+    configuration.relation :books
+    configuration.relation :tags
+
+    configuration.commands(:users) do
+      define(:create) do
+        result :one
+      end
+    end
+
+    configuration.commands(:books) do
+      define(:create) do
+        def execute(tuples, user)
+          super(tuples.map { |t| t.merge(user: user.fetch(:name)) })
+        end
+      end
+    end
+
+    configuration.commands(:tags) do
+      define(:create) do
+        def execute(tuples, task)
+          super(tuples.map { |t| t.merge(task: task.fetch(:title)) })
+        end
+      end
+    end
+  end
+end

data/spec/shared/container.rb

@@ -0,0 +1,9 @@
+RSpec.shared_context 'container' do
+  let(:container) { ROM.container(configuration) }
+  let!(:configuration) { ROM::Configuration.new(:memory).use(:macros) }
+  let(:gateway) { configuration.gateways[:default] }
+  let(:users_relation) { container.relation(:users) }
+  let(:tasks_relation) { container.relation(:tasks) }
+  let(:users_dataset) { gateway.dataset(:users) }
+  let(:tasks_dataset) { gateway.dataset(:tasks) }
+end

data/spec/shared/gateway_only.rb

@@ -0,0 +1,6 @@
+RSpec.shared_context 'gateway only' do
+  let(:gateway) { ROM::Memory::Gateway.new }
+
+  let(:users_dataset) { gateway.dataset(:users) }
+  let(:tasks_dataset) { gateway.dataset(:tasks) }
+end

data/spec/shared/no_container.rb

@@ -0,0 +1,16 @@
+require 'rom/memory'
+
+RSpec.shared_context 'no container' do
+  let(:gateway) { ROM::Memory::Gateway.new }
+
+  let(:users_dataset) { gateway.dataset(:users) }
+  let(:tasks_dataset) { gateway.dataset(:tasks) }
+
+  let(:users_relation) do
+    Class.new(ROM::Memory::Relation).new(users_dataset)
+  end
+
+  let(:tasks_relation) do
+    Class.new(ROM::Memory::Relation).new(tasks_dataset)
+  end
+end

data/spec/shared/one_behavior.rb

@@ -1,7 +1,7 @@
 shared_examples_for 'a relation that returns one tuple' do
   describe '#one' do
     it 'returns first tuple' do
-      rom.relations.users.delete(name: 'Joe', email: 'joe@doe.org')
+      users_relation.delete(name: 'Joe', email: 'joe@doe.org')
       expect(relation.one).to eql(name: 'Jane', email: 'jane@doe.org')
     end
 
@@ -12,13 +12,13 @@ shared_examples_for 'a relation that returns one tuple' do
 
   describe '#one!' do
     it 'returns first tuple' do
-      rom.relations.users.delete(name: 'Joe', email: 'joe@doe.org')
+      users_relation.delete(name: 'Joe', email: 'joe@doe.org')
       expect(relation.one!).to eql(name: 'Jane', email: 'jane@doe.org')
     end
 
     it 'raises error when there is no tuples' do
-      rom.relations.users.delete(name: 'Jane', email: 'jane@doe.org')
-      rom.relations.users.delete(name: 'Joe', email: 'joe@doe.org')
+      users_relation.delete(name: 'Jane', email: 'jane@doe.org')
+      users_relation.delete(name: 'Joe', email: 'joe@doe.org')
 
       expect { relation.one! }.to raise_error(ROM::TupleCountMismatchError)
     end

data/spec/shared/users_and_tasks.rb

@@ -1,22 +1,10 @@
 RSpec.shared_context 'users and tasks' do
-  require 'rom/memory'
-
-  subject(:rom) { setup.finalize }
-
-  let(:setup) { ROM.setup(:memory) }
-
   before do
-    gateway = setup.default
-
-    users = gateway.dataset(:users)
-    tasks = gateway.dataset(:tasks)
-
-    users.insert(name: "Joe", email: "joe@doe.org")
-    users.insert(name: "Jane", email: "jane@doe.org")
-
-    tasks.insert(name: "Joe", title: "be nice", priority: 1)
-    tasks.insert(name: "Joe", title: "sleep well", priority: 2)
+    users_dataset.insert(name: "Joe", email: "joe@doe.org")
+    users_dataset.insert(name: "Jane", email: "jane@doe.org")
 
-    tasks.insert(name: "Jane", title: "be cool", priority: 2)
+    tasks_dataset.insert(name: "Joe", title: "be nice", priority: 1)
+    tasks_dataset.insert(name: "Joe", title: "sleep well", priority: 2)
+    tasks_dataset.insert(name: "Jane", title: "be cool", priority: 2)
   end
 end

data/spec/spec_helper.rb

@@ -17,7 +17,7 @@ begin
 rescue LoadError
 end
 
-root = Pathname(__FILE__).dirname
+SPEC_ROOT = root = Pathname(__FILE__).dirname
 
 Dir[root.join('support/*.rb').to_s].each do |f|
   require f
@@ -38,6 +38,10 @@ def T(*args)
 end
 
 RSpec.configure do |config|
+  config.before do
+    ROM.env = nil
+  end
+
   config.after do
     Test.remove_constants
   end
@@ -46,5 +50,3 @@ RSpec.configure do |config|
     ConstantLeakFinder.find(example)
   end
 end
-
-ROM.use :auto_registration