rom 0.7.1 → 0.8.0

data/spec/integration/mappers/ungroup_spec.rb

@@ -0,0 +1,127 @@
+require 'spec_helper'
+require 'rom/memory'
+
+describe 'Mapper definition DSL' do
+  let(:setup) { ROM.setup(:memory) }
+  let(:rom)   { ROM.finalize.env   }
+
+  before do
+    setup.relation(:users)
+
+    users = setup.default.dataset(:users)
+    users.insert(name: 'Joe', emails: [
+      { address: 'joe@home.org', type: 'home' },
+      { address: 'joe@job.com',  type: 'job'  },
+      { address: 'joe@doe.com',  type: 'job'  },
+      { address: 'joe@thor.org'               },
+      {                          type: 'home' },
+      {}
+    ])
+    users.insert(name: 'Jane')
+  end
+
+  describe 'ungroup' do
+    subject(:mapped_users) { rom.relation(:users).as(:users).to_a }
+
+    it 'partially ungroups attributes' do
+      setup.mappers do
+        define(:users) { ungroup emails: [:type] }
+      end
+
+      expect(mapped_users).to eql [
+        {
+          name: 'Joe', type: 'home',
+          emails: [{ address: 'joe@home.org' }, { address: nil }]
+        },
+        {
+          name: 'Joe', type: 'job',
+          emails: [{ address: 'joe@job.com' }, { address: 'joe@doe.com' }]
+        },
+        {
+          name: 'Joe', type: nil,
+          emails: [{ address: 'joe@thor.org' }, { address: nil }]
+        },
+        { name: 'Jane' }
+      ]
+    end
+
+    it 'removes group when all attributes extracted' do
+      setup.mappers do
+        define(:users) { ungroup emails: [:address, :type, :foo] }
+      end
+
+      expect(mapped_users).to eql [
+        { name: 'Joe',  address: 'joe@home.org', type: 'home' },
+        { name: 'Joe',  address: 'joe@job.com',  type: 'job'  },
+        { name: 'Joe',  address: 'joe@doe.com',  type: 'job'  },
+        { name: 'Joe',  address: 'joe@thor.org', type: nil    },
+        { name: 'Joe',  address: nil,            type: 'home' },
+        { name: 'Joe',  address: nil,            type: nil    },
+        { name: 'Jane'                                        }
+      ]
+    end
+
+    it 'accepts block syntax' do
+      setup.mappers do
+        define(:users) do
+          ungroup :emails do
+            attribute :address
+            attribute :type
+          end
+        end
+      end
+
+      expect(mapped_users).to eql [
+        { name: 'Joe',  address: 'joe@home.org', type: 'home' },
+        { name: 'Joe',  address: 'joe@job.com',  type: 'job'  },
+        { name: 'Joe',  address: 'joe@doe.com',  type: 'job'  },
+        { name: 'Joe',  address: 'joe@thor.org', type: nil    },
+        { name: 'Joe',  address: nil,            type: 'home' },
+        { name: 'Joe',  address: nil,            type: nil    },
+        { name: 'Jane'                                        }
+      ]
+    end
+
+    it 'renames ungrouped attributes' do
+      setup.mappers do
+        define(:users) do
+          ungroup :emails do
+            attribute :email, from: :address
+            attribute :type
+          end
+        end
+      end
+
+      expect(mapped_users).to eql [
+        { name: 'Joe',  email: 'joe@home.org', type: 'home' },
+        { name: 'Joe',  email: 'joe@job.com',  type: 'job'  },
+        { name: 'Joe',  email: 'joe@doe.com',  type: 'job'  },
+        { name: 'Joe',  email: 'joe@thor.org', type: nil    },
+        { name: 'Joe',  email: nil,            type: 'home' },
+        { name: 'Joe',  email: nil,            type: nil    },
+        { name: 'Jane'                                      }
+      ]
+    end
+
+    it 'skips existing attributes' do
+      setup.mappers do
+        define(:users) do
+          ungroup :emails do
+            attribute :name, from: :address
+            attribute :type
+          end
+        end
+      end
+
+      expect(mapped_users).to eql [
+        { name: 'Joe',  type: 'home' },
+        { name: 'Joe',  type: 'job'  },
+        { name: 'Joe',  type: 'job'  },
+        { name: 'Joe',  type: nil    },
+        { name: 'Joe',  type: 'home' },
+        { name: 'Joe',  type: nil    },
+        { name: 'Jane'               }
+      ]
+    end
+  end
+end

data/spec/integration/mappers/unwrap_spec.rb

@@ -78,7 +78,7 @@ describe 'Mapper definition DSL' do
           attribute :title
           attribute :priority
 
-          unwrap :user do
+          unwrap :contact, from: :user do
             attribute :task_user_name, from: :name
           end
         end
@@ -92,7 +92,7 @@ describe 'Mapper definition DSL' do
                             priority: 2,
                             name: 'Jane',
                             task_user_name: 'Jane',
-                            user: { email: 'jane@doe.org' })
+                            contact: { email: 'jane@doe.org' })
     end
   end
 end

