rom 0.9.1 → 1.0.0.beta1

data/spec/unit/rom/relation/composite_spec.rb

@@ -1,16 +1,11 @@
 require 'spec_helper'
 
 describe ROM::Relation::Composite do
+  include_context 'gateway only'
   include_context 'users and tasks'
 
-  let(:users) { rom.relation(:users) }
-  let(:tasks) { rom.relation(:tasks) }
-
-  let(:name_list) { proc { |r| r.map { |t| t[:name] } } }
-  let(:upcaser) { proc { |r| r.map(&:upcase) } }
-
-  before do
-    setup.relation(:users) do
+  let(:users_relation) do
+    Class.new(ROM::Memory::Relation) do
       def by_name(name)
         restrict(name: name)
       end
@@ -18,30 +13,35 @@ describe ROM::Relation::Composite do
       def sorted(other)
         other.source.order(:name)
       end
-    end
+    end.new(users_dataset)
+  end
 
-    setup.relation(:tasks) do
+  let(:tasks_relation) do
+    Class.new(ROM::Memory::Relation) do
       def for_users(users)
         restrict(name: users.map { |u| u[:name] })
       end
-    end
+    end.new(tasks_dataset)
   end
 
+  let(:name_list) { proc { |r| r.map { |t| t[:name] } } }
+  let(:upcaser) { proc { |r| r.map(&:upcase) } }
+
   describe '#call' do
     it 'sends a relation through mappers' do
-      relation = users >> name_list >> upcaser
+      relation = users_relation >> name_list >> upcaser
       loaded = relation.call
 
-      expect(loaded.source).to eql(users)
+      expect(loaded.source).to eql(users_relation)
 
       expect(loaded).to match_array(%w(JANE JOE))
     end
 
     it 'sends a relation through another relation' do
-      relation = users >> users.sorted
+      relation = users_relation >> users_relation.sorted
       loaded = relation.call
 
