rom 2.0.2 → 3.0.0.beta1

data/spec/unit/rom/association_set_spec.rb

@@ -7,6 +7,10 @@ RSpec.describe ROM::AssociationSet do
       assoc_set.try(:users, &:done)
 
       expect(assoc).to have_received(:done)
+
+      assoc_set.try(:user, &:done)
+
+      expect(assoc).to have_received(:done)
     end
 
     it 'returns false when assoc is not found' do

data/spec/unit/rom/auto_curry_spec.rb

@@ -0,0 +1,63 @@
+require 'rom/auto_curry'
+
+RSpec.describe ROM::AutoCurry do
+  subject(:object) { klass.new }
+
+  let(:klass) do
+    Class.new do
+      extend ROM::AutoCurry
+
+      def self.curried(*)
+        self
+      end
+
+      def initialize(*)
+      end
+
+      def arity_0
+        0
+      end
+
+      def arity_1(x)
+        x
+      end
+
+      def arity_2(x, y)
+        [x,y]
+      end
+
+      def arity_many(*args)
+        args
+      end
+
+      protected
+
+      def leave_me_alone(foo)
+        foo
+      end
+    end
+  end
+
+  it 'registers auto-curried methods' do
+    expect(object.class.auto_curried_methods).to eql(%i[arity_1 arity_2 arity_many])
+  end
+
+  it 'auto-curries method with arity == 0' do
+    expect(object.arity_0).to be(0)
+  end
+
+  it 'auto-curries method with arity == 1' do
+    expect(object.arity_1).to be_instance_of(klass)
+    expect(object.arity_1(1)).to be(1)
+  end
+
+  it 'auto-curries method with arity > 0' do
+    expect(object.arity_2).to be_instance_of(klass)
+    expect(object.arity_2(1, 2)).to eql([1, 2])
+  end
+
+  it 'auto-curries method with arity < 0' do
+    expect(object.arity_many).to eql([])
+    expect(object.arity_many(1, 2)).to eql([1, 2])
+  end
+end

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'dry-struct'
 
-describe ROM::Commands::Graph do
+RSpec.describe ROM::Commands::Graph do
   shared_examples_for 'a persisted graph' do
     it 'returns nested results' do
       expect(command.call).to match_array([
@@ -75,17 +75,19 @@ describe ROM::Commands::Graph do
     configuration.commands(:tasks) do
       define(:create) do
         result :one
+        before :associate
 
-        def execute(task, user)
-          super(task.merge(user: user[:name]))
+        def associate(task, user)
+          task.merge(user: user[:name])
         end
       end
 
       define(:create) do
         register_as :create_many
+        before :associate
 
-        def execute(tasks, user)
-          super(tasks.map { |t| t.merge(user: user[:name]) })
+        def associate(tasks, user)
+          tasks.map { |t| t.merge(user: user[:name]) }
         end
       end
     end
@@ -93,13 +95,12 @@ describe ROM::Commands::Graph do
     configuration.commands(:tags) do
       define(:create) do
         register_as :create_many
+        before :associate
 
-        def execute(tags, tasks)
-          super(
-            Array([tasks]).flatten.map { |task|
-              tags.map { |tag| tag.merge(task: task[:title]) }
-            }.flatten
-          )
+        def associate(tags, tasks)
+          Array([tasks]).flatten.map { |task|
+            tags.map { |tag| tag.merge(task: task[:title]) }
+          }.flatten
         end
       end
     end

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

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe ROM::Commands::Lazy do
+RSpec.describe ROM::Commands::Lazy do
   include_context 'container'
 
   let(:create_user) { container.command(:users).create }
@@ -56,16 +56,19 @@ describe ROM::Commands::Lazy do
       end
 
       define(:create_many, type: :create) do
-        def execute(tuples, user)
-          super(tuples.map { |tuple| tuple.merge(user: user[:name]) })
+        before :associate
+
+        def associate(tuples, user)
+          tuples.map { |tuple| tuple.merge(user: user[:name]) }
         end
       end
 
       define(:update) do
         result :one
+        before :associate
 
-        def execute(tuple, user)
-          super(tuple.merge(user: user[:name]))
+        def associate(tuple, user)
+          tuple.merge(user: user[:name])
         end
       end
     end

data/spec/unit/rom/commands/pre_and_post_processors_spec.rb

@@ -0,0 +1,269 @@
+require 'rom/command'
+
+RSpec.describe ROM::Command, 'before/after hooks' do
+  let(:relation) do
+    spy(:relation)
+  end
+
+  describe '#before' do
+    subject(:command) do
+      Class.new(ROM::Command) do
+        def prepare(*)
+        end
+      end.build(relation)
+    end
+
+    it 'returns a new command with configured before hooks' do
+      expect(command.before(:prepare).before_hooks).to include(:prepare)
+    end
+  end
+
+  describe '#after' do
+    subject(:command) do
+      Class.new(ROM::Command) do
+        def prepare(*)
+        end
+      end.build(relation)
+    end
+
+    it 'returns a new command with configured after hooks' do
+      expect(command.after(:prepare).after_hooks).to include(:prepare)
+    end
+  end
+
+  context 'without curried args' do
+    subject(:command) do
+      Class.new(ROM::Command) do
+        result :many
+        before :prepare
+        after :finalize
+
+        def execute(tuples)
+          input = tuples.map.with_index { |tuple, idx| tuple.merge(id: idx + 1) }
+          relation.insert(input)
+          input
+        end
+
+        def prepare(tuples)
+          tuples.map { |tuple| tuple.merge(prepared: true) }
+        end
+
+        def finalize(tuples)
+          tuples.map { |tuple| tuple.merge(finalized: true) }
+        end
+      end.build(relation)
+    end
+
+    let(:tuples) do
+      [{ name: 'Jane' }, { name: 'Joe' }]
+    end
+
+    it 'applies before/after hooks' do
+      insert_tuples = [
+        { id: 1, name: 'Jane', prepared: true },
+        { id: 2, name: 'Joe', prepared: true }
+      ]
+
+      result = [
+        { id: 1, name: 'Jane', prepared: true, finalized: true },
+        { id: 2, name: 'Joe', prepared: true, finalized: true }
+      ]
+
+      expect(command.call(tuples)).to eql(result)
+
+      expect(relation).to have_received(:insert).with(insert_tuples)
+    end
+  end
+
+  context 'with curried args' do
+    subject(:command) do
+      Class.new(ROM::Command) do
+        result :many
+        before :prepare
+        after :finalize
+
+        def execute(tuples)
+          input = tuples.map.with_index { |tuple, idx| tuple.merge(id: idx + 1) }
+          relation.insert(input)
+          input
+        end
+
+        def prepare(tuples, name)
+          tuples.map.with_index { |tuple, idx| tuple.merge(name: "#{name} #{idx + 1}") }
+        end
+
+        def finalize(tuples, *)
+          tuples.map { |tuple| tuple.merge(finalized: true) }
+        end
+      end.build(relation)
+    end
+
+    let(:tuples) do
+      [{ email: 'user-1@test.com' }, { email: 'user-2@test.com' }]
+    end
+
+    let(:relation) do
+      spy(:relation)
+    end
+
+    it 'applies before/after hooks' do
+      insert_tuples = [
+        { id: 1, email: 'user-1@test.com', name: 'User 1' },
+        { id: 2, email: 'user-2@test.com', name: 'User 2' }
+      ]
+
+      result = [
+        { id: 1, email: 'user-1@test.com', name: 'User 1', finalized: true },
+        { id: 2, email: 'user-2@test.com', name: 'User 2', finalized: true }
+      ]
+
+      expect(command.with(tuples).call('User')).to eql(result)
+
+      expect(relation).to have_received(:insert).with(insert_tuples)
+    end
+  end
+
+  context 'with pre-set opts' do
+    subject(:command) do
+      Class.new(ROM::Command) do
+        result :many
+        before [prepare: { prepared: true }]
+        after [finalize: { finalized: true }]
+
+        def execute(tuples)
+          input = tuples.map.with_index { |tuple, idx| tuple.merge(id: idx + 1) }
+          relation.insert(input)
+          input
+        end
+
+        def prepare(tuples, opts)
+          tuples.map { |tuple| tuple.merge(opts) }
+        end
+
+        def finalize(tuples, opts)
+          tuples.map { |tuple| tuple.merge(opts) }
+        end
+      end.build(relation)
+    end
+
+    let(:tuples) do
+      [{ name: 'Jane' }, { name: 'Joe' }]
+    end
+
+    let(:relation) do
+      spy(:relation)
+    end
+
+    it 'applies before/after hooks' do
+      insert_tuples = [
+        { id: 1, name: 'Jane', prepared: true },
+        { id: 2, name: 'Joe', prepared: true }
+      ]
+
+      result = [
+        { id: 1, name: 'Jane', prepared: true, finalized: true },
+        { id: 2, name: 'Joe', prepared: true, finalized: true }
+      ]
+
+      expect(command.call(tuples)).to eql(result)
+
+      expect(relation).to have_received(:insert).with(insert_tuples)
+    end
+  end
+
+  context 'with pre-set opts for a curried command' do
+    subject(:command) do
+      Class.new(ROM::Command) do
+        result :many
+        before [prepare: { prepared: true }]
+        after [finalize: { finalized: true }]
+
+        def execute(tuples)
+          input = tuples.map.with_index { |tuple, idx| tuple.merge(id: idx + 1) }
+          relation.insert(input)
+          input
+        end
+
+        def prepare(tuples, parent, opts)
+          tuples.map { |tuple| tuple.merge(opts).merge(parent_size: parent.size) }
+        end
+
+        def finalize(tuples, parent, opts)
+          tuples.map { |tuple| tuple.merge(opts).merge(user_id: parent[:id]) }
+        end
+      end.build(relation)
+    end
+
+    let(:tuples) do
+      [{ name: 'Jane' }, { name: 'Joe' }]
+    end
+
+    let(:relation) do
+      spy(:relation)
+    end
+
+    it 'applies before/after hooks' do
+      insert_tuples = [
+        { id: 1, name: 'Jane', parent_size: 1, prepared: true },
+        { id: 2, name: 'Joe', parent_size: 1, prepared: true }
+      ]
+
+      result = [
+        { id: 1, name: 'Jane', parent_size: 1, user_id: 1, prepared: true, finalized: true },
+        { id: 2, name: 'Joe', parent_size: 1, user_id: 1, prepared: true, finalized: true }
+      ]
+
+      expect(command.with(tuples).call(id: 1)).to eql(result)
+
+      expect(relation).to have_received(:insert).with(insert_tuples)
+    end
+  end
+
+  context 'calling with multiple args' do
+    subject(:command) do
+      Class.new(ROM::Command) do
+        result :many
+        before [prepare: { prepared: true }]
+        after [finalize: { finalized: true }]
+
+        def execute(tuples)
+          input = tuples.map.with_index { |tuple, idx| tuple.merge(id: idx + 1) }
+          relation.insert(input)
+          input
+        end
+
+        def prepare(tuples, parent, opts)
+          tuples.map { |tuple| tuple.merge(opts).merge(parent_size: parent.size) }
+        end
+
+        def finalize(tuples, parent, opts)
+          tuples.map { |tuple| tuple.merge(opts).merge(user_id: parent[:id]) }
+        end
+      end.build(relation)
+    end
+
+    let(:tuples) do
+      [{ name: 'Jane' }, { name: 'Joe' }]
+    end
+
+    let(:relation) do
+      spy(:relation)
+    end
+
+    it 'applies before/after hooks' do
+      insert_tuples = [
+        { id: 1, name: 'Jane', parent_size: 1, prepared: true },
+        { id: 2, name: 'Joe', parent_size: 1, prepared: true }
+      ]
+
+      result = [
+        { id: 1, name: 'Jane', parent_size: 1, user_id: 1, prepared: true, finalized: true },
+        { id: 2, name: 'Joe', parent_size: 1, user_id: 1, prepared: true, finalized: true }
+      ]
+
+      expect(command.call(tuples, id: 1)).to eql(result)
+
+      expect(relation).to have_received(:insert).with(insert_tuples)
+    end
+  end
+end

data/spec/unit/rom/commands/result_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe ROM::Commands::Result do
+RSpec.describe ROM::Commands::Result do
   describe '#value' do
     subject(:result) { ROM::Commands::Result::Success }
 

data/spec/unit/rom/commands_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe 'Commands' do
+RSpec.describe 'Commands' do
   include_context 'gateway only'
   include_context 'users and tasks'
 
@@ -99,8 +99,14 @@ describe 'Commands' do
       }.build(users)
 
       create_task = Class.new(ROM::Commands::Create) {
-        def execute(task_input, user_tuple)
-          relation.insert(task_input.merge(user_id: user_tuple[:user_id]))
+        before :associate
+
+        def associate(task_input, user_tuple)
+          task_input.merge(user_id: user_tuple[:user_id])
+        end
+
+        def execute(task_input)
+          relation.insert(task_input)
         end
       }.build(tasks)
 

data/spec/unit/rom/configuration_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe ROM::Configuration do
+RSpec.describe ROM::Configuration do
   it 'is configurable via settings hash' do
     configuration = ROM::Configuration.new(:memory, 'something', infer_schema: false)
 

data/spec/unit/rom/container_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe ROM::Container do
+RSpec.describe ROM::Container do
   include_context 'container'
   include_context 'users and tasks'
 
@@ -8,16 +8,22 @@ describe ROM::Container do
     configuration
 
     users = Class.new(ROM::Relation[:memory]) do
-      register_as :users
-      dataset :users
+      schema(:users) do
+        attribute :name, ROM::Types::String
+        attribute :email, ROM::Types::String
+      end
+
       def by_name(name)
         restrict(name: name).project(:name)
       end
     end
 
     tasks = Class.new(ROM::Relation[:memory]) do
-      register_as :tasks
-      dataset :tasks
+      schema(:tasks) do
+        attribute :name, ROM::Types::String
+        attribute :title, ROM::Types::String
+        attribute :priority, ROM::Types::Int
+      end
     end
 
     create_user = Class.new(ROM::Commands::Create[:memory]) do

data/spec/unit/rom/create_container_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe ROM::CreateContainer do
+RSpec.describe ROM::CreateContainer do
   describe '#finalize' do
     include_context 'container'
 

data/spec/unit/rom/enumerable_dataset_spec.rb

@@ -0,0 +1,15 @@
+require 'rom/enumerable_dataset'
+
+RSpec.describe ROM::EnumerableDataset do
+  let(:klass) do
+    Class.new do
+      include ROM::EnumerableDataset
+
+      def self.row_proc
+        -> i { i.each_with_object({}) { |(k,v),h| h[k.to_sym] = v } }
+      end
+    end
+  end
+
+  it_behaves_like 'an enumerable dataset'
+end

data/spec/unit/rom/gateway_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe ROM::Gateway do
+RSpec.describe ROM::Gateway do
 
   subject(:gateway) { Class.new(ROM::Gateway).new }
 

data/spec/unit/rom/mapper_registry_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe ROM::MapperRegistry do
+RSpec.describe ROM::MapperRegistry do
   subject(:registry) { ROM::MapperRegistry.new }
 
   let(:user_mapper) { double('user_mapper') }

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'rom/memory'
 
-describe ROM::Memory::Commands do
+RSpec.describe ROM::Memory::Commands do
   let(:relation) do
     Class.new(ROM::Relation[:memory]) do
       schema do

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

@@ -3,7 +3,7 @@ require 'rom/lint/spec'
 
 require 'rom/memory/dataset'
 
-describe ROM::Memory::Dataset do
+RSpec.describe ROM::Memory::Dataset do
   subject(:dataset) { ROM::Memory::Dataset.new(data) }
 
   let(:data) do

data/spec/unit/rom/memory/{repository_spec.rb → gateway_spec.rb}

@@ -2,7 +2,7 @@ require 'spec_helper'
 require 'rom/lint/spec'
 require 'rom/memory'
 
-describe ROM::Memory::Gateway do
+RSpec.describe ROM::Memory::Gateway do
   let(:gateway) { ROM::Memory::Gateway }
   let(:uri) { nil }
 

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

@@ -0,0 +1,32 @@
+require 'rom/memory'
+
+RSpec.describe ROM::Memory::Relation, '.inherited' do
+  subject(:relation) do
+    Class.new(ROM::Relation[:test]) do
+      schema(:users) do
+        attribute :name, ROM::Types::String
+      end
+    end.new([])
+  end
+
+  before do
+    module Test
+      module AnotherAdapter
+        class Relation < ROM::Memory::Relation
+          adapter :test
+        end
+      end
+    end
+
+    ROM.register_adapter(:test, Test::AnotherAdapter)
+  end
+
+  after do
+    ROM.adapters.delete(:test)
+  end
+
+  it 'extends subclass with core methods' do
+    expect(relation.name.to_sym).to be(:users)
+    expect(relation.schema.map(&:name)).to eql(%i[name])
+  end
+end

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

@@ -4,8 +4,16 @@ require 'rom/lint/spec'
 require 'rom/memory/dataset'
 require 'rom/memory/relation'
 
-describe ROM::Memory::Relation do
-  subject(:relation) { ROM::Memory::Relation.new(dataset) }
+RSpec.describe ROM::Memory::Relation do
+  subject(:relation) do
+    Class.new(ROM::Memory::Relation) do
+      schema do
+        attribute :name, ROM::Types::String
+        attribute :email, ROM::Types::String
+        attribute :age, ROM::Types::Int
+      end
+    end.new(dataset) 
+  end
 
   let(:dataset) do
     ROM::Memory::Dataset.new([
@@ -30,7 +38,11 @@ describe ROM::Memory::Relation do
 
   describe '#project' do
     it 'projects tuples with the provided keys' do
-      expect(relation.project(:name, :age)).to match_array([
+      projected = relation.project(:name, :age)
+
+      expect(projected.schema).to eql(relation.schema.project(:name, :age))
+
+      expect(projected).to match_array([
         { name: 'Jane', age: 10 },
         { name: 'Jade', age: 11 },
         { name: 'Joe',  age: 12 },

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'rom/memory/storage'
 
-describe ROM::Memory::Storage do
+RSpec.describe ROM::Memory::Storage do
   describe 'thread safe' do
     let(:threads) { 4 }
     let(:operations) { 5000 }

data/spec/unit/rom/plugin_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe "ROM::PluginRegistry" do
+RSpec.describe "ROM::PluginRegistry" do
   include_context 'container'
 
   before do

data/spec/unit/rom/plugins/relation/key_inference_spec.rb

@@ -58,7 +58,7 @@ RSpec.describe ROM::Plugins::Relation::KeyInference do
         use :key_inference
 
         schema :posts do
-          attribute :author_id, ROM::Types::Int.meta(foreign_key: true, relation: :users)
+          attribute :author_id, ROM::Types::Int.meta(foreign_key: true, target: :users)
         end
       end
     end