rom 0.9.1 → 1.0.0.beta1

data/spec/test/memory_repository_lint_test.rb

@@ -21,7 +21,7 @@ class MemoryDatasetLintTest < Minitest::Test
   include ROM::Lint::TestEnumerableDataset
 
   def setup
-    @data  = [{ name: 'Jane', age: 24 }, { name: 'Joe', age: 25 }]
+    @data = [{ name: 'Jane', age: 24 }, { name: 'Joe', age: 25 }]
     @dataset = ROM::Memory::Dataset.new(@data)
   end
 end

data/spec/unit/rom/auto_registration_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'rom/setup/auto_registration'
+
+RSpec.describe ROM::Setup, '#auto_registration' do
+  let(:setup) { ROM::Setup.new }
+
+  context 'with namespace turned on' do
+    before do
+      setup.auto_registration(SPEC_ROOT.join('fixtures/lib/persistence'))
+    end
+
+    describe '#relations' do
+      it 'loads files and returns constants' do
+        expect(setup.relation_classes).to eql([Persistence::Relations::Users])
+      end
+    end
+
+    describe '#commands' do
+      it 'loads files and returns constants' do
+        expect(setup.command_classes).to eql([Persistence::Commands::CreateUser])
+      end
+    end
+
+    describe '#mappers' do
+      it 'loads files and returns constants' do
+        expect(setup.mapper_classes).to eql([Persistence::Mappers::UserList])
+      end
+    end
+  end
+
+  context 'with namespace turned off' do
+    before do
+      setup.auto_registration(SPEC_ROOT.join('fixtures/app'), namespace: false)
+    end
+
+    describe '#relations' do
+      it 'loads files and returns constants' do
+        expect(setup.relation_classes).to eql([Users])
+      end
+    end
+
+    describe '#commands' do
+      it 'loads files and returns constants' do
+        expect(setup.command_classes).to eql([CreateUser])
+      end
+    end
+
+    describe '#mappers' do
+      it 'loads files and returns constants' do
+        expect(setup.mapper_classes).to eql([UserList])
+      end
+    end
+  end
+end

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

@@ -6,7 +6,7 @@ describe ROM::Commands::Graph do
       expect(command.call).to match_array([
         # parent users
         [
-          { name: 'Jane' },
+          { name: 'Jane' }
         ],
         [
           [
@@ -31,15 +31,15 @@ describe ROM::Commands::Graph do
       before { command.call }
 
       it 'inserts root' do
-        expect(rom.relation(:users)).to match_array([{ name: 'Jane' }])
+        expect(container.relation(:users)).to match_array([{ name: 'Jane' }])
       end
 
       it 'inserts root nodes' do
-        expect(rom.relation(:tasks)).to match_array([{ user: 'Jane', title: 'One' }])
+        expect(container.relation(:tasks)).to match_array([{ user: 'Jane', title: 'One' }])
       end
 
       it 'inserts nested graph nodes' do
-        expect(rom.relation(:tags)).to match_array([
+        expect(container.relation(:tags)).to match_array([
           { name: 'red', task: 'One' },
           { name: 'green', task: 'One' },
           { name: 'blue', task: 'One' }
@@ -48,31 +48,30 @@ describe ROM::Commands::Graph do
     end
   end
 
-  let(:rom) { setup.finalize }
-  let(:setup) { ROM.setup(:memory) }
+  include_context 'container'
 
-  let(:create_user) { rom.command(:users).create }
-  let(:create_task) { rom.command(:tasks).create }
+  let(:create_user) { container.command(:users).create }
+  let(:create_task) { container.command(:tasks).create }
 
-  let(:create_many_tasks) { rom.command(:tasks).create_many }
-  let(:create_many_tags) { rom.command(:tags).create_many }
+  let(:create_many_tasks) { container.command(:tasks).create_many }
+  let(:create_many_tags) { container.command(:tags).create_many }
 
   let(:user) { { name: 'Jane' } }
   let(:task) { { title: 'One' } }
   let(:tags) { [{ name: 'red' }, { name: 'green' }, { name: 'blue' }] }
 
   before do
-    setup.relation(:users)
-    setup.relation(:tasks)
-    setup.relation(:tags)
+    configuration.relation(:users)
+    configuration.relation(:tasks)
+    configuration.relation(:tags)
 
-    setup.commands(:users) do
+    configuration.commands(:users) do
       define(:create) do
         result :one
       end
     end
 
-    setup.commands(:tasks) do
+    configuration.commands(:tasks) do
       define(:create) do
         result :one
 
@@ -90,7 +89,7 @@ describe ROM::Commands::Graph do
       end
     end
 
-    setup.commands(:tags) do
+    configuration.commands(:tags) do
       define(:create) do
         register_as :create_many
 
@@ -125,37 +124,11 @@ describe ROM::Commands::Graph do
         end
       end
     end
-
-    context 'when error is raised' do
-      subject(:command) do
-        create_user.with(user).combine(create_many_tasks.with([task]))
-      end
-
-      it 're-raises the error providing proper context when root fails' do
-        allow(command.root).to receive(:call).and_raise(StandardError, 'ooops')
-
-        expect { command.call }.to raise_error(ROM::CommandFailure, /oops/)
-      end
-
-      it 're-raises the error providing proper context when a node fails' do
-        allow(command.nodes[0]).to receive(:call).and_raise(StandardError, 'ooops')
-
-        expect { command.call }.to raise_error(ROM::CommandFailure, /oops/)
-
-        begin
-          command.call
-        rescue ROM::CommandFailure => e
-          expect(e.original_error).to be_a(ROM::CommandFailure)
-          expect(e.original_error.message).to include('ooops')
-          expect(e.backtrace).to eql(e.original_error.backtrace)
-        end
-      end
-    end
   end
 
   describe 'pipeline' do
     subject(:command) do
-      rom.command(:users).as(:entity).create.with(user)
+      container.command(:users).as(:entity).create.with(user)
         .combine(create_task.with(task)
         .combine(create_many_tags.with(tags)))
     end
@@ -185,6 +158,7 @@ describe ROM::Commands::Graph do
           end
         end
       end
+      configuration.register_mapper(Test::UserMapper)
     end
 
     it 'sends data through the pipeline' do
@@ -196,7 +170,7 @@ describe ROM::Commands::Graph do
             tags: [
               Test::Tag.new(name: 'red'),
               Test::Tag.new(name: 'green'),
-              Test::Tag.new(name: 'blue'),
+              Test::Tag.new(name: 'blue')
             ]
           )
         )

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

@@ -1,52 +1,275 @@
 require 'spec_helper'
 
 describe ROM::Commands::Lazy do
-  let(:rom) { setup.finalize }
-  let(:setup) { ROM.setup(:memory) }
+  include_context 'container'
 
-  let(:create_user) { rom.command(:users).create }
-  let(:update_user) { rom.command(:users).update }
-  let(:create_task) { rom.command(:tasks).create }
+  let(:create_user) { container.command(:users).create }
+  let(:update_user) { container.command(:users).update }
+  let(:delete_user) { container.command(:users).delete }
 
-  let(:user) { { user: { name: 'Jane' } } }
+  let(:create_task) { container.command(:tasks).create }
+  let(:create_tasks) { container.command(:tasks).create_many }
+  let(:update_task) { container.command(:tasks).update }
+
+  let(:input) { { user: { name: 'Jane', email: 'jane@doe.org' } } }
+  let(:jane) { input[:user] }
   let(:evaluator) { -> input { input[:user] } }
 
   before do
-    setup.relation(:tasks)
+    configuration.relation(:tasks) do
+      def by_user_and_title(user, title)
+        by_user(user).by_title(title)
+      end
+
+      def by_user(user)
+        restrict(user: user)
+      end
 
-    setup.relation(:users) do
+      def by_title(title)
+        restrict(title: title)
+      end
+    end
+
+    configuration.relation(:users) do
       def by_name(name)
         restrict(name: name)
       end
     end
 
-    setup.commands(:users) do
+    configuration.commands(:users) do
       define(:create) do
         result :one
       end
 
-      define(:update)
+      define(:update) do
+        result :one
+      end
+
+      define(:delete) do
+        result :one
+      end
     end
 
-    setup.commands(:tasks) do
-      define(:create)
+    configuration.commands(:tasks) do
+      define(:create) do
+        result :one
+      end
+
+      define(:create_many, type: :create) do
+        def execute(tuples, user)
+          super(tuples.map { |tuple| tuple.merge(user: user[:name]) })
+        end
+      end
+
+      define(:update) do
+        result :one
+
+        def execute(tuple, user)
+          super(tuple.merge(user: user[:name]))
+        end
+      end
     end
   end
 
   describe '#call' do
-    subject(:command) { ROM::Commands::Lazy.new(create_user, evaluator) }
+    context 'with a create command' do
+      subject(:command) { ROM::Commands::Lazy[create_user].new(create_user, evaluator) }
+
+      it 'evaluates the input and calls command' do
+        command.call(input)
+
+        expect(container.relation(:users)).to match_array([jane])
+      end
+    end
+
+    context 'with a create command for many child tuples' do
+      subject(:command) do
+        ROM::Commands::Lazy[create_tasks].new(create_tasks, evaluator)
+      end
+
+      let(:evaluator) { -> input, index { input[:users][index][:tasks] } }
+
+      let(:input) do
+        { users: [
+          {
+            name: 'Jane',
+            tasks: [{ title: 'Jane Task One' }, { title: 'Jane Task Two' }]
+          },
+          {
+            name: 'Joe',
+            tasks: [{ title: 'Joe Task One' }]
+          }
+        ]}
+      end
+
+      it 'evaluates the input and calls command' do
+        command.call(input, input[:users])
+
+        expect(container.relation(:tasks)).to match_array([
+          { user: 'Jane', title: 'Jane Task One' },
+          { user: 'Jane', title: 'Jane Task Two' },
+          { user: 'Joe', title: 'Joe Task One' }
+        ])
+      end
+    end
+
+    context 'with an update command' do
+      subject(:command) do
+        ROM::Commands::Lazy[update_user].new(
+          update_user, evaluator, -> cmd, user { cmd.by_name(user[:name]) })
+      end
+
+      before do
+        create_user[jane]
+      end
+
+      it 'evaluates the input, restricts the relation and calls its command' do
+        input = { user: { name: 'Jane', email: 'jane.doe@rom-rb.org' } }
+        command.call(input)
+
+        expect(container.relation(:users)).to match_array([input[:user]])
+      end
+    end
+
+    context 'with an update command for a child tuple' do
+      subject(:command) do
+        ROM::Commands::Lazy[update_task].new(
+          update_task,
+          evaluator,
+          -> cmd, user, task { cmd.by_user(user[:name]).by_title(task[:title]) }
+        )
+      end
 
-    it 'evaluates the input and calls command' do
-      command.call(user)
+      let(:evaluator) { -> input { input[:user][:task] } }
 
-      expect(rom.relation(:users)).to match_array([
-        { name: 'Jane' }
-      ])
+      let(:jane) { { name: 'Jane' } }
+      let(:jane_task) { { user: 'Jane', title: 'Jane Task', priority: 1 } }
+
+      let(:input) { { user: jane.merge(task: jane_task) } }
+
+      before do
+        create_user[jane]
+        create_task[user: 'Jane', title: 'Jane Task', priority: 2]
+      end
+
+      it 'evaluates the input, restricts the relation and calls its command' do
+        command.call(input, input[:user])
+
+        expect(container.relation(:users)).to match_array([jane])
+
+        expect(container.relation(:tasks)).to match_array([jane_task])
+      end
+    end
+
+    context 'with an update command for child tuples' do
+      subject(:command) do
+        ROM::Commands::Lazy[update_task].new(
+          update_task,
+          evaluator,
+          -> cmd, user, task { cmd.by_user(user[:name]).by_title(task[:title]) }
+        )
+      end
+
+      let(:evaluator) { -> input { input[:user][:tasks] } }
+
+      let(:jane) { { name: 'Jane' } }
+      let(:jane_tasks) {
+        [
+          { user: 'Jane', title: 'Jane Task One', priority: 2 },
+          { user: 'Jane', title: 'Jane Task Two', priority: 3 }
+        ]
+      }
+
+      let(:input) { { user: jane.merge(tasks: jane_tasks) } }
+
+      before do
+        create_user[jane]
+        create_task[user: 'Jane', title: 'Jane Task One', priority: 3]
+        create_task[user: 'Jane', title: 'Jane Task Two', priority: 4]
+      end
+
+      it 'evaluates the input, restricts the relation and calls its command' do
+        command.call(input, input[:user])
+
+        expect(container.relation(:users)).to match_array([jane])
+
+        expect(container.relation(:tasks)).to match_array(jane_tasks)
+      end
+    end
+
+    context 'with an update command for many parents and their children' do
+      subject(:command) do
+        ROM::Commands::Lazy[update_task].new(
+          update_task,
+          evaluator,
+          -> cmd, user, task { cmd.by_user(user[:name]).by_title(task[:title]) }
+        )
+      end
+
+      let(:evaluator) { -> input, index { input[:users][index][:tasks] } }
+
+      let(:input) do
+        { users: [
+          {
+            name: 'Jane',
+            tasks: [
+              { title: 'Jane Task One', priority: 1 },
+              { title: 'Jane Task Two', priority: 2 }
+            ]
+          },
+          {
+            name: 'Joe',
+            tasks: [{ title: 'Joe Task One', priority: 1 }]
+          }
+        ]}
+      end
+
+      before do
+        create_user[name: 'Jane']
+        create_user[name: 'Joe']
+
+        create_task[user: 'Jane', title: 'Jane Task One']
+        create_task[user: 'Jane', title: 'Jane Task Two']
+        create_task[user: 'Joe', title: 'Joe Task One']
+      end
+
+      it 'evaluates the input and calls its command' do
+        command.call(input, input[:users])
+
+        expect(container.relation(:tasks)).to match_array([
+          { user: 'Jane', title: 'Jane Task One', priority: 1 },
+          { user: 'Jane', title: 'Jane Task Two', priority: 2 },
+          { user: 'Joe', title: 'Joe Task One', priority: 1 }
+        ])
+      end
+    end
+
+    context 'with a delete command' do
+      subject(:command) do
+        ROM::Commands::Lazy[delete_user].new(
+          delete_user,
+          evaluator,
+          -> cmd, user { cmd.by_name(user[:name]) }
+        )
+      end
+
+      let(:joe) { { name: 'Joe' } }
+
+      before do
+        create_user[jane]
+        create_user[joe]
+      end
+
+      it 'restricts the relation and calls its command' do
+        command.call(input)
+
+        expect(container.relation(:users)).to match_array([joe])
+      end
     end
   end
 
   describe '#>>' do
-    subject(:command) { ROM::Commands::Lazy.new(create_user, evaluator) }
+    subject(:command) { ROM::Commands::Lazy[create_user].new(create_user, evaluator) }
 
     it 'composes with another command' do
       expect(command >> create_task).to be_instance_of(ROM::Commands::Composite)
@@ -54,7 +277,7 @@ describe ROM::Commands::Lazy do
   end
 
   describe '#combine' do
-    subject(:command) { ROM::Commands::Lazy.new(create_user, evaluator) }
+    subject(:command) { ROM::Commands::Lazy[create_user].new(create_user, evaluator) }
 
     it 'combines with another command' do
       expect(command.combine(create_task)).to be_instance_of(ROM::Commands::Graph)
@@ -62,23 +285,11 @@ describe ROM::Commands::Lazy do
   end
 
   describe '#method_missing' do
-    subject(:command) { ROM::Commands::Lazy.new(update_user, evaluator) }
-
-    it 'forwards to command' do
-      rom.relations[:users] << { name: 'Jane' } << { name: 'Joe' }
-
-      new_command = command.by_name('Jane')
-      new_command.call(user: { name: 'Jane Doe' })
-
-      expect(rom.relation(:users)).to match_array([
-        { name: 'Jane Doe' },
-        { name: 'Joe' }
-      ])
-    end
+    subject(:command) { ROM::Commands::Lazy[update_user].new(update_user, evaluator) }
 
-    it 'return original response if it was not a command' do
+    it 'returns original response if it was not a command' do
       response = command.result
-      expect(response).to be(:many)
+      expect(response).to be(:one)
     end
 
     it 'raises error when message is unknown' do