rom-sql 1.2.1 → 1.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b4f8bdb0d753d19b5bb7be8f3d9282312f634e5d
-  data.tar.gz: dff2a952b88aa4457dc58adfc69a60e636a64527
+  metadata.gz: bc6edcd56b3aeda31a41f53c921aa2a79dd19ffc
+  data.tar.gz: d954520aa88474fcf6d61897ea0f1fed50e876ee
 SHA512:
-  metadata.gz: 837cc9f183231b155420771c55408db56779aee6adb8d97c9ad378cbe82f4047774d93b764d064f5ecddfe3521081f02a91445d394ba6aa014e607382a69fd02
-  data.tar.gz: 20c1e14423d4113a1aef6d03bd68a2e1a41232b562891fbf53b01b7ffea185e27d15d902c5bd72734f30b330e515ad2e6a831831d990694dc6c3226aedf786da
+  metadata.gz: 9f9f16bab1aef147b4956217362a1e08ec3f08dda74fc624c1e82622b6614e7bf557f8a47026f94dad182f4c34fe9fddebb3f33e876902355938f051a9c239f2
+  data.tar.gz: faa2da9349e0f26bfe53ed96a6e145a444a21ce100930191324650399d26a9aeeaa23ff1485b4cddc20532fda67e7667276bcd98ec460eecb7f0a1053f498347

data/.travis.yml

@@ -9,6 +9,7 @@ bundler_args: --without yard guard benchmarks tools
 before_script:
   - psql -c 'create database rom_sql;' -U postgres
   - mysql -u root -e 'create database rom_sql;'
+  - rvm get master
 after_success:
   - '[ "${TRAVIS_JOB_NUMBER#*.}" = "1" ] && [ "$TRAVIS_BRANCH" = "master" ] && bundle exec codeclimate-test-reporter'
 script: "bundle exec rake ci"

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## v1.2.2 2017-03-25
+
+### Changed
+
+* Updated `dry-initializer` (flash-gordon)
+
+[Compare v1.2.1...v1.2.2](https://github.com/rom-rb/rom-sql/compare/v1.2.1...v1.2.2)
+
 ## v1.2.1 2017-03-09
 
 ### Fixed

data/Gemfile

@@ -10,7 +10,6 @@ group :test do
   gem 'pry', platforms: %i(jruby rbx)
   gem 'dry-struct'
   gem 'activesupport', '~> 5.0'
-  gem 'rspec', '~> 3.1'
   gem 'codeclimate-test-reporter', require: false
   gem 'simplecov', require: false
 

data/lib/rom/sql/association.rb

@@ -29,23 +29,23 @@ module ROM
 
       # @!attribute [r] relation
       #   @return [Symbol] an optional relation identifier for the target
-      option :relation, Types::Strict::Symbol, reader: true, optional: true
+      option :relation, Types::Strict::Symbol, optional: true
 
       # @!attribute [r] result
       #   @return [Symbol] either :one or :many
-      option :result, Types::Strict::Symbol, reader: true, default: -> assoc { assoc.class.result }
+      option :result, Types::Strict::Symbol, default: -> { self.class.result }
 
       # @!attribute [r] as
       #   @return [Symbol] an optional association alias name
-      option :as, Types::Strict::Symbol, reader: true, optional: true, default: -> assoc { assoc.target.to_sym }
+      option :as, Types::Strict::Symbol, default: -> { target.to_sym }
 
       # @!attribute [r] foreign_key
       #   @return [Symbol] an optional association alias name
-      option :foreign_key, Types::Strict::Symbol, optional: true, reader: true, default: proc { nil }
+      option :foreign_key, Types::Optional::Strict::Symbol, optional: true
 
       # @!attribute [r] view
       #   @return [Symbol] An optional view that should be used to extend assoc relation
-      option :view, reader: true, optional: true, default: proc { nil }
+      option :view, optional: true
 
       alias_method :name, :as
 

data/lib/rom/sql/extensions/postgres/commands.rb

@@ -69,19 +69,19 @@ module ROM
 
           # @!attribute [r] constraint
           #  @return [Symbol] the name of the constraint expected to be violated
-          option :constraint, reader: true, default: -> c { c.class.constraint }
+          option :constraint, default: -> { self.class.constraint }
 
           # @!attribute [r] conflict_target
           #  @return [Object] the column or expression to handle a violation on
-          option :conflict_target, reader: true, default: -> c { c.class.conflict_target }
+          option :conflict_target, default: -> { self.class.conflict_target }
 
           # @!attribute [r] update_statement
           #  @return [Object] the update statement which will be executed in case of a violation
-          option :update_statement, reader: true, default: -> c { c.class.update_statement }
+          option :update_statement, default: -> { self.class.update_statement }
 
           # @!attribute [r] update_where
           #  @return [Object] the WHERE clause to be added to the update
-          option :update_where, reader: true, default: -> c { c.class.update_where }
+          option :update_where, default: -> { self.class.update_where }
 
           # Tries to insert provided tuples and do an update (or nothing)
           # when the inserted record violates a unique constraint and hence

data/lib/rom/sql/extensions/rails_log_subscriber.rb

@@ -22,8 +22,10 @@ module ROM
         debug "  #{name}  #{sql}  #{binds}"
       end
 
+      attr_reader :odd_or_even
+      private :odd_or_even
       def odd?
-        @odd_or_even = !@odd_or_even
+        @odd_or_even = !odd_or_even
       end
     end
   end

data/lib/rom/sql/gateway.rb

@@ -23,6 +23,8 @@ module ROM
         attr_accessor :instance
       end
 
+      adapter :sql
+
       CONNECTION_EXTENSIONS = {
         postgres: %i(pg_array pg_json pg_enum pg_hstore)
       }.freeze

data/lib/rom/sql/migration/migrator.rb

@@ -15,7 +15,7 @@ module ROM
 
         param :connection
 
-        option :path, type: ROM::Types.Definition(Pathname), reader: true, default: proc { DEFAULT_PATH }
+        option :path, type: ROM::Types.Definition(Pathname), default: -> { DEFAULT_PATH }
 
         # @api private
         def run(options = {})

data/lib/rom/sql/plugin/associates.rb

@@ -57,8 +57,8 @@ module ROM
 
             associations Hash.new
 
-            option :associations, reader: true, optional: true, default: -> cmd { cmd.class.associations }
-            option :configured_associations, reader: true, optional: true, default: proc { [] }
+            option :associations, default: -> { self.class.associations }
+            option :configured_associations, default: -> { EMPTY_ARRAY }
           end
           super
         end
@@ -170,7 +170,9 @@ module ROM
           # @api public
           def with_association(name, opts = EMPTY_HASH)
             self.class.build(
-              relation, options.merge(associations: associations.merge(name => opts))
+              relation,
+              **options,
+              associations: associations.merge(name => opts)
             )
           end
 

data/lib/rom/sql/plugin/pagination.rb

@@ -10,8 +10,8 @@ module ROM
 
           param :dataset
 
-          option :current_page, reader: true, default: proc { 1 }
-          option :per_page, reader: true
+          option :current_page, default: -> { 1 }
+          option :per_page
 
           def next_page
             num = current_page + 1
@@ -50,8 +50,8 @@ module ROM
           klass.class_eval do
             defines :per_page
 
-            option :pager, reader: true, default: proc { |relation|
-              Pager.new(relation.dataset, per_page: relation.class.per_page)
+            option :pager, default: -> {
+              Pager.new(dataset, per_page: self.class.per_page)
             }
           end
         end

data/lib/rom/sql/relation.rb

@@ -112,7 +112,7 @@ module ROM
         names.map { |col| :"#{table}__#{col}" }
       end
 
-      option :primary_key, reader: true, default: -> rel { rel.schema.primary_key_name }
+      option :primary_key, default: -> { schema.primary_key_name }
 
       # Return relation that will load associated tuples of this relation
       #

data/lib/rom/sql/version.rb

@@ -1,5 +1,5 @@
 module ROM
   module SQL
-    VERSION = '1.2.1'.freeze
+    VERSION = '1.2.2'.freeze
   end
 end

data/rom-sql.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'dry-equalizer', '~> 0.2'
   spec.add_runtime_dependency 'dry-types', '~> 0.9', '>= 0.9.4'
   spec.add_runtime_dependency 'dry-core', '~> 0.2', '>= 0.2.3'
-  spec.add_runtime_dependency 'rom', '~> 3.1'
+  spec.add_runtime_dependency 'rom', '~> 3.2'
 
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake', '~> 10.0'

data/spec/integration/association/many_to_many_spec.rb

@@ -7,7 +7,6 @@ RSpec.describe ROM::SQL::Association::ManyToMany do
         ROM::SQL::Association::ManyToMany.new(:tasks, :tags, through: :task_tags)
       }
 
-      let(:tasks) { container.relations[:tasks] }
       let(:tags) { container.relations[:tags] }
 
       before do

data/spec/integration/association/many_to_one/self_ref_spec.rb

@@ -25,9 +25,9 @@ RSpec.describe ROM::SQL::Association::OneToMany, '#call' do
 
       p1_id = relations[:categories].insert(name: 'P1')
       p2_id = relations[:categories].insert(name: 'P2')
-      c1_id = relations[:categories].insert(name: 'C3', parent_id: p2_id)
-      c2_id = relations[:categories].insert(name: 'C4', parent_id: p1_id)
-      c3_id = relations[:categories].insert(name: 'C5', parent_id: p1_id)
+      relations[:categories].insert(name: 'C3', parent_id: p2_id)
+      relations[:categories].insert(name: 'C4', parent_id: p1_id)
+      relations[:categories].insert(name: 'C5', parent_id: p1_id)
     end
 
     after do

data/spec/integration/association/many_to_one_spec.rb

@@ -1,7 +1,4 @@
 RSpec.describe ROM::SQL::Association::ManyToOne, helpers: true do
-  let(:users) { container.relations[:users] }
-  let(:tasks) { container.relations[:tasks] }
-
   with_adapters do
     context 'common name conventions' do
       include_context 'users and tasks'

data/spec/integration/association/one_to_many/self_ref_spec.rb

@@ -30,9 +30,9 @@ RSpec.describe ROM::SQL::Association::OneToMany, '#call' do
 
       p1_id = relations[:categories].insert(name: 'P1')
       p2_id = relations[:categories].insert(name: 'P2')
-      c1_id = relations[:categories].insert(name: 'C3', parent_id: p2_id)
-      c2_id = relations[:categories].insert(name: 'C4', parent_id: p1_id)
-      c3_id = relations[:categories].insert(name: 'C5', parent_id: p1_id)
+      relations[:categories].insert(name: 'C3', parent_id: p2_id)
+      relations[:categories].insert(name: 'C4', parent_id: p1_id)
+      relations[:categories].insert(name: 'C5', parent_id: p1_id)
     end
 
     it 'prepares joined relations using custom FK for a self-ref association' do

data/spec/integration/commands/create_spec.rb

@@ -3,8 +3,9 @@ require 'dry-struct'
 RSpec.describe 'Commands / Create', :postgres, seeds: false do
   include_context 'relations'
 
-  let(:users) { commands[:users] }
-  let(:tasks) { commands[:tasks] }
+  let(:create_user) { user_commands.create }
+  let(:create_users) { user_commands.create_many }
+  let(:create_task) { task_commands.create }
 
   before do |ex|
     module Test
@@ -45,16 +46,16 @@ RSpec.describe 'Commands / Create', :postgres, seeds: false do
   with_adapters do
     describe '#transaction' do
       it 'creates record if nothing was raised' do
-        result = users.create.transaction {
-          users.create.call(name: 'Jane')
+        result = create_user.transaction {
+          create_user.call(name: 'Jane')
         }
 
         expect(result.value).to eql(id: 1, name: 'Jane')
       end
 
       it 'creates multiple records if nothing was raised' do
-        result = users.create.transaction {
-          users.create_many.call([{ name: 'Jane' }, { name: 'Jack' }])
+        result = create_user.transaction {
+          create_users.call([{ name: 'Jane' }, { name: 'Jack' }])
         }
 
         expect(result.value).to match_array([
@@ -63,9 +64,9 @@ RSpec.describe 'Commands / Create', :postgres, seeds: false do
       end
 
       it 'allows for nested transactions' do
-        result = users.create.transaction {
-          users.create.transaction {
-            users.create.call(name: 'Jane')
+        result = create_user.transaction {
+          create_user.transaction {
+            create_user.call(name: 'Jane')
           }
         }
 
@@ -75,9 +76,9 @@ RSpec.describe 'Commands / Create', :postgres, seeds: false do
       it 'creates nothing if command error was raised' do
         expect {
           begin
-            users.create.transaction {
-              users.create.call(name: 'Jane')
-              users.create.call(name: nil)
+            create_user.transaction {
+              create_user.call(name: 'Jane')
+              create_user.call(name: nil)
             }
           rescue ROM::SQL::Error
           end
@@ -88,9 +89,9 @@ RSpec.describe 'Commands / Create', :postgres, seeds: false do
         expect {
           passed = false
 
-          result = users.create.transaction {
-            users.create.call(name: 'Jane')
-            users.create.call(name: 'John')
+          result = create_user.transaction {
+            create_user.call(name: 'Jane')
+            create_user.call(name: 'John')
             raise ROM::SQL::Rollback
           } >-> _value {
             passed = true
@@ -107,9 +108,9 @@ RSpec.describe 'Commands / Create', :postgres, seeds: false do
           begin
             passed = false
 
-            users.create.transaction {
-              users.create.call(name: 'Jane')
-              users.create.call(name: 'Jane')
+            create_user.transaction {
+              create_user.call(name: 'Jane')
+              create_user.call(name: 'Jane')
             } >-> _value {
               passed = true
             }
@@ -123,10 +124,10 @@ RSpec.describe 'Commands / Create', :postgres, seeds: false do
       it 'creates nothing if anything was raised in any nested transaction' do
         expect {
           expect {
-            users.create.transaction {
-              users.create.call(name: 'John')
-              users.create.transaction {
-                users.create.call(name: 'Jane')
+            create_user.transaction {
+              create_user.call(name: 'John')
+              create_user.transaction {
+                create_user.call(name: 'Jane')
                 raise Exception
               }
             }
@@ -159,14 +160,14 @@ RSpec.describe 'Commands / Create', :postgres, seeds: false do
     end
 
     it 'returns a single tuple when result is set to :one' do
-      result = users.try { users.create.call(name: 'Jane') }
+      result = user_commands.try { create_user.call(name: 'Jane') }
 
       expect(result.value).to eql(id: 1, name: 'Jane')
     end
 
     it 'returns tuples when result is set to :many' do
-      result = users.try do
-        users.create_many.call([{ name: 'Jane' }, { name: 'Jack' }])
+      result = user_commands.try do
+        create_users.call([{ name: 'Jane' }, { name: 'Jack' }])
       end
 
       expect(result.value.to_a).to match_array([
@@ -176,7 +177,7 @@ RSpec.describe 'Commands / Create', :postgres, seeds: false do
 
     it 're-raises not-null constraint violation error' do
       expect {
-        users.try { users.create.call(name: nil) }
+        user_commands.try { create_user.call(name: nil) }
       }.to raise_error(ROM::SQL::NotNullConstraintError)
     end
 
@@ -208,32 +209,32 @@ RSpec.describe 'Commands / Create', :postgres, seeds: false do
 
     it 're-raises uniqueness constraint violation error' do
       expect {
-        users.try {
-          users.create.call(name: 'Jane')
+        user_commands.try {
+          create_user.call(name: 'Jane')
         } >-> user {
-          users.try { users.create.call(name: user[:name]) }
+          user_commands.try { create_user.call(name: user[:name]) }
         }
       }.to raise_error(ROM::SQL::UniqueConstraintError)
     end
 
     it 're-raises fk constraint violation error' do |ex|
       expect {
-        tasks.try {
-          tasks.create.call(user_id: 918_273_645)
+        task_commands.try {
+          create_task.call(user_id: 918_273_645)
         }
       }.to raise_error(ROM::SQL::ForeignKeyConstraintError)
     end
 
     it 're-raises database errors' do
       expect {
-        users.try { users.create.call(name: nil) }
+        user_commands.try { create_user.call(name: nil) }
       }.to raise_error(ROM::SQL::NotNullConstraintError)
     end
 
     describe '#execute' do
       context 'with a single record' do
         it 'materializes the result' do
-          result = container.command(:users).create.execute(name: 'Jane')
+          result = create_user.execute(name: 'Jane')
           expect(result).to eq([
             { id: 1, name: 'Jane' }
           ])
@@ -242,7 +243,7 @@ RSpec.describe 'Commands / Create', :postgres, seeds: false do
 
       context 'with multiple records' do
         it 'materializes the results' do
-          result = container.command(:users).create.execute([
+          result = create_user.execute([
             { name: 'Jane' },
             { name: 'John' }
           ])
@@ -291,16 +292,16 @@ RSpec.describe 'Commands / Create', :postgres, seeds: false do
   describe '#call' do
     it 're-raises check constraint violation error' do
       expect {
-        users.try {
-          users.create.call(name: 'J')
+        user_commands.try {
+          create_user.call(name: 'J')
         }
       }.to raise_error(ROM::SQL::CheckConstraintError, /name/)
     end
 
     it 're-raises constraint violation error' do
       expect {
-        users.try {
-          tasks.create.call(title: '')
+        user_commands.try {
+          create_task.call(title: '')
         }
       }.to raise_error(ROM::SQL::ConstraintError, /title/)
     end
@@ -309,20 +310,20 @@ RSpec.describe 'Commands / Create', :postgres, seeds: false do
   describe '#upsert' do
     let(:task) { { title: 'task 1' } }
 
-    before { tasks.create.call(task) }
+    before { create_task.call(task) }
 
     it 'raises error without upsert marker' do
       expect {
-        tasks.create.call(task)
+        create_task.call(task)
       }.to raise_error(ROM::SQL::UniqueConstraintError)
     end
 
     it 'raises no error for duplicated data' do
-      expect { tasks.create.upsert(task) }.to_not raise_error
+      expect { create_task.upsert(task) }.to_not raise_error
     end
 
     it 'returns record data' do
-      expect(tasks.create.upsert(task, constraint: :tasks_title_key, update: { user_id: nil })).to eql([
+      expect(create_task.upsert(task, constraint: :tasks_title_key, update: { user_id: nil })).to eql([
         id: 1, user_id: nil, title: 'task 1'
       ])
     end

data/spec/integration/commands/delete_spec.rb

@@ -1,7 +1,7 @@
 RSpec.describe 'Commands / Delete' do
   include_context 'users and tasks'
 
-  subject(:users) { container.commands.users }
+  let(:delete_user) { user_commands.delete }
 
   with_adapters do
     before do
@@ -17,45 +17,45 @@ RSpec.describe 'Commands / Delete' do
         end
       end
 
-      container.relations.users.insert(id: 3, name: 'Jade')
-      container.relations.users.insert(id: 4, name: 'John')
+      users.insert(id: 3, name: 'Jade')
+      users.insert(id: 4, name: 'John')
     end
 
     describe '#transaction' do
       it 'deletes in normal way if no error raised' do
         expect {
-          users.delete.transaction do
-            users.delete.by_name('Jade').call
+          delete_user.transaction do
+            delete_user.by_name('Jade').call
           end
-        }.to change { container.relations.users.count }.by(-1)
+        }.to change { users.count }.by(-1)
       end
 
       it 'deletes nothing if error was raised' do
         expect {
-          users.delete.transaction do
-            users.delete.by_name('Jade').call
+          delete_user.transaction do
+            delete_user.by_name('Jade').call
             raise ROM::SQL::Rollback
           end
-        }.to_not change { container.relations.users.count }
+        }.to_not change { users.count }
       end
     end
 
     describe '#call' do
       it 'deletes all tuples in a restricted relation' do
-        result = users.try { users.delete.by_name('Jade').call }
+        result = user_commands.try { delete_user.by_name('Jade').call }
 
         expect(result.value).to eql(id: 3, name: 'Jade')
       end
 
       it 're-raises database error' do
-        command = users.delete.by_name('Jade')
+        command = delete_user.by_name('Jade')
 
         expect(command.relation).to receive(:delete).and_raise(
           Sequel::DatabaseError, 'totally wrong'
         )
 
         expect {
-          users.try { command.call }
+          user_commands.try { command.call }
         }.to raise_error(ROM::SQL::DatabaseError, /totally wrong/)
       end
     end

data/spec/integration/commands/update_spec.rb

@@ -3,12 +3,9 @@ require 'dry-struct'
 RSpec.describe 'Commands / Update', seeds: false do
   include_context 'users'
 
-  subject(:users) { container.command(:users) }
+  let(:update_user) { user_commands[:update] }
 
-  let(:update) { container.commands[:users][:update] }
-
-  let(:relation) { container.relations.users }
-  let(:piotr) { relation.by_name('Piotr').one }
+  let(:piotr) { users.by_name('Piotr').one }
   let(:peter) { { name: 'Peter' } }
 
   with_adapters do
@@ -36,55 +33,53 @@ RSpec.describe 'Commands / Update', seeds: false do
         register :users, entity: -> tuples { tuples.map { |tuple| Test::User.new(tuple) } }
       end
 
-      relation.insert(name: 'Piotr')
-      relation.insert(name: 'Jane')
+      users.insert(name: 'Piotr')
+      users.insert(name: 'Jane')
     end
 
     context '#transaction' do
       it 'update record if there was no errors' do
-        result = users.update.transaction do
-          users.update.by_id(piotr[:id]).call(peter)
+        result = update_user.transaction do
+          update_user.by_id(piotr[:id]).call(peter)
         end
 
         expect(result.value).to eq([{ id: 1, name: 'Peter' }])
       end
 
       it 'updates nothing if error was raised' do
-        users.update.transaction do
-          users.update.by_id(piotr[:id]).call(peter)
+        update_user.transaction do
+          update_user.by_id(piotr[:id]).call(peter)
           raise ROM::SQL::Rollback
         end
 
-        expect(relation.first[:name]).to eql('Piotr')
+        expect(users.first[:name]).to eql('Piotr')
       end
     end
 
     describe '#call' do
       it 'updates relation tuples' do
-        result = users.try do
-          users.update.by_id(piotr[:id]).call(peter)
+        result = user_commands.try do
+          update_user.by_id(piotr[:id]).call(peter)
         end
 
         expect(result.value.to_a).to match_array([{ id: 1, name: 'Peter' }])
       end
 
       it 're-raises database errors' do |example|
-        pending 'why is it failing on travis?' if ENV['TRAVIS'] && mysql?(example) && !jruby?
-
         expect {
-          users.update.by_id(piotr[:id]).call(name: nil)
+          update_user.by_id(piotr[:id]).call(name: nil)
         }.to raise_error(ROM::SQL::NotNullConstraintError, /name/i)
       end
 
       it 'materializes single result' do
-        result = users.update.by_name('Piotr').call(name: 'Pete')
+        result = update_user.by_name('Piotr').call(name: 'Pete')
         expect(result).to eq([
           { id: 1, name: 'Pete' }
         ])
       end
 
       it 'materializes multiple results' do
-        result = users.update.by_name(%w(Piotr Jane)).call(name: 'Josie')
+        result = update_user.by_name(%w(Piotr Jane)).call(name: 'Josie')
         expect(result).to eq([
           { id: 1, name: 'Josie' },
           { id: 2, name: 'Josie' }

data/spec/integration/commands/upsert_spec.rb

@@ -1,10 +1,8 @@
 RSpec.describe 'Commands / Postgres / Upsert', :postgres, seeds: false do
-  subject(:command) { commands[:tasks][:create_or_update] }
+  subject(:command) { task_commands[:create_or_update] }
 
   include_context 'relations'
 
-  let(:tasks) { commands[:tasks] }
-
   before do
     conn.execute "ALTER TABLE tasks add CONSTRAINT tasks_title_key UNIQUE (title)"
 

data/spec/integration/plugins/associates/many_to_many_spec.rb

@@ -1,15 +1,15 @@
 RSpec.describe 'Plugins / :associates / with many-to-many', :sqlite, seeds: false do
   include_context 'users and tasks'
 
-  let(:tasks) { container.commands[:tasks] }
-  let(:tags) { container.commands[:tags] }
+  let(:create_tag) { tag_commands.create }
+  let(:create_task) { task_commands.create }
 
   let(:jane) do
-    relations[:users].by_pk(relations[:users].insert(name: 'Jane')).one
+    users.by_pk(users.insert(name: 'Jane')).one
   end
 
   let(:john) do
-    relations[:users].by_pk(relations[:users].insert(name: 'John')).one
+    users.by_pk(users.insert(name: 'John')).one
   end
 
   before do
@@ -53,10 +53,10 @@ RSpec.describe 'Plugins / :associates / with many-to-many', :sqlite, seeds: fals
   end
 
   it 'associates a child with many parents' do
-    create_tags = tags[:create].with([{ name: 'red' }, { name: 'blue' }])
-    create_task = tasks[:create].with(user_id: jane[:id], title: "Jade's task")
+    add_tags = create_tag.with([{ name: 'red' }, { name: 'blue' }])
+    add_task = create_task.with(user_id: jane[:id], title: "Jade's task")
 
-    command = create_tags >> create_task
+    command = add_tags >> add_task
 
     result = command.call
 

data/spec/integration/plugins/auto_wrap_spec.rb

@@ -4,10 +4,6 @@ RSpec.describe 'Plugins / :auto_wrap' do
 
     describe '#for_wrap' do
       shared_context 'joined tuple' do
-        let(:name) do
-          users.name.relation
-        end
-
         it 'returns joined tuples' do
           task_with_user = tasks
             .for_wrap({ id: :user_id }, name)
@@ -31,36 +27,29 @@ RSpec.describe 'Plugins / :auto_wrap' do
       end
 
       context 'when parent relation is registered under dataset name' do
-        subject(:tasks) { relations[:tasks] }
-
-        let(:users) { relations[:users] }
-
         before do
           conf.relation(:tasks) { schema(infer: true) }
           conf.relation(:users) { schema(infer: true) }
         end
 
-        include_context 'joined tuple'
+        include_context 'joined tuple' do
+          let(:name) { :users }
+        end
       end
 
       context 'when parent relation is registered under a custom name' do
-        subject(:tasks) { relations[:tasks] }
-
-        let(:users) { relations[:authors] }
-
         before do
           conf.relation(:tasks) { schema(infer: true) }
           conf.relation(:authors) { schema(:users, infer: true) }
         end
 
-        include_context 'joined tuple'
+        include_context 'joined tuple' do
+          let(:users) { relations[:authors] }
+          let(:name) { :authors}
+        end
       end
 
       context 'using association' do
-        subject(:tasks) { relations[:tasks] }
-
-        let(:users) { relations[:users] }
-
         before do
           conf.relation(:tasks) {
             schema(infer: true) { associations { belongs_to :users, as: :assignee } }

data/spec/integration/schema/inferrer_spec.rb

@@ -312,8 +312,6 @@ RSpec.describe 'Schema inference for common datatypes', seeds: false do
 
     describe 'inferring indices', oracle: false do
       before do |ex|
-        ctx = self
-
         conn.create_table :test_inferrence do
           primary_key :id
           Integer :foo

data/spec/integration/sequel_api_spec.rb

@@ -3,8 +3,6 @@ require 'spec_helper'
 RSpec.describe 'Using legacy sequel api', :sqlite do
   include_context 'users'
 
-  let(:users) { relations[:users] }
-
   before do
     conf.relation(:users) do
       include ROM::SQL::Relation::SequelAPI

data/spec/shared/users.rb

@@ -6,6 +6,7 @@ RSpec.shared_context 'users' do
   end
 
   let(:users) { container.relations[:users] }
+  let(:user_commands) { container.commands[:users] }
 
   let(:jane_id) { 1 }
   let(:joe_id) { 2 }

data/spec/shared/users_and_tasks.rb

@@ -2,6 +2,10 @@ RSpec.shared_context 'users and tasks' do
   include_context 'users'
 
   let(:tasks) { container.relations[:tasks] }
+  let(:tags) { container.relations[:tags] }
+
+  let(:task_commands) { container.commands[:tasks] }
+  let(:tag_commands) { container.commands[:tags] }
 
   before do
     inferrable_relations.concat %i(tasks tags task_tags)

data/spec/spec_helper.rb

@@ -33,14 +33,14 @@ if defined? JRUBY_VERSION
   DB_URIS = {
     sqlite: 'jdbc:sqlite:::memory',
     postgres: 'jdbc:postgresql://localhost/rom_sql',
-    mysql: 'jdbc:mysql://localhost/rom_sql?user=root',
+    mysql: 'jdbc:mysql://localhost/rom_sql?user=root&sql_mode=STRICT_TRANS_TABLES,NO_ENGINE_SUBSTITUTION',
     oracle: ENV['ROM_USE_ORACLE'] ? fail('Setup Oracle for JRuby!') : nil
   }
 else
   DB_URIS = {
     sqlite: 'sqlite::memory',
     postgres: 'postgres://localhost/rom_sql',
-    mysql: 'mysql2://root@localhost/rom_sql',
+    mysql: 'mysql2://root@localhost/rom_sql?sql_mode=STRICT_TRANS_TABLES,NO_ENGINE_SUBSTITUTION',
     oracle: "oracle://#{ oracle_settings[:host] }:#{ oracle_settings[:port] }/" \
             "#{ oracle_settings[:db_name] }?username=rom_sql&password=rom_sql&autosequence=true"
   }
@@ -78,9 +78,23 @@ def with_adapters(*args, &block)
   end
 end
 
+warning_api_available = RUBY_VERSION >= '2.4.0'
+
+module SileneceWarnings
+  def warn(str)
+    if str['/sequel/'] || str['/rspec-core']
+      nil
+    else
+      super
+    end
+  end
+end
+
+Warning.extend(SileneceWarnings) if warning_api_available
+
 RSpec.configure do |config|
   config.disable_monkey_patching!
-
+  config.warnings = warning_api_available
 
   config.before(:suite) do
     tmp_test_dir = TMP_PATH.join('test')

data/spec/unit/attribute_spec.rb

@@ -3,7 +3,6 @@ require 'spec_helper'
 RSpec.describe ROM::SQL::Attribute, :postgres do
   include_context 'users and tasks'
 
-  let(:users) { relations[:users] }
   let(:ds) { users.dataset }
 
   describe '#is' do

data/spec/unit/relation/group_spec.rb

@@ -2,7 +2,6 @@ RSpec.describe ROM::Relation, '#group' do
   subject(:relation) { relations[:users] }
 
   let(:notes) { relations[:notes] }
-  let(:tasks) { relations[:tasks] }
 
   include_context 'users and tasks'
 

data/spec/unit/relation/inner_join_spec.rb

@@ -1,8 +1,6 @@
 RSpec.describe ROM::Relation, '#inner_join' do
   subject(:relation) { relations[:users] }
 
-  let(:tasks) { relations[:tasks] }
-  let(:tags) { relations[:tags] }
   let(:puzzles) { relations[:puzzles] }
 
   include_context 'users and tasks'

data/spec/unit/relation/left_join_spec.rb

@@ -1,8 +1,6 @@
 RSpec.describe ROM::Relation, '#left_join' do
   subject(:relation) { relations[:users] }
 
-  let(:tasks) { relations[:tasks] }
-
   include_context 'users and tasks'
 
   with_adapters do

data/spec/unit/relation/qualified_spec.rb

@@ -1,8 +1,6 @@
 RSpec.describe ROM::Relation, '#qualified' do
   subject(:relation) { relations[:users] }
 
-  let(:tasks) { relations[:tasks] }
-
   include_context 'users and tasks'
 
   with_adapters do

data/spec/unit/relation/right_join_spec.rb

@@ -1,8 +1,6 @@
 RSpec.describe ROM::Relation, '#right_join' do
   subject(:relation) { relations[:tasks] }
 
-  let(:users) { relations[:users] }
-
   include_context 'users and tasks'
 
   with_adapters :postgres, :mysql do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rom-sql
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.2.2
 platform: ruby
 authors:
 - Piotr Solnica
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-09 00:00:00.000000000 Z
+date: 2017-03-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
@@ -84,14 +84,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.2'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -346,7 +346,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.6.10
 signing_key: 
 specification_version: 4
 summary: SQL databases support for ROM