-      expect(loaded.source).to eql(users.sorted(users.call))
+      expect(loaded.source).to eql(users_relation.sorted(users_relation.call))
 
       expect(loaded).to match_array([
         { name: 'Jane', email: 'jane@doe.org' },
@@ -50,12 +50,12 @@ describe ROM::Relation::Composite do
     end
 
     it 'sends a relation through another composite relation' do
-      task_mapper = -> tasks { tasks }
-      relation = users.by_name('Jane') >> (tasks.for_users >> task_mapper)
+      task_mapper = -> tasks_relation { tasks_relation }
+      relation = users_relation.by_name('Jane') >> (tasks_relation.for_users >> task_mapper)
 
       loaded = relation.call
 
-      expect(loaded.source).to eql(tasks.for_users(users.by_name('Jane')))
+      expect(loaded.source).to eql(tasks_relation.for_users(users_relation.by_name('Jane')))
 
       expect(loaded).to match_array([
         { name: 'Jane', title: 'be cool', priority: 2 }
@@ -64,7 +64,7 @@ describe ROM::Relation::Composite do
   end
 
   describe '#each' do
-    let(:relation) { users >> name_list >> upcaser }
+    let(:relation) { users_relation >> name_list >> upcaser }
 
     it 'calls and iterates' do
       result = []
@@ -80,7 +80,7 @@ describe ROM::Relation::Composite do
   end
 
   describe '#first' do
-    let(:relation) { users >> name_list >> upcaser }
+    let(:relation) { users_relation >> name_list >> upcaser }
 
     it 'calls and returns the first object' do
       expect(relation.first).to eql('JOE')

data/spec/unit/rom/relation/curried_spec.rb

@@ -1,12 +1,11 @@
 require 'spec_helper'
 
 RSpec.describe ROM::Relation::Curried do
+  include_context 'gateway only'
   include_context 'users and tasks'
 
-  let(:users) { rom.relations.users }
-
-  before do
-    setup.relation(:users) do
+  let(:users_relation) do
+    Class.new(ROM::Memory::Relation) do
       def by_name(name)
         restrict(name: name)
       end
@@ -14,11 +13,11 @@ RSpec.describe ROM::Relation::Curried do
       def find(criteria)
         restrict(criteria)
       end
-    end
+    end.new(users_dataset)
   end
 
   describe '#call' do
-    let(:relation) { users.by_name.('Jane') }
+    let(:relation) { users_relation.by_name.call('Jane') }
 
     it 'materializes a relation' do
       expect(relation).to match_array([
@@ -27,27 +26,27 @@ RSpec.describe ROM::Relation::Curried do
     end
 
     it 'returns a loaded relation' do
-      expect(relation.source).to eql(users.by_name('Jane'))
+      expect(relation.source).to eql(users_relation.by_name('Jane'))
     end
   end
 
   describe '#respond_to?' do
     it 'returns true if wrapped relation responds to a method' do
-      expect(users.by_name).to respond_to(:dataset)
+      expect(users_relation.by_name).to respond_to(:dataset)
     end
 
     it 'returns false if wrapped relation does not respond to a method' do
-      expect(users.by_name).not_to respond_to(:not_here)
+      expect(users_relation.by_name).not_to respond_to(:not_here)
     end
   end
 
   describe '#method_missing' do
     it 'forwards to the relation' do
-      expect(users.by_name.dataset).to eql(users.dataset)
+      expect(users_relation.by_name.dataset).to eql(users_relation.dataset)
     end
 
     it 'does not forward to the relation when method is auto-curried' do
-      expect { users.by_name.find }.to raise_error(NoMethodError, /find/)
+      expect { users_relation.by_name.find }.to raise_error(NoMethodError, /find/)
     end
   end
 end

data/spec/unit/rom/relation/graph_spec.rb

@@ -1,36 +1,36 @@
 require 'spec_helper'
 
 describe ROM::Relation::Graph do
-  subject(:graph) { ROM::Relation::Graph.new(users, [tasks.for_users]) }
-
+  include_context 'gateway only'
   include_context 'users and tasks'
 
-  it_behaves_like 'materializable relation' do
-    let(:mapper) do
-      T(:combine, [[:tasks, name: :name]])
-    end
-
-    let(:relation) do
-      ROM::Relation::Graph.new(users.by_name('Jane'), [tasks.for_users]) >> mapper
-    end
-  end
-
-  before do
-    setup.relation(:users) do
+  let(:users_relation) do
+    Class.new(ROM::Memory::Relation) do
       def by_name(name)
         restrict(name: name)
       end
-    end
+    end.new(users_dataset)
+  end
 
-    setup.relation(:tasks) do
+  let(:tasks_relation) do
+    Class.new(ROM::Memory::Relation) do
       def for_users(_users)
         self
       end
-    end
+    end.new(tasks_dataset)
   end
 
-  let(:users) { rom.relation(:users) }
-  let(:tasks) { rom.relation(:tasks) }
+  subject(:graph) { ROM::Relation::Graph.new(users_relation, [tasks_relation.for_users]) }
+
+  it_behaves_like 'materializable relation' do
+    let(:mapper) do
+      T(:combine, [[:tasks, name: :name]])
+    end
+
+    let(:relation) do
+      ROM::Relation::Graph.new(users_relation.by_name('Jane'), [tasks_relation.for_users]) >> mapper
+    end
+  end
 
   describe '#method_missing' do
     it 'responds to the root methods' do
@@ -42,11 +42,11 @@ describe ROM::Relation::Graph do
     end
 
     it 'forwards methods to the root and decorates curried response' do
-      expect((users.combine(tasks.for_users)).by_name).to be_instance_of(ROM::Relation::Graph)
+      expect((users_relation.combine(tasks_relation.for_users)).by_name).to be_instance_of(ROM::Relation::Graph)
     end
 
     it 'returns original response from the root' do
-      expect(graph.mappers).to eql(users.mappers)
+      expect(graph.mappers).to eql(users_relation.mappers)
     end
 
     it 'raises method error' do
@@ -57,8 +57,8 @@ describe ROM::Relation::Graph do
   describe '#call' do
     it 'materializes relations' do
       expect(graph.call).to match_array([
-        rom.relations.users,
-        [rom.relations.tasks]
+        users_relation,
+        [tasks_relation]
       ])
     end
   end
@@ -66,16 +66,16 @@ describe ROM::Relation::Graph do
   describe '#to_a' do
     it 'coerces to an array' do
       expect(graph).to match_array([
-        users.to_a,
-        [tasks.for_users(users).to_a]
+        users_relation.to_a,
+        [tasks_relation.for_users(users_relation).to_a]
       ])
     end
 
     it 'returns empty arrays when left was empty' do
-      graph = ROM::Relation::Graph.new(users.by_name('Not here'), [tasks.for_users])
+      graph = ROM::Relation::Graph.new(users_relation.by_name('Not here'), [tasks_relation.for_users])
 
       expect(graph).to match_array([
-        [], [ROM::Relation::Loaded.new(tasks.for_users, [])]
+        [], [ROM::Relation::Loaded.new(tasks_relation.for_users, [])]
       ])
     end
   end

data/spec/unit/rom/relation/lazy/combine_spec.rb

@@ -1,23 +1,31 @@
 require 'spec_helper'
 
 describe ROM::Relation, '#combine' do
+  include_context 'gateway only'
   include_context 'users and tasks'
 
-  before do
-    setup.relation(:users) do
+  let(:tags_dataset) { gateway.dataset(:tags) }
+
+  let(:users_relation) do
+    Class.new(ROM::Memory::Relation) do
       def by_name(name)
         restrict(name: name)
       end
-    end
+    end.new(users_dataset)
+  end
 
-    setup.relation(:tasks) do
+  let(:tasks_relation) do
+    Class.new(ROM::Memory::Relation) do
       def for_users(users)
         names = users.map { |user| user[:name] }
         restrict { |task| names.include?(task[:name]) }
       end
-    end
+    end.new(tasks_dataset)
+  end
 
-    setup.relation(:tags) do
+  let(:tags_relation) do
+    Class.new(ROM::Memory::Relation) do
+      attr_accessor :tasks
       forward :map
 
       def for_tasks(tasks)
@@ -34,15 +42,13 @@ describe ROM::Relation, '#combine' do
           } [:name])
         }
       end
-    end
-
-    setup.gateways[:default].dataset(:tags).insert(task: 'be cool', name: 'red')
-    setup.gateways[:default].dataset(:tags).insert(task: 'be cool', name: 'green')
+    end.new(tags_dataset).tap { |r| r.tasks = tasks_relation }
   end
 
-  let(:users) { rom.relation(:users) }
-  let(:tasks) { rom.relation(:tasks) }
-  let(:tags) { rom.relation(:tags) }
+  before do
+    tags_dataset.insert(task: 'be cool', name: 'red')
+    tags_dataset.insert(task: 'be cool', name: 'green')
+  end
 
   let(:map_users) {
     proc { |users, tasks|
@@ -87,7 +93,7 @@ describe ROM::Relation, '#combine' do
 
   it 'raises error when composite relation is passed as a node' do
     expect {
-      users.combine(tasks >> proc {})
+      users_relation.combine(tasks_relation >> proc {})
     }.to raise_error(ROM::UnsupportedRelationError)
   end
 
@@ -106,8 +112,8 @@ describe ROM::Relation, '#combine' do
       }
     ]
 
-    user_with_tasks_and_tags = users.by_name('Jane')
-      .combine(tasks.for_users, tags.for_users)
+    user_with_tasks_and_tags = users_relation.by_name('Jane')
+      .combine(tasks_relation.for_users, tags_relation.for_users)
 
     result = user_with_tasks_and_tags >> map_user_with_tasks_and_tags
 
@@ -129,8 +135,8 @@ describe ROM::Relation, '#combine' do
       }
     ]
 
-    user_with_tasks_and_tags = users.by_name('Jane')
-      .combine(tasks.for_users).combine(tags.for_users)
+    user_with_tasks_and_tags = users_relation.by_name('Jane')
+      .combine(tasks_relation.for_users).combine(tags_relation.for_users)
 
     result = user_with_tasks_and_tags >> map_user_with_tasks_and_tags
 
@@ -149,8 +155,8 @@ describe ROM::Relation, '#combine' do
       }
     ]
 
-    user_with_tasks = users.by_name('Jane')
-      .combine(tasks.for_users.combine(tags.for_tasks))
+    user_with_tasks = users_relation.by_name('Jane')
+      .combine(tasks_relation.for_users.combine(tags_relation.for_tasks))
 
     result = user_with_tasks >> map_user_with_tasks
 

data/spec/unit/rom/relation/lazy_spec.rb

@@ -1,13 +1,11 @@
 require 'spec_helper'
 
 describe ROM::Relation do
+  include_context 'gateway only'
   include_context 'users and tasks'
 
-  let(:users) { rom.relations.users }
-  let(:tasks) { rom.relations.tasks }
-
-  before do
-    setup.relation(:users) do
+  let(:users_relation) do
+    Class.new(ROM::Memory::Relation) do
       def by_name(name)
         restrict(name: name)
       end
@@ -35,31 +33,33 @@ describe ROM::Relation do
           self
         end
       end
-    end
+    end.new(users_dataset)
+  end
 
-    setup.relation(:tasks) do
+  let(:tasks_relation) do
+    Class.new(ROM::Memory::Relation) do
       def for_users(users)
         names = users.map { |u| u[:name] }
         restrict { |t| names.include?(t[:name]) }
       end
-    end
+    end.new(tasks_dataset)
   end
 
   it_behaves_like 'a relation that returns one tuple' do
-    let(:relation) { users }
+    let(:relation) { users_relation }
   end
 
   describe '#map_with' do
     it 'raises error when unknown mapper was selected' do
       expect {
-        users.as(:not_here)
+        users_relation.as(:not_here)
       }.to raise_error(ROM::MapperMissingError, /not_here/)
     end
   end
 
   describe '#method_missing' do
     it 'forwards to relation and auto-curries' do
-      relation = users.by_name_and_email_sorted('Jane')
+      relation = users_relation.by_name_and_email_sorted('Jane')
 
       expect(relation.name).to eql(:by_name_and_email_sorted)
       expect(relation.curry_args).to eql(['Jane'])
@@ -70,46 +70,46 @@ describe ROM::Relation do
       expect(relation.curry_args).to eql(['Jane', 'jane@doe.org'])
 
       expect(relation[:email]).to match_array(
-        rom.relations.users.by_name_and_email_sorted('Jane', 'jane@doe.org', :email)
+        users_relation.by_name_and_email_sorted('Jane', 'jane@doe.org', :email)
       )
     end
 
     it 'forwards to relation and does not auto-curry when it is not needed' do
-      relation = users.by_name('Jane')
+      relation = users_relation.by_name('Jane')
 
       expect(relation).to_not be_curried
-      expect(relation).to match_array(rom.relations.users.by_name('Jane'))
+      expect(relation).to match_array(users_relation.by_name('Jane'))
     end
 
     it 'forwards to relation and return lazy when arity is unknown' do
-      relation = users.all(name: 'Jane')
+      relation = users_relation.all(name: 'Jane')
       expect(relation).to_not be_curried
-      expect(relation).to match_array(rom.relations.users.by_name('Jane').to_a)
+      expect(relation).to match_array(users_relation.by_name('Jane').to_a)
     end
 
     it 'returns original response if it is not a relation' do
-      expect(users.gateway).to be(:default)
+      expect(users_relation.gateway).to be(:default)
     end
 
     it 'raises NoMethodError when relation does not respond to a method' do
-      expect { users.not_here }.to raise_error(NoMethodError, /not_here/)
+      expect { users_relation.not_here }.to raise_error(NoMethodError, /not_here/)
     end
   end
 
   describe '#call' do
     it 'auto-curries' do
-      relation = users.by_name
+      relation = users_relation.by_name
 
       expect(relation.name).to eql(:by_name)
-      expect(relation['Jane'].to_a).to eql(rom.relations.users.by_name('Jane').to_a)
+      expect(relation['Jane'].to_a).to eql(users_relation.by_name('Jane').to_a)
     end
 
     it 'returns relation' do
-      expect(users.call.to_a).to eql(rom.relations.users.to_a)
+      expect(users_relation.call.to_a).to eql(users_relation.to_a)
     end
 
     describe 'using mappers' do
-      subject(:users) { rom.relations.users.with(mappers: mappers) }
+      subject(:users) { users_relation.with(mappers: mappers) }
 
       let(:name_list) { proc { |r| r.map { |t| t[:name] } } }
       let(:upcaser) { proc { |r| r.map(&:upcase) } }
@@ -125,24 +125,24 @@ describe ROM::Relation do
 
   describe '#first' do
     it 'return first tuple' do
-      expect(users.first).to eql(name: 'Joe', email: 'joe@doe.org')
+      expect(users_relation.first).to eql(name: 'Joe', email: 'joe@doe.org')
     end
 
     it 'raises when relation is curried and arity does not match' do
-      expect { users.by_name.first }.to raise_error(
-        ArgumentError, 'ROM::Relation[Users]#by_name arity is 1 (0 args given)'
+      expect { users_relation.by_name.first }.to raise_error(
+        ArgumentError, "#{users_relation.class.to_s}#by_name arity is 1 (0 args given)"
       )
     end
 
     it 'does not raise when relation is curried and arity matches' do
-      expect { users.by_name_sorted('Joe').first }.to_not raise_error
+      expect { users_relation.by_name_sorted('Joe').first }.to_not raise_error
     end
   end
 
   describe '#each' do
     it 'yields relation tuples' do
       result = []
-      users.each do |tuple|
+      users_relation.each do |tuple|
         result << tuple
       end
       expect(result).to match_array([
@@ -152,45 +152,45 @@ describe ROM::Relation do
     end
 
     it 'returns an enumerator if block is not provided' do
-      expect(users.each.to_a).to match_array([
+      expect(users_relation.each.to_a).to match_array([
         { name: 'Jane', email: 'jane@doe.org' },
         { name: 'Joe', email: 'joe@doe.org' }
       ])
     end
 
     it 'raises when relation is curried and arity does not match' do
-      expect { users.by_name.each {} }.to raise_error(
-        ArgumentError, 'ROM::Relation[Users]#by_name arity is 1 (0 args given)'
+      expect { users_relation.by_name.each {} }.to raise_error(
+        ArgumentError, "#{users_relation.class.to_s}#by_name arity is 1 (0 args given)"
       )
     end
 
     it 'does not raise when relation is curried and arity matches' do
-      expect { users.by_name_sorted('Jane').first }.to_not raise_error
+      expect { users_relation.by_name_sorted('Jane').first }.to_not raise_error
     end
   end
 
   describe '#to_ary' do
     it 'returns an array with relation tuples' do
-      expect(users.to_ary).to match_array([
+      expect(users_relation.to_ary).to match_array([
         { name: 'Jane', email: 'jane@doe.org' },
         { name: 'Joe', email: 'joe@doe.org' }
       ])
     end
 
     it 'raises when relation is curried and arity does not match' do
-      expect { users.by_name.to_ary }.to raise_error(
-        ArgumentError, 'ROM::Relation[Users]#by_name arity is 1 (0 args given)'
+      expect { users_relation.by_name.to_ary }.to raise_error(
+        ArgumentError, "#{users_relation.class.to_s}#by_name arity is 1 (0 args given)"
       )
     end
 
     it 'does not raise when relation is curried and arity matches' do
-      expect { users.by_name_sorted('Jane').first }.to_not raise_error
+      expect { users_relation.by_name_sorted('Jane').first }.to_not raise_error
     end
   end
 
   describe '#>>' do
     it 'composes two relations' do
-      other = users.by_name('Jane') >> tasks.for_users
+      other = users_relation.by_name('Jane') >> tasks_relation.for_users
 
       expect(other).to match_array([
         { name: 'Jane', title: 'be cool', priority: 2 }
@@ -198,12 +198,12 @@ describe ROM::Relation do
     end
 
     it_behaves_like 'a relation that returns one tuple' do
-      let(:relation) { rom.relation(:users) >> proc { |r| r } }
+      let(:relation) { users_relation >> proc { |r| r } }
 
       describe 'using a mapper' do
         it 'returns one mapped tuple' do
           mapper = proc { |r| r.map { |t| t[:name].upcase } }
-          relation = users.by_name('Jane') >> mapper
+          relation = users_relation.by_name('Jane') >> mapper
 
           expect(relation.one).to eql('JANE')
           expect(relation.one!).to eql('JANE')