data/spec/integration/multi_repo_spec.rb

@@ -1,24 +1,24 @@
 require 'spec_helper'
 require 'rom/memory'
 
-describe 'Using in-memory repositories for cross-repo access' do
+describe 'Using in-memory gateways for cross-repo access' do
   let(:setup) do
     ROM.setup(left: :memory, right: :memory, main: :memory)
   end
 
-  let(:repositories) { rom.repositories }
+  let(:gateways) { rom.gateways }
   let(:rom) { setup.finalize }
 
   it 'works' do
-    setup.relation(:users, repository: :left) do
+    setup.relation(:users, gateway: :left) do
       def by_name(name)
         restrict(name: name)
       end
     end
 
-    setup.relation(:tasks, repository: :right)
+    setup.relation(:tasks, gateway: :right)
 
-    setup.relation(:users_and_tasks, repository: :main) do
+    setup.relation(:users_and_tasks, gateway: :main) do
       def by_user(name)
         join(users.by_name(name), tasks)
       end
@@ -30,14 +30,14 @@ describe 'Using in-memory repositories for cross-repo access' do
       end
     end
 
-    repositories[:left][:users] << { user_id: 1, name: 'Joe' }
-    repositories[:left][:users] << { user_id: 2, name: 'Jane' }
-    repositories[:right][:tasks] << { user_id: 1, title: 'Have fun' }
-    repositories[:right][:tasks] << { user_id: 2, title: 'Have fun' }
+    gateways[:left][:users] << { user_id: 1, name: 'Joe' }
+    gateways[:left][:users] << { user_id: 2, name: 'Jane' }
+    gateways[:right][:tasks] << { user_id: 1, title: 'Have fun' }
+    gateways[:right][:tasks] << { user_id: 2, title: 'Have fun' }
 
     user_and_tasks = rom.relation(:users_and_tasks)
-                     .by_user('Jane')
-                     .as(:users_and_tasks)
+      .by_user('Jane')
+      .as(:users_and_tasks)
 
     expect(user_and_tasks).to match_array([
       { user_id: 2, name: 'Jane', tasks: [{ title: 'Have fun' }] }

data/spec/integration/repositories/setting_logger_spec.rb

@@ -22,14 +22,14 @@ describe 'Repositories / Setting logger' do
     logger_class.new
   end
 
-  it 'sets up a logger for a given repository' do
+  it 'sets up a logger for a given gateway' do
     setup = ROM.setup(:memory)
 
     setup.default.use_logger(logger)
 
     rom = setup.finalize
 
-    rom.repositories[:default].logger.info("test")
+    rom.gateways[:default].logger.info("test")
 
     expect(logger.messages).to eql(["test"])
   end

data/spec/integration/setup_spec.rb

@@ -14,7 +14,7 @@ describe 'Setting up ROM' do
     end
 
     it 'configures schema relations' do
-      expect(rom.repositories[:default][:users]).to match_array([joe, jane])
+      expect(rom.gateways[:default][:users]).to match_array([joe, jane])
     end
 
     it 'configures rom relations' do
@@ -48,6 +48,16 @@ describe 'Setting up ROM' do
     end
   end
 
+  context 'with old syntax' do
+    it 'warns when old repository key is used' do
+      setup = ROM.setup(data: :memory)
+
+      expect {
+        setup.relation(:users, repository: :data)
+      }.to output(/use `gateway: :data`/).to_stderr
+    end
+  end
+
   describe 'defining classes' do
     it 'sets up registries based on class definitions' do
       ROM.setup(:memory)

data/spec/shared/command_behavior.rb

@@ -0,0 +1,18 @@
+shared_examples_for 'a command' do
+  describe '#method_missing' do
+    it 'forwards to relation and wraps response if it returned another relation' do
+      new_command = command.by_id(1)
+
+      expect(new_command).to be_instance_of(command.class)
+      expect(new_command.relation).to eql(command.by_id(1).relation)
+    end
+
+    it 'returns original response if it was not a relation' do
+      expect(command.name).to eql(command.relation.name)
+    end
+
+    it 'raises error when message is not known' do
+      expect { command.not_here }.to raise_error(NoMethodError, /not_here/)
+    end
+  end
+end

data/spec/shared/materializable.rb

@@ -1,10 +1,12 @@
 shared_examples_for 'materializable relation' do
   describe '#each' do
     it 'yields objects' do
-      count = relation.to_a.count
+      count = relation.to_a.size
       result = []
 
-      relation.each { |object| result << object }
+      relation.each do |object|
+        result << object
+      end
 
       expect(result.count).to eql(count)
     end

data/spec/shared/users_and_tasks.rb

@@ -6,10 +6,10 @@ RSpec.shared_context 'users and tasks' do
   let(:setup) { ROM.setup(:memory) }
 
   before do
-    repository = setup.default
+    gateway = setup.default
 
-    users = repository.dataset(:users)
-    tasks = repository.dataset(:tasks)
+    users = gateway.dataset(:users)
+    tasks = gateway.dataset(:tasks)
 
     users.insert(name: "Joe", email: "joe@doe.org")
     users.insert(name: "Jane", email: "jane@doe.org")

data/spec/test/memory_repository_lint_test.rb

@@ -5,15 +5,15 @@ require 'rom/lint/test'
 require 'minitest/autorun'
 
 class MemoryRepositoryLintTest < Minitest::Test
-  include ROM::Lint::TestRepository
+  include ROM::Lint::TestGateway
 
   def setup
-    @repository = ROM::Memory::Repository
+    @gateway = ROM::Memory::Gateway
     @identifier = :memory
   end
 
-  def repository_instance
-    ROM::Memory::Repository.new
+  def gateway_instance
+    ROM::Memory::Gateway.new
   end
 end
 

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

@@ -0,0 +1,198 @@
+require 'spec_helper'
+
+describe ROM::Commands::Graph do
+  shared_examples_for 'a persisted graph' do
+    it 'returns nested results' do
+      expect(command.call).to match_array([
+        # parent users
+        [
+          { name: 'Jane' },
+        ],
+        [
+          [
+            # user tasks
+            [
+              { title: 'One', user: 'Jane' }
+            ],
+            [
+              # task tags
+              [
+                { name: 'red', task: 'One' },
+                { name: 'green', task: 'One' },
+                { name: 'blue', task: 'One' }
+              ]
+            ]
+          ]
+        ]
+      ])
+    end
+
+    context 'persisted relations' do
+      before { command.call }
+
+      it 'inserts root' do
+        expect(rom.relation(:users)).to match_array([{ name: 'Jane' }])
+      end
+
+      it 'inserts root nodes' do
+        expect(rom.relation(:tasks)).to match_array([{ user: 'Jane', title: 'One' }])
+      end
+
+      it 'inserts nested graph nodes' do
+        expect(rom.relation(:tags)).to match_array([
+          { name: 'red', task: 'One' },
+          { name: 'green', task: 'One' },
+          { name: 'blue', task: 'One' }
+        ])
+      end
+    end
+  end
+
+  let(:rom) { setup.finalize }
+  let(:setup) { ROM.setup(:memory) }
+
+  let(:create_user) { rom.command(:users).create }
+  let(:create_task) { rom.command(:tasks).create }
+
+  let(:create_many_tasks) { rom.command(:tasks).create_many }
+  let(:create_many_tags) { rom.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)
+
+    setup.commands(:users) do
+      define(:create) do
+        result :one
+      end
+    end
+
+    setup.commands(:tasks) do
+      define(:create) do
+        result :one
+
+        def execute(task, user)
+          super(task.merge(user: user[:name]))
+        end
+      end
+
+      define(:create) do
+        register_as :create_many
+
+        def execute(tasks, user)
+          super(tasks.map { |t| t.merge(user: user[:name]) })
+        end
+      end
+    end
+
+    setup.commands(:tags) do
+      define(:create) do
+        register_as :create_many
+
+        def execute(tags, tasks)
+          super(
+            Array([tasks]).flatten.map { |task|
+              tags.map { |tag| tag.merge(task: task[:title]) }
+            }.flatten
+          )
+        end
+      end
+    end
+  end
+
+  describe '#call' do
+    context 'when result is :one in root and its direct children' do
+      it_behaves_like 'a persisted graph' do
+        subject(:command) do
+          create_user.with(user)
+            .combine(create_task.with(task)
+            .combine(create_many_tags.with(tags)))
+        end
+      end
+    end
+
+    context 'when result is :many for root direct children' do
+      it_behaves_like 'a persisted graph' do
+        subject(:command) do
+          create_user.with(user)
+            .combine(create_many_tasks.with([task])
+            .combine(create_many_tags.with(tags)))
+        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/)
+      end
+    end
+  end
+
+  describe 'pipeline' do
+    subject(:command) do
+      rom.command(:users).as(:entity).create.with(user)
+        .combine(create_task.with(task)
+        .combine(create_many_tags.with(tags)))
+    end
+
+    before do
+      Test::Tag = Class.new { include Anima.new(:name) }
+      Test::Task = Class.new { include Anima.new(:title, :tags) }
+      Test::User = Class.new { include Anima.new(:name, :task) }
+
+      class Test::UserMapper < ROM::Mapper
+        relation :users
+        register_as :entity
+        reject_keys :true
+
+        model Test::User
+
+        attribute :name
+
+        combine :task, on: { name: :user }, type: :hash do
+          model Test::Task
+
+          attribute :title
+
+          combine :tags, on: { title: :task } do
+            model Test::Tag
+            attribute :name
+          end
+        end
+      end
+    end
+
+    it 'sends data through the pipeline' do
+      expect(command.call).to eql(
+        Test::User.new(
+          name: 'Jane',
+          task: Test::Task.new(
+            title: 'One',
+            tags: [
+              Test::Tag.new(name: 'red'),
+              Test::Tag.new(name: 'green'),
+              Test::Tag.new(name: 'blue'),
+            ]
+          )
+        )
+      )
+    end
+  end
+end