rom 0.6.2 → 0.7.0

data/spec/spec_helper.rb

@@ -19,8 +19,12 @@ end
 
 root = Pathname(__FILE__).dirname
 
-Dir[root.join('support/*.rb').to_s].each { |f| require f }
-Dir[root.join('shared/*.rb').to_s].each { |f| require f }
+Dir[root.join('support/*.rb').to_s].each do |f|
+  require f
+end
+Dir[root.join('shared/*.rb').to_s].each do |f|
+  require f
+end
 
 # Namespace holding all objects created during specs
 module Test

data/spec/support/mutant.rb

@@ -1,7 +1,10 @@
 module Mutant
-  class Subject
-    def tests
-      config.integration.all_tests
-    end
-  end
-end
+  class Selector
+    # Expression based test selector
+    class Expression < self
+      def call(subject)
+        integration.all_tests
+      end
+    end # Expression
+  end # Selector
+end # Mutant

data/spec/unit/rom/commands_spec.rb

@@ -15,11 +15,11 @@ describe 'Commands' do
 
   describe '.build_class' do
     it 'creates a command class constant' do
-      klass = ROM::Command.build_class(:create, :users, adapter: :memory) do
+      klass = ROM::Command.build_class(:create, :users, adapter: :memory) {
         def super?
           true
         end
-      end
+      }
 
       expect(klass.name).to eql('ROM::Memory::Commands::Create[Users]')
       expect(klass.register_as).to eql(:create)
@@ -135,7 +135,7 @@ describe 'Commands' do
       }.build(users)
 
       create_task = Class.new(ROM::Commands::Create) {
-        def execute(user_tuple, task_input)
+        def execute(task_input, user_tuple)
           relation.insert(task_input.merge(user_id: user_tuple[:user_id]))
         end
       }.build(tasks)

data/spec/unit/rom/header_spec.rb

@@ -33,7 +33,7 @@ describe ROM::Header do
 
         expect(tasks.type).to be(:array)
         expect(tasks.header.model).to be(model)
-        expect(tasks.header).to eql(ROM::Header.coerce([[:title]], model))
+        expect(tasks.header).to eql(ROM::Header.coerce([[:title]], model: model))
 
         expect(input.first[1])
           .to eql(header: [[:title]], type: :array, model: model)
@@ -55,7 +55,7 @@ describe ROM::Header do
 
         expect(tasks.type).to be(:hash)
         expect(tasks.header.model).to be(model)
-        expect(tasks.header).to eql(ROM::Header.coerce([[:title]], model))
+        expect(tasks.header).to eql(ROM::Header.coerce([[:title]], model: model))
 
         expect(input.first[1])
           .to eql(header: [[:title]], type: :hash, model: model)

data/spec/unit/rom/mapper/dsl_spec.rb

@@ -3,7 +3,9 @@ require 'spec_helper'
 describe ROM::Mapper do
   subject(:mapper) do
     klass = Class.new(parent)
-    options.each { |k, v| klass.send(k, v) }
+    options.each do |k, v|
+      klass.send(k, v)
+    end
     klass
   end
 
@@ -69,6 +71,18 @@ describe ROM::Mapper do
     end
   end
 
+  describe 'reject_keys' do
+    let(:attributes) { [[:name, type: :string]] }
+    let(:options) { { reject_keys: true } }
+
+    it 'sets rejected_keys for the header' do
+      mapper.reject_keys true
+      mapper.attribute :name, type: :string
+
+      expect(header).to eql(expected_header)
+    end
+  end
+
   describe 'overriding inherited attributes' do
     context 'when name matches' do
       let(:attributes) { [[:name, type: :string]] }
@@ -322,4 +336,91 @@ describe ROM::Mapper do
       end
     end
   end
+
+  context 'reusing mappers' do
+    describe '#group' do
+      let(:task_mapper) do
+        Class.new(ROM::Mapper) { attribute :title }
+      end
+
+      let(:attributes) do
+        [
+          [:name],
+          [:tasks, type: :array, group: true, header: task_mapper.header]
+        ]
+      end
+
+      it 'uses other mapper header' do
+        mapper.attribute :name
+        mapper.group :tasks, mapper: task_mapper
+
+        expect(header).to eql(expected_header)
+      end
+    end
+
+    describe '#wrap' do
+      let(:task_mapper) do
+        Class.new(ROM::Mapper) { attribute :title }
+      end
+
+      let(:attributes) do
+        [
+          [:name],
+          [:task, type: :hash, wrap: true, header: task_mapper.header]
+        ]
+      end
+
+      it 'uses other mapper header' do
+        mapper.attribute :name
+        mapper.wrap :task, mapper: task_mapper
+
+        expect(header).to eql(expected_header)
+      end
+    end
+
+    describe '#embedded' do
+      let(:task_mapper) do
+        Class.new(ROM::Mapper) { attribute :title }
+      end
+
+      let(:attributes) do
+        [
+          [:name],
+          [:task, type: :array, header: task_mapper.header]
+        ]
+      end
+
+      it 'uses other mapper header' do
+        mapper.attribute :name
+        mapper.embedded :task, mapper: task_mapper, type: :hash
+
+        expect(header).to eql(expected_header)
+      end
+    end
+  end
+
+  describe '#combine' do
+    let(:attributes) do
+      [
+        [:title],
+        [:tasks, combine: true, type: :array, header: [[:title]]]
+      ]
+    end
+
+    it 'adds combine attributes' do
+      mapper.attribute :title
+
+      mapper.combine :tasks, on: { title: :title } do
+        attribute :title
+      end
+
+      expect(header).to eql(expected_header)
+    end
+  end
+
+  describe '#method_missing' do
+    it 'responds to DSL methods' do
+      expect(mapper).to respond_to(:attribute)
+    end
+  end
 end

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

@@ -1,9 +1,10 @@
 require 'spec_helper'
 require 'rom/lint/spec'
+
 require 'rom/memory/dataset'
 
 describe ROM::Memory::Dataset do
-  subject(:dataset) { described_class.new(data) }
+  subject(:dataset) { ROM::Memory::Dataset.new(data) }
 
   let(:data) do
     [
@@ -15,40 +16,16 @@ describe ROM::Memory::Dataset do
 
   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([
-        { name: 'Jane', age: 10 },
-        { name: 'Jade', age: 11 },
-        { name: 'Joe', age: 12 }
-      ])
-    end
-  end
-
-  describe '#restrict' do
-    it 'restricts data using criteria hash' do
-      expect(dataset.restrict(age: 10)).to match_array([
-        { name: 'Jane', email: 'jane@doe.org', age: 10 }
-      ])
+  describe 'subclassing' do
+    it 'supports options' do
+      descendant = Class.new(ROM::Memory::Dataset) do
+        option :path, reader: true
+      end
 
-      expect(dataset.restrict(age: 10.0)).to match_array([])
-    end
-
-    it 'restricts data using block' do
-      expect(dataset.restrict { |tuple| tuple[:age] > 10 }).to match_array([
-        { name: 'Jade', email: 'jade@doe.org', age: 11 },
-        { name: 'Joe', email: 'joe@doe.org', age: 12 }
-      ])
-    end
-  end
+      dataset = descendant.new([1, 2, 3], path: '/data')
 
-  describe '#order' do
-    it 'sorts data using provided attribute names' do
-      expect(dataset.order(:name)).to match_array([
-        { name: 'Jade', email: 'jade@doe.org', age: 11 },
-        { name: 'Jane', email: 'jane@doe.org', age: 10 },
-        { name: 'Joe', email: 'joe@doe.org', age: 12 }
-      ])
+      expect(dataset.to_a).to eql([1, 2, 3])
+      expect(dataset.path).to eql('/data')
     end
   end
 end

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

@@ -0,0 +1,63 @@
+require 'spec_helper'
+require 'rom/lint/spec'
+
+require 'rom/memory/dataset'
+require 'rom/memory/relation'
+
+describe ROM::Memory::Relation do
+  subject(:relation) { ROM::Memory::Relation.new(dataset) }
+
+  let(:dataset) do
+    ROM::Memory::Dataset.new([
+      { name: 'Jane', email: 'jane@doe.org', age: 10 },
+      { name: 'Jade', email: 'jade@doe.org', age: 11 },
+      { name: 'Joe', email: 'joe@doe.org', age: 12 }
+    ])
+  end
+
+  describe '#take' do
+    it 'takes given number of tuples' do
+      expect(relation.take(2)).to match_array([
+        { name: 'Jane', email: 'jane@doe.org', age: 10 },
+        { name: 'Jade', email: 'jade@doe.org', age: 11 }
+      ])
+    end
+  end
+
+  describe '#project' do
+    it 'projects tuples with the provided keys' do
+      expect(relation.project(:name, :age)).to match_array([
+        { name: 'Jane', age: 10 },
+        { name: 'Jade', age: 11 },
+        { name: 'Joe', age: 12 }
+      ])
+    end
+  end
+
+  describe '#restrict' do
+    it 'restricts data using criteria hash' do
+      expect(relation.restrict(age: 10)).to match_array([
+        { name: 'Jane', email: 'jane@doe.org', age: 10 }
+      ])
+
+      expect(relation.restrict(age: 10.0)).to match_array([])
+    end
+
+    it 'restricts data using block' do
+      expect(relation.restrict { |tuple| tuple[:age] > 10 }).to match_array([
+        { name: 'Jade', email: 'jade@doe.org', age: 11 },
+        { name: 'Joe', email: 'joe@doe.org', age: 12 }
+      ])
+    end
+  end
+
+  describe '#order' do
+    it 'sorts data using provided attribute names' do
+      expect(relation.order(:name).to_a).to eq([
+        { name: 'Jade', email: 'jade@doe.org', age: 11 },
+        { name: 'Jane', email: 'jane@doe.org', age: 10 },
+        { name: 'Joe', email: 'joe@doe.org', age: 12 }
+      ])
+    end
+  end
+end

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

@@ -33,13 +33,13 @@ describe ROM::Memory::Storage do
     end
 
     def threaded_operations
-      threads.times.map do |thread|
+      threads.times.map { |thread|
         Thread.new do
           operations.times do |operation|
             yield thread, operation
           end
         end
-      end.each(&:join)
+      }.each(&:join)
     end
   end
 end

data/spec/unit/rom/plugin_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+describe "ROM::PluginRegistry" do
+  subject(:env) { setup.finalize }
+
+  let(:setup) { ROM.setup(:memory) }
+
+  before do
+    Test::CommandPlugin   = Module.new
+    Test::MapperPlugin    = Module.new
+    Test::RelationPlugin  = Module.new do
+      def self.included(mod)
+        mod.exposed_relations << :plugged_in
+      end
+
+      def plugged_in
+        "a relation"
+      end
+    end
+
+    ROM.plugins do
+      register :publisher,  Test::CommandPlugin,  type: :command
+      register :pager,      Test::RelationPlugin, type: :relation
+      register :translater, Test::MapperPlugin,   type: :mapper
+    end
+  end
+
+  around do |example|
+    orig_plugins = ROM.plugin_registry
+    example.run
+    ROM.instance_variable_set('@plugin_registry', orig_plugins)
+  end
+
+  it "includes relation plugins" do
+    setup.relation(:users) do
+      use :pager
+    end
+
+    expect(env.relation(:users).plugged_in).to eq "a relation"
+  end
+
+  it "makes command plugins available" do
+    setup.relation(:users)
+
+    Class.new(ROM::Commands::Create[:memory]) do
+      relation :users
+      register_as :create
+      use :publisher
+    end
+
+    expect(env.command(:users).create).to be_kind_of Test::CommandPlugin
+  end
+
+  it "inclues plugins in mappers" do
+    setup.relation(:users)
+
+    Class.new(ROM::Mapper) do
+      relation :users
+      register_as :translator
+      use :translater
+    end
+
+    expect(env.mappers[:users][:translator]).to be_kind_of Test::MapperPlugin
+  end
+
+  it "restricts plugins to defined type" do
+    expect {
+      setup.relation(:users) do
+        use :publisher
+      end
+    }.to raise_error ROM::UnknownPluginError
+  end
+
+  it "allows definition of adapter restricted plugins" do
+    Test::LazyPlugin = Module.new do
+      def self.included(mod)
+        mod.exposed_relations << :lazy?
+      end
+
+      def lazy?
+        true
+      end
+    end
+
+    ROM.plugins do
+      adapter :memory do
+        register :lazy, Test::LazyPlugin, type: :relation
+      end
+    end
+
+    setup.relation(:users) do
+      use :lazy, adapter: :memory
+    end
+
+    expect(env.relation(:users)).to be_lazy
+  end
+
+  it "respects adapter restrictions" do
+    Test::LazyPlugin = Module.new
+    Test::LazySQLPlugin = Module.new
+
+    ROM.plugins do
+      register :lazy, Test::LazyPlugin, type: :command
+
+      adapter :sql do
+        register :lazy, Test::LazySQLPlugin, type: :command
+      end
+    end
+
+    setup.relation(:users)
+
+    Class.new(ROM::Commands::Create[:memory]) do
+      relation :users
+      register_as :create
+      use :lazy, adapter: :memory
+    end
+
+    expect(env.command(:users).create).not_to be_kind_of Test::LazySQLPlugin
+    expect(env.command(:users).create).to be_kind_of Test::LazyPlugin
+  end
+end