rom 0.6.2 → 0.7.0

data/lib/rom/support/inflector.rb

@@ -39,7 +39,7 @@ module ROM
     end
 
     def self.inflector
-      @inflector || select_backend
+      defined?(@inflector) && @inflector || select_backend
     end
 
     def self.camelize(input)

data/lib/rom/version.rb

@@ -1,3 +1,3 @@
 module ROM
-  VERSION = '0.6.2'.freeze
+  VERSION = '0.7.0'.freeze
 end

data/rom.gemspec

@@ -15,7 +15,7 @@ Gem::Specification.new do |gem|
   gem.test_files    = `git ls-files -- {spec}/*`.split("\n")
   gem.license       = 'MIT'
 
-  gem.add_runtime_dependency 'transproc', '~> 0.2', '>= 0.2.0'
+  gem.add_runtime_dependency 'transproc', '~> 0.2', '>= 0.2.1'
   gem.add_runtime_dependency 'equalizer', '~> 0.0', '>= 0.0.9'
 
   gem.add_development_dependency 'rake', '~> 10.3'

data/spec/integration/commands/create_spec.rb

@@ -34,7 +34,7 @@ describe 'Commands / Create' do
       register_as :create
       result :one
 
-      def execute(user, task)
+      def execute(task, user)
         super(task.merge(name: user.to_h[:name]))
       end
     end
@@ -65,9 +65,9 @@ describe 'Commands / Create' do
   end
 
   it 'inserts user on successful validation' do
-    result = users.try do
+    result = users.try {
       users.create.call(name: 'Piotr', email: 'piotr@solnic.eu')
-    end
+    }
 
     expect(result.value).to eql(name: 'Piotr', email: 'piotr@solnic.eu')
   end

data/spec/integration/commands/update_spec.rb

@@ -37,7 +37,7 @@ describe 'Commands / Update' do
 
   it 'update tuples on successful validation' do
     result = users.try {
-      users.update.all(name: 'Jane').set(email: 'jane.doe@test.com')
+      users.update.all(name: 'Jane').call(email: 'jane.doe@test.com')
     }
 
     expect(result)
@@ -45,7 +45,7 @@ describe 'Commands / Update' do
   end
 
   it 'returns validation object with errors on failed validation' do
-    result = users.try { users.update.all(name: 'Jane').set(email: nil) }
+    result = users.try { users.update.all(name: 'Jane').call(email: nil) }
 
     expect(result.error).to be_instance_of(Test::ValidationError)
     expect(result.error.message).to eql(':email is required')
@@ -64,7 +64,7 @@ describe 'Commands / Update' do
       end
 
       result = users.try {
-        users.update_one.by_name('Jane').set(email: 'jane.doe@test.com')
+        users.update_one.by_name('Jane').call(email: 'jane.doe@test.com')
       }
 
       expect(result.value).to eql(name: 'Jane', email: 'jane.doe@test.com')
@@ -78,7 +78,7 @@ describe 'Commands / Update' do
       end
 
       result = users.try {
-        users.update_one.set(email: 'jane.doe@test.com')
+        users.update_one.call(email: 'jane.doe@test.com')
       }
 
       expect(result.error).to be_instance_of(ROM::TupleCountMismatchError)
@@ -100,4 +100,24 @@ describe 'Commands / Update' do
       }.to raise_error(ROM::InvalidOptionValueError)
     end
   end
+
+  describe 'piping results through mappers' do
+    it 'allows scoping to a virtual relation' do
+      user_model = Class.new { include Anima.new(:name, :email) }
+
+      setup.mappers do
+        define(:users) do
+          model user_model
+          register_as :entity
+        end
+      end
+
+      command = rom.command(:users).as(:entity).update.by_name('Jane')
+
+      attributes = { name: 'Jane Doe', email: 'jane@doe.org' }
+      result = command[attributes]
+
+      expect(result).to eql([user_model.new(attributes)])
+    end
+  end
 end

data/spec/integration/mappers/combine_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+describe 'Mapper definition DSL' do
+  include_context 'users and tasks'
+
+  describe 'combine' do
+    before do
+      setup.relation(:tasks) do
+        def for_users(users)
+          names = users.map { |user| user[:name] }
+          restrict { |task| names.include?(task[:name]) }
+        end
+
+        def tags(_tasks)
+          [{ name: 'blue', task: 'be cool' }]
+        end
+      end
+
+      setup.relation(:users) do
+        def addresses(_users_)
+          [{ city: 'NYC', user: 'Jane' }, { city: 'Boston', user: 'Joe' }]
+        end
+      end
+
+      setup.mappers do
+        define(:users) do
+          register_as :entity
+
+          model name: 'Test::User'
+
+          attribute :name
+          attribute :email
+
+          combine :tasks, on: { name: :name } do
+            model name: 'Test::Task'
+
+            attribute :title
+
+            wrap :meta do
+              attribute :user, from: :name
+              attribute :priority
+            end
+
+            combine :tags, on: { title: :task } do
+              model name: 'Test::Tag'
+
+              attribute :name
+            end
+          end
+
+          combine :address, on: { name: :user }, type: :hash do
+            model name: 'Test::Address'
+
+            attribute :city
+          end
+        end
+      end
+    end
+
+    let(:users) { rom.relation(:users) }
+    let(:tasks) { rom.relation(:tasks) }
+
+    let(:joe) {
+      Test::User.new(
+        name: 'Joe',
+        email: 'joe@doe.org',
+        tasks: [
+          Test::Task.new(title: 'be nice', meta: { user: 'Joe', priority: 1 },
+                         tags: []),
+          Test::Task.new(title: 'sleep well', meta: { user: 'Joe', priority: 2 },
+                         tags: [])
+        ],
+        address: Test::Address.new(city: 'Boston')
+      )
+    }
+
+    let(:jane) {
+      Test::User.new(
+        name: 'Jane',
+        email: 'jane@doe.org',
+        tasks: [
+          Test::Task.new(
+            title: 'be cool',
+            meta: { user: 'Jane', priority: 2 },
+            tags: [Test::Tag.new(name: 'blue')]
+          )
+        ],
+        address: Test::Address.new(city: 'NYC')
+      )
+    }
+
+    it 'works' do
+      rom
+
+      Test::User.send(:include, Equalizer.new(:name, :email, :tasks, :address))
+      Test::Task.send(:include, Equalizer.new(:title, :meta))
+      Test::Address.send(:include, Equalizer.new(:city))
+
+      result = users.combine(
+        tasks.for_users.combine(tasks.tags),
+        users.addresses
+      ).as(:entity)
+
+      expect(result).to match_array([joe, jane])
+    end
+  end
+end

data/spec/integration/mappers/registering_custom_mappers_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe 'Registering Custom Mappers' do
+  include_context 'users and tasks'
+
+  it 'allows registering arbitrary objects as mappers' do
+    model = Struct.new(:name, :email)
+
+    mapper = -> users {
+      users.map { |tuple| model.new(*tuple.values_at(:name, :email)) }
+    }
+
+    setup.relation(:users) do
+      def by_name(name)
+        restrict(name: name)
+      end
+    end
+
+    setup.mappers do
+      register(:users, entity: mapper)
+    end
+
+    rom = setup.finalize
+
+    users = rom.relation(:users).by_name('Jane').as(:entity)
+
+    expect(users).to match_array([model.new('Jane', 'jane@doe.org')])
+  end
+end

data/spec/integration/mappers/reusing_mappers_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe 'Reusing mappers' do
+  it 'allows using another mapper in mapping definitions' do
+    class Test::TaskMapper < ROM::Mapper
+      attribute :title
+    end
+
+    class Test::UserMapper < ROM::Mapper
+      attribute :name
+      group :tasks, mapper: Test::TaskMapper
+    end
+
+    mapper = Test::UserMapper.build
+    relation = [{ name: 'Jane', title: 'One' }, { name: 'Jane', title: 'Two' }]
+    result = mapper.call(relation)
+
+    expect(result).to eql([
+      { name: 'Jane', tasks: [{ title: 'One' }, { title: 'Two' }] }
+    ])
+  end
+end

data/spec/integration/mappers/unwrap_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+describe 'Mapper definition DSL' do
+  include_context 'users and tasks'
+
+  let(:header) { mapper.header }
+
+  describe 'unwrapping relation mapper' do
+    before do
+      setup.relation(:tasks) do
+        def with_user
+          tuples = map { |tuple|
+            tuple.merge(user: users.restrict(name: tuple[:name]).first)
+          }
+
+          self.class.new(tuples)
+        end
+      end
+
+      setup.relation(:users)
+
+      setup.mappers do
+        define(:tasks) do
+          model name: 'Test::Task'
+
+          attribute :title
+          attribute :priority
+        end
+      end
+    end
+
+    it 'unwraps nested attributes via options hash' do
+      setup.mappers do
+        define(:with_user, parent: :tasks) do
+          attribute :title
+          attribute :priority
+
+          unwrap user: [:email, :name]
+        end
+      end
+
+      rom = setup.finalize
+
+      result = rom.relation(:tasks).with_user.as(:with_user).to_a.last
+
+      expect(result).to eql(title: 'be cool',
+                            priority: 2,
+                            name: 'Jane',
+                            email: 'jane@doe.org')
+    end
+
+    it 'unwraps nested attributes via options block' do
+      setup.mappers do
+        define(:with_user, parent: :tasks) do
+          attribute :title
+          attribute :priority
+
+          unwrap :user do
+            attribute :name
+            attribute :user_email, from: :email
+          end
+        end
+      end
+
+      rom = setup.finalize
+
+      result = rom.relation(:tasks).with_user.as(:with_user).to_a.last
+
+      expect(result).to eql(title: 'be cool',
+                            priority: 2,
+                            name: 'Jane',
+                            user_email: 'jane@doe.org')
+    end
+
+    it 'unwraps specified attributes via options block' do
+      setup.mappers do
+        define(:with_user, parent: :tasks) do
+          attribute :title
+          attribute :priority
+
+          unwrap :user do
+            attribute :task_user_name, from: :name
+          end
+        end
+      end
+
+      rom = setup.finalize
+
+      result = rom.relation(:tasks).with_user.as(:with_user).to_a.last
+
+      expect(result).to eql(title: 'be cool',
+                            priority: 2,
+                            name: 'Jane',
+                            task_user_name: 'Jane',
+                            user: { email: 'jane@doe.org' })
+    end
+  end
+end

data/spec/integration/multi_repo_spec.rb

@@ -36,8 +36,8 @@ describe 'Using in-memory repositories for cross-repo access' do
     repositories[: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/extending_relations_spec.rb

@@ -22,6 +22,15 @@ describe 'Repository' do
     end
   end
 
+  after do
+    ROM::Memory::Relation.class_eval do
+      undef_method :freaking_cool?
+      class << self
+        undef_method :freaking_awesome?
+      end
+    end
+  end
+
   shared_examples_for 'extended relation' do
     it 'can extend relation class' do
       expect(rom.relations.users.class).to be_freaking_awesome

data/spec/integration/setup_spec.rb

@@ -90,7 +90,7 @@ describe 'Setting up ROM' do
         end
       end
 
-      rom = ROM.setup(:memory) do
+      rom = ROM.setup(:memory) {
         relation(:users) do
           def by_name(name)
             restrict(name: name)
@@ -106,7 +106,7 @@ describe 'Setting up ROM' do
             model Test::User
           end
         end
-      end
+      }
 
       rom.commands.users.create.call(name: 'Jane')
 

data/spec/shared/enumerable_dataset.rb

@@ -9,7 +9,10 @@ shared_examples_for "an enumerable dataset" do
     it 'yields tuples through row_proc' do
       result = []
 
-      dataset.each { |tuple| result << tuple }
+      dataset.each do |tuple|
+        result << tuple
+      end
+
       expect(result).to match_array([{ name: 'Jane' }, { name: 'Joe' }])
     end
   end

data/spec/shared/materializable.rb

@@ -0,0 +1,34 @@
+shared_examples_for 'materializable relation' do
+  describe '#each' do
+    it 'yields objects' do
+      count = relation.to_a.count
+      result = []
+
+      relation.each { |object| result << object }
+
+      expect(result.count).to eql(count)
+    end
+
+    it 'returns enumerator when block is not provided' do
+      expect(relation.each.to_a).to eql(relation.to_a)
+    end
+  end
+
+  describe '#one' do
+    it 'returns one tuple' do
+      expect(relation.one).to be_instance_of(Hash)
+    end
+  end
+
+  describe '#first' do
+    it 'returns first tuple' do
+      expect(relation.first).to be_instance_of(Hash)
+    end
+  end
+
+  describe '#call' do
+    it 'materializes relation' do
+      expect(relation.call).to be_instance_of(ROM::Relation::Loaded)
+    end
+  end
+end