rom 0.5.0 → 0.6.0.beta1

data/spec/unit/rom/mapper_spec.rb

@@ -1,20 +1,23 @@
 require 'spec_helper'
+require 'rom/memory/dataset'
 
 require 'ostruct'
 
 describe ROM::Mapper do
-  subject(:mapper) do
-    ROM::Mapper.build(ROM::Header.coerce(relation.header.zip, user_model))
-  end
+  subject(:mapper) { mapper_class.build }
 
-  let(:relation) do
-    ROM::Relation.new(dataset, dataset.header)
+  let(:mapper_class) do
+    user_model = self.user_model
+
+    Class.new(ROM::Mapper) do
+      attribute :id
+      attribute :name
+      model user_model
+    end
   end
 
-  let(:dataset) do
-    ROM::Adapter::Memory::Dataset.new(
-      [{ id: 1, name: 'Jane' }, { id: 2, name: 'Joe' }], [:id, :name]
-    )
+  let(:relation) do
+    [{ id: 1, name: 'Jane' }, { id: 2, name: 'Joe' }]
   end
 
   let(:user_model) do
@@ -24,11 +27,49 @@ describe ROM::Mapper do
   let(:jane) { user_model.new(id: 1, name: 'Jane') }
   let(:joe) { user_model.new(id: 2, name: 'Joe') }
 
+  describe '.registry' do
+    it 'builds mapper class registry for base and virtual relations' do
+      users = Class.new(ROM::Mapper) { relation(:users) }
+      active = Class.new(users) { relation(:active) }
+      admins = Class.new(users) { relation(:admins) }
+      custom = Class.new(users) { register_as(:custom) }
+
+      registry = ROM::Mapper.registry([users, active, admins, custom])
+
+      expect(registry).to eql(
+        users: {
+          users: users.build,
+          active: active.build,
+          admins: admins.build,
+          custom: custom.build
+        }
+      )
+    end
+  end
+
+  describe '.relation' do
+    it 'inherits from parent' do
+      base = Class.new(ROM::Mapper) { relation(:users) }
+      virt = Class.new(base)
+
+      expect(virt.relation).to be(:users)
+      expect(virt.base_relation).to be(:users)
+    end
+
+    it 'allows overriding' do
+      base = Class.new(ROM::Mapper) { relation(:users) }
+      virt = Class.new(base) { relation(:active) }
+
+      expect(virt.relation).to be(:active)
+      expect(virt.base_relation).to be(:users)
+    end
+  end
+
   describe "#each" do
     it "yields all mapped objects" do
       result = []
 
-      mapper.process(relation).each do |tuple|
+      mapper.call(relation).each do |tuple|
         result << tuple
       end
 

data/spec/unit/rom/{adapter/memory → memory}/dataset_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
+require 'rom/lint/spec'
+require 'rom/memory/dataset'
 
-describe ROM::Adapter::Memory::Dataset do
-  subject(:dataset) do
-    ROM::Adapter::Memory::Dataset.new(data, [:name, :email, :age])
-  end
+describe ROM::Memory::Dataset do
+  subject(:dataset) { described_class.new(data) }
 
   let(:data) do
     [
@@ -13,6 +13,8 @@ describe ROM::Adapter::Memory::Dataset do
     ]
   end
 
+  it_behaves_like "a rom enumerable dataset"
+
   describe '#project' do
     it 'projects tuples with the provided keys' do
       expect(dataset.project(:name, :age)).to match_array([

data/spec/unit/rom/memory/repository_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+require 'rom/lint/spec'
+require 'rom/memory'
+
+describe ROM::Memory::Repository do
+  let(:repository) { ROM::Memory::Repository }
+  let(:uri) { nil }
+
+  it_behaves_like "a rom repository" do
+    let(:identifier) { :memory }
+  end
+end

data/spec/unit/rom/memory/storage_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+require 'rom/memory/storage'
+
+describe ROM::Memory::Storage do
+  describe 'thread safe' do
+    let(:threads) { 4 }
+    let(:operations) { 5000 }
+
+    describe 'data' do
+      it 'create datasets properly' do
+        storage = ROM::Memory::Storage.new
+
+        threaded_operations do |thread, operation|
+          key = "#{thread}:#{operation}"
+          storage.create_dataset(key)
+        end
+
+        expect(storage.size).to eql(threads * operations)
+      end
+    end
+
+    describe 'dataset' do
+      it 'inserts data in proper order' do
+        storage = ROM::Memory::Storage.new
+        dataset = storage.create_dataset(:ary)
+
+        threaded_operations do
+          dataset << :data
+        end
+
+        expect(dataset.size).to eql(threads * operations)
+      end
+    end
+
+    def threaded_operations
+      threads.times.map do |thread|
+        Thread.new do
+          operations.times do |operation|
+            yield thread, operation
+          end
+        end
+      end.each(&:join)
+    end
+  end
+end

data/spec/unit/rom/model_builder_spec.rb

@@ -28,16 +28,17 @@ describe ROM::ModelBuilder do
         builder.call([:name, :email])
 
         expect(Object.const_defined?(:User)).to be(true)
+        Object.send(:remove_const, :User)
       end
 
       it 'defines a constant within a namespace for the model' do
-        module MyApp; module Entities; end; end
+        module Test::MyApp; module Entities; end; end
 
-        builder = ROM::ModelBuilder::PORO.new(name: 'MyApp::Entities::User')
+        builder = ROM::ModelBuilder::PORO.new(name: 'Test::MyApp::Entities::User')
 
         builder.call([:name, :email])
 
-        expect(MyApp::Entities.const_defined?(:User)).to be(true)
+        expect(Test::MyApp::Entities.const_defined?(:User)).to be(true)
         expect(Object.const_defined?(:User)).to be(false)
       end
     end

data/spec/unit/rom/processor/transproc_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'virtus'
 
 describe ROM::Processor::Transproc do
   subject(:transproc) { ROM::Processor::Transproc.build(header) }

data/spec/unit/rom/reader_spec.rb

@@ -10,27 +10,10 @@ describe ROM::Reader do
   let(:mappers) { ROM::MapperRegistry.new(users: mapper) }
   let(:mapper) { double('mapper', header: []) }
 
-  describe '#initialize' do
-    it 'raises error when mapper cannot be found' do
-      expect { ROM::Reader.new(:not_here, relation, mappers) }
-        .to raise_error(ROM::Reader::MapperMissingError, /not_here/)
-    end
-  end
-
-  describe '#each' do
-    it 'yields mapped tuples from relations' do
-      expect(mapper).to receive(:process)
-        .with(relation)
-        .and_yield(jane).and_yield(joe)
-
-      result = []
-      reader.each { |user| result << user }
-      expect(result).to eql([jane, joe])
-    end
-  end
-
   describe '.build' do
-    subject(:reader) { ROM::Reader.build(name, relation, mappers, [:all]) }
+    subject(:reader) do
+      ROM::Reader.build(name, relation, mappers, [:all])
+    end
 
     before do
       relation.instance_exec do
@@ -51,15 +34,17 @@ describe ROM::Reader do
     it 'defines methods from relation' do
       block = proc {}
 
+      user_id = 1
+
       expect(relation).to receive(:all)
-        .with(1, &block)
+        .with(user_id, &block)
         .and_return([joe])
 
-      expect(mapper).to receive(:process)
+      expect(mapper).to receive(:call)
         .with([joe])
-        .and_yield(joe)
+        .and_return([joe])
 
-      result = reader.all(1, &block)
+      result = reader.all(user_id, &block)
 
       expect(result.path).to eql('users.all')
       expect(result.to_a).to eql([joe])
@@ -69,5 +54,93 @@ describe ROM::Reader do
       expect { reader.not_here }
         .to raise_error(ROM::NoRelationError, /not_here/)
     end
+
+    it 'raises error when relation does not respond to the method with args' do
+      expect { reader.find_by_id(1) }
+        .to raise_error(ROM::NoRelationError, /find_by_id/)
+    end
+  end
+
+  describe '#initialize' do
+    it 'raises error when mapper cannot be found' do
+      expect { ROM::Reader.new(:not_here, relation, mappers) }
+        .to raise_error(ROM::MapperMissingError, /not_here/)
+    end
+  end
+
+  describe '#each' do
+    it 'yields mapped tuples from relations' do
+      expect(mapper).to receive(:call)
+        .with(relation)
+        .and_return(relation)
+
+      result = []
+      reader.each { |user| result << user }
+      expect(result).to eql([jane, joe])
+    end
+  end
+
+  shared_examples_for 'one and one!' do |method|
+    context 'with a single tuple' do
+      let(:relation) { [jane] }
+
+      it 'returns a single tuple' do
+        expect(mapper).to receive(:call)
+          .with(relation)
+          .and_return(relation)
+
+        expect(reader.public_send(method)).to eql(jane)
+      end
+    end
+
+    context 'with more than one tuple' do
+      it 'raises an error' do
+        expect { reader.public_send(method) }
+          .to raise_error(ROM::TupleCountMismatchError)
+      end
+    end
+  end
+
+  describe '#one' do
+    it_should_behave_like 'one and one!', :one
+
+    context 'without any tuple' do
+      let(:relation) { [] }
+
+      it 'returns nil' do
+        expect(mapper).to receive(:call)
+          .with(relation)
+          .and_return(relation)
+
+        expect(reader.one).to be_nil
+      end
+    end
+  end
+
+  describe '#one!' do
+    it_should_behave_like 'one and one!', :one!
+
+    context 'without any tuple' do
+      let(:relation) { [] }
+
+      it 'raises an error' do
+        expect(mapper).to receive(:call)
+          .with(relation)
+          .and_return(relation)
+
+        expect { reader.one! }.to raise_error(ROM::TupleCountMismatchError)
+      end
+    end
+  end
+
+  describe '#to_ary' do
+    it 'casts relation to an array with loaded objects' do
+      expect(mapper).to receive(:call)
+        .with(relation)
+        .and_return(relation)
+
+      result = reader.to_ary
+      expect(result).to eql(relation)
+    end
   end
 end

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

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe ROM::Relation::Composite do
+  include_context 'users and tasks'
+
+  let(:users) { rom.relation(:users) }
+
+  let(:name_list) { proc { |r| r.map { |t| t[:name] } } }
+  let(:upcaser) { proc { |r| r.map(&:upcase) } }
+
+  before do
+    setup.relation(:users) do
+      def by_name(name)
+        restrict(name: name)
+      end
+
+      def sorted(other)
+        other.sort_by { |t| t[:name] }
+      end
+    end
+  end
+
+  describe '#call' do
+    it 'sends a relation through mappers' do
+      relation = users >> name_list >> upcaser
+      loaded = relation.call
+
+      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
+      loaded = relation.call
+
+      expect(loaded.source).to eql(users.relation)
+      expect(loaded).to match_array([
+        { name: 'Jane', email: 'jane@doe.org' },
+        { name: 'Joe', email: 'joe@doe.org' }
+      ])
+    end
+  end
+
+  describe '#each' do
+    let(:relation) { users >> name_list >> upcaser }
+
+    it 'calls and iterates' do
+      result = []
+      relation.each { |object| result << object }
+      expect(result).to match_array(%w(JANE JOE))
+    end
+
+    it 'returns enumerator if block is not provided' do
+      expect(relation.each.to_a).to match_array(%w(JANE JOE))
+    end
+  end
+
+  describe '#first' do
+    let(:relation) { users >> name_list >> upcaser }
+
+    it 'calls and returns the first object' do
+      expect(relation.first).to eql('JOE')
+    end
+  end
+end

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

@@ -0,0 +1,145 @@
+require 'spec_helper'
+
+describe ROM::Relation::Lazy do
+  include_context 'users and tasks'
+
+  let(:users) { rom.relations.users.to_lazy }
+  let(:tasks) { rom.relations.tasks.to_lazy }
+
+  before do
+    setup.relation(:users) do
+      def repository
+        :default
+      end
+
+      def by_name(name)
+        restrict(name: name)
+      end
+
+      def by_email(email)
+        restrict(name: email)
+      end
+
+      def by_name_and_email(name, email)
+        by_name(name).by_email(email)
+      end
+
+      def by_name_and_email_sorted(name, email, order_by)
+        by_name_and_email(name, email).order(order_by)
+      end
+
+      def all(*args)
+        if args.any?
+          restrict(*args)
+        else
+          self
+        end
+      end
+    end
+
+    setup.relation(:tasks) do
+      def for_users(users)
+        names = users.map { |u| u[:name] }
+        restrict { |t| names.include?(t[:name]) }
+      end
+    end
+  end
+
+  it_behaves_like 'a relation that returns one tuple' do
+    let(:relation) { users }
+  end
+
+  describe '#method_missing' do
+    it 'forwards to relation and auto-curries' do
+      relation = users.by_name_and_email_sorted('Jane')
+
+      expect(relation.name).to eql(:by_name_and_email_sorted)
+      expect(relation.curry_args).to eql(['Jane'])
+
+      relation = relation['jane@doe.org']
+
+      expect(relation.name).to eql(:by_name_and_email_sorted)
+      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)
+      )
+    end
+
+    it 'forwards to relation and does not auto-curry when it is not needed' do
+      relation = users.by_name('Jane')
+
+      expect(relation).to_not be_curried
+      expect(relation).to match_array(rom.relations.users.by_name('Jane'))
+    end
+
+    it 'forwards to relation and return lazy when arity is unknown' do
+      relation = users.all(name: 'Jane')
+      expect(relation).to_not be_curried
+      expect(relation).to match_array(rom.relations.users.by_name('Jane').to_a)
+    end
+
+    it 'returns original response if it is not a relation' do
+      expect(users.repository).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/)
+    end
+  end
+
+  describe '#call' do
+    it 'auto-curries' do
+      relation = users.by_name
+
+      expect(relation.name).to eql(:by_name)
+      expect(relation['Jane'].to_a).to eql(rom.relations.users.by_name('Jane').to_a)
+    end
+
+    it 'returns relation' do
+      expect(users.call.to_a).to eql(rom.relations.users.to_a)
+    end
+
+    it 'does not allow currying on already curried relation' do
+      expect { users.by_name.by_email }.to raise_error(NoMethodError, /by_email/)
+    end
+
+    describe 'using mappers' do
+      subject(:users) { rom.relations.users.to_lazy(mappers: mappers) }
+
+      let(:name_list) { proc { |r| r.map { |t| t[:name] } } }
+      let(:upcaser) { proc { |r| r.map(&:upcase) } }
+      let(:mappers) { { name_list: name_list, upcaser: upcaser } }
+
+      it 'sends relation through mappers' do
+        relation = users.map_with(:name_list, :upcaser).by_name('Jane')
+
+        expect(relation.call.to_a).to eql(['JANE'])
+      end
+    end
+  end
+
+  describe '#>>' do
+    it 'composes two relations' do
+      other = users.by_name('Jane') >> tasks.for_users
+
+      expect(other).to match_array([
+        { name: 'Jane', title: 'be cool', priority: 2 }
+      ])
+    end
+
+    it_behaves_like 'a relation that returns one tuple' do
+      let(:relation) { rom.relation(:users) >> 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
+
+          expect(relation.one).to eql('JANE')
+          expect(relation.one!).to eql('JANE')
+        end
+      end
+    end
+  end
+end