rom 2.0.2 → 3.0.0

data/spec/shared/enumerable_dataset.rb

@@ -1,4 +1,4 @@
-shared_examples_for "an enumerable dataset" do
+RSpec.shared_examples_for "an enumerable dataset" do
   subject(:dataset) { klass.new(data) }
 
   let(:data) do

data/spec/spec_helper.rb

@@ -1,10 +1,4 @@
-# encoding: utf-8
-
-# this is needed for guard to work, not sure why :(
-require "bundler"
-Bundler.setup
-
-if ENV['COVERAGE'] == 'true' && RUBY_ENGINE == 'ruby' && RUBY_VERSION='2.3.1'
+if ENV['COVERAGE'] == 'true' && RUBY_ENGINE == 'ruby' && RUBY_VERSION == '2.3.1'
   require "simplecov"
   SimpleCov.start do
     add_filter '/spec/'
@@ -13,8 +7,8 @@ end
 
 SPEC_ROOT = root = Pathname(__FILE__).dirname
 
-require 'rom/support/deprecations'
-ROM::Deprecations.set_logger!(SPEC_ROOT.join('../log/deprecations.log'))
+require 'dry/core/deprecations'
+Dry::Core::Deprecations.set_logger!(SPEC_ROOT.join('../log/deprecations.log'))
 
 require 'rom'
 
@@ -42,6 +36,8 @@ def T(*args)
 end
 
 RSpec.configure do |config|
+  config.include(SchemaHelpers)
+
   config.after do
     Test.remove_constants
   end
@@ -49,4 +45,6 @@ RSpec.configure do |config|
   config.around do |example|
     ConstantLeakFinder.find(example)
   end
+
+  config.disable_monkey_patching!
 end

data/spec/support/schema.rb

@@ -0,0 +1,14 @@
+require 'dry-types'
+
+module SchemaHelpers
+  def define_schema(source, attrs)
+    ROM::Schema.define(
+      source,
+      attributes: attrs.map { |name, type| define_type(name, type, source: source) }
+    )
+  end
+
+  def define_type(name, id, **opts)
+    ROM::Types.const_get(id).meta(name: name, **opts)
+  end
+end

data/spec/unit/rom/array_dataset_spec.rb

@@ -0,0 +1,59 @@
+require 'rom/array_dataset'
+
+RSpec.describe ROM::ArrayDataset do
+  let(:klass) do
+    Class.new do
+      include ROM::ArrayDataset
+
+      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' do
+    describe '#flatten' do
+      let(:data) { [[{ 'name' => 'Jane' }], [{ 'name' => 'Joe' }]] }
+
+      it 'returns a new dataset with flattened data' do
+        result = dataset.flatten
+
+        expect(result).to match_array([{ name: 'Jane' }, { name: 'Joe' }])
+      end
+    end
+
+    describe '#map!' do
+      context 'with a block' do
+        it 'returns a new dataset with mapped data' do
+          dataset.map! do |row|
+            row.merge(age: 21)
+          end
+
+          expect(dataset).to match_array([
+            { name: 'Jane', age: 21 }, { name: 'Joe', age: 21 }
+          ])
+        end
+      end
+
+      context 'without a block' do
+        it 'returns an enumerator' do
+          result = dataset.map!
+
+          expect(result).to be_instance_of(Enumerator)
+
+          expect(result).to match_array([
+            { name: 'Jane' }, { name: 'Joe' }
+          ])
+        end
+      end
+    end
+
+    describe '#values_at' do
+      it 'returns a new dataset with rows at given indices' do
+        result = dataset.values_at(1)
+
+        expect(result).to match_array([{ name: 'Joe' }])
+      end
+    end
+  end
+end

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,336 @@
+require 'rom/command'
+require 'rom/memory'
+
+RSpec.describe ROM::Commands::Create[:memory], 'before/after hooks' do
+  let(:relation) do
+    spy(:relation)
+  end
+
+  describe '#before' do
+    subject(:command) do
+      Class.new(ROM::Commands::Create[:memory]) do
+        before :init
+        before :normalize
+
+        def init(*)
+        end
+
+        def normalize(*)
+        end
+
+        def prepare(*)
+        end
+      end.build(relation)
+    end
+
+    it 'returns a new command with configured before hooks' do
+      expect(command.before(:prepare).before_hooks).to eql(%i[init normalize prepare])
+    end
+  end
+
+  describe '#after' do
+    subject(:command) do
+      Class.new(ROM::Commands::Create[:memory]) do
+        after :finalize
+        after :filter
+
+        def finalize(*)
+        end
+
+        def filter(*)
+        end
+
+        def prepare(*)
+        end
+      end.build(relation)
+    end
+
+    it 'returns a new command with configured after hooks' do
+      expect(command.after(:prepare).after_hooks).to eql(%i[finalize filter prepare])
+    end
+  end
+
+  context 'without curried args' do
+    subject(:command) do
+      Class.new(ROM::Commands::Create[:memory]) 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 one curried arg' do
+    subject(:command) do
+      Class.new(ROM::Commands::Create[:memory]) 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 2 curried args' do
+    subject(:command) do
+      Class.new(ROM::Commands::Create[:memory]) 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, 'User').call).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::Commands::Create[:memory]) 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::Commands::Create[:memory]) 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::Commands::Create[:memory]) 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)
 
@@ -162,4 +168,21 @@ describe 'Commands' do
       expect(command.call('foo')).to be(ROM::EMPTY_ARRAY)
     end
   end
+
+  describe '#with_opts' do
+    subject(:command) do
+      Class.new(ROM::Command::Create).build(relation, options)
+    end
+
+    let(:relation) { double(:relation) }
+    let(:options) { { result: :one } }
+
+    it 'returns a new command with updated options' do
+      new_command = command.with_opts(before: :test)
+
+      expect(new_command.relation).to be(relation)
+      expect(new_command.result).to be(:one)
+      expect(new_command.before_hooks).to eql([:test])
+    end
+  end
 end

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)