polymorpheus 3.1.1 → 3.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: e181e9294980f79aa4b50efdd7edb588de1c390a
-  data.tar.gz: 317c3f2e0da8513874d57955042e547a2077c3bb
+SHA256:
+  metadata.gz: 60273820617c2e5ef7e4eab45965a2729ae9ecb3e8ba05357cf9c0ae432d36be
+  data.tar.gz: 156743a57b80836a20280d0bdef6bd4e3f895e79cbf93aac60b986fe5deb4bac
 SHA512:
-  metadata.gz: b5ccb72b1c3a0ed0d247b67a5c2dbf71b04a46d6947c64b71e16a4212960acc60cf1b8771e8768b04967c1a8b64df9238aa7102febf67c5fe95ce36facbd0f3c
-  data.tar.gz: 5ef3e30327eaab0914ea2731cf3d5699ea1f058320ebfc2ada4704e8e4b497db556d112dcca7f8a694efb8cc74b7b1bf7d3f7307ed35ceb532e89acc2ccbe8ae
+  metadata.gz: 5bb967919da9877c1129879492445d4972aff408399c0c6da01804cc4848382e9565b1cf32aa72c63101cf791ef331e5382cededa0a146e0d439a828f34fade2
+  data.tar.gz: cb3b1f649f7317ef555b78b6932a5385c8f78ba7e8b5bbdb3d37a552a4b4c20dce0ef72fd1deb410745744885020766e674acd50a1826989b720fe99abe71e65

data/README.md

@@ -1,4 +1,3 @@
-[![Build Status](https://travis-ci.org/wegowise/polymorpheus.png?branch=master)](https://travis-ci.org/wegowise/polymorpheus)
 [![Code Climate](https://codeclimate.com/github/wegowise/polymorpheus.png)](https://codeclimate.com/github/wegowise/polymorpheus)
 
 # Polymorpheus
@@ -10,15 +9,6 @@ no setup**
 If you are using Bundler, you can add the gem to your Gemfile:
 
 ```ruby
-# with Rails >= 4.2
-gem 'polymorpheus'
-```
-
-Or:
-
-```ruby
-# with Rails < 4.2
-gem 'foreigner'
 gem 'polymorpheus'
 ```
 
@@ -142,8 +132,6 @@ Now let's review what we've done.
 
 * Currently the gem only supports MySQL. Please feel free to fork and submit a
   (well-tested) pull request if you want to add Postgres support.
-* This gem is tested and has been tested for Rails 2.3.8, 3.0.x, 3.1.x, 3.2.x,
-  and 4.0.0
 * For Rails 3.1+, you'll still need to use `up` and `down` methods in your
   migrations.
 
@@ -214,8 +202,8 @@ pic.polymorpheus.query_condition
 ## Credits and License
 
 * This gem was written by [Barun Singh](https://github.com/barunio)
-* It uses the [Foreigner gem](https://github.com/matthuhiggins/foreigner) under
-  the hood for Rails < 4.2.
+* Older, unsupported versions of this gem use [Foreigner gem](https://github.com/matthuhiggins/foreigner)
+  under the hood for Rails < 4.2.
 
 polymorpheus is Copyright © 2011-2015 Barun Singh and [WegoWise](
 http://wegowise.com). It is free software, and may be redistributed under the

data/lib/polymorpheus/adapter.rb

@@ -15,7 +15,11 @@ module Polymorpheus
       end
 
       def configured_adapter
-        ActiveRecord::Base.connection_pool.spec.config[:adapter]
+        if ActiveRecord::Base.respond_to?(:connection_db_config)
+          ActiveRecord::Base.connection_db_config.adapter # ActiveRecord >= 6.1
+        else
+          ActiveRecord::Base.connection_pool.spec.config[:adapter]
+        end
       end
     end
 

data/lib/polymorpheus/interface/belongs_to_polymorphic.rb

@@ -21,7 +21,7 @@ module Polymorpheus
 
         # Set belongs_to associations
         builder.associations.each do |association|
-          belongs_to association.name.to_sym, association.options
+          belongs_to association.name.to_sym, **association.options
         end
 
         # Exposed interface for introspection

data/lib/polymorpheus/interface/{rails4/has_many_as_polymorph.rb → has_many_as_polymorph.rb}

@@ -25,7 +25,7 @@ module Polymorpheus
           relation
         end
 
-        has_many association, conditions, options
+        has_many association, conditions, **options
       end
     end
   end

data/lib/polymorpheus/mysql_adapter.rb

@@ -74,7 +74,7 @@ module Polymorpheus
             :name => "#{table}_#{col_name}_fk",
             :primary_key => (ref_col || 'id' )
           }.merge(generate_constraints(options))
-          add_foreign_key(table, ref_table, fk_options)
+          add_foreign_key(table, ref_table, **fk_options)
         end
       end
 
@@ -208,8 +208,3 @@ end
   rescue
   end
 end
-
-if ::Polymorpheus.require_foreigner?
-  require 'foreigner/connection_adapters/mysql2_adapter'
-  require 'polymorpheus/mysql_adapter/foreigner_constraints'
-end

data/lib/polymorpheus/version.rb

@@ -1,3 +1,3 @@
 module Polymorpheus
-  VERSION = '3.1.1'
+  VERSION = '3.4.0'
 end

data/lib/polymorpheus.rb

@@ -8,12 +8,7 @@ module Polymorpheus
   module Interface
     autoload :BelongsToPolymorphic, 'polymorpheus/interface/belongs_to_polymorphic'
     autoload :ValidatesPolymorph, 'polymorpheus/interface/validates_polymorph'
-
-    if ActiveRecord::VERSION::MAJOR >= 4
-      autoload :HasManyAsPolymorph, 'polymorpheus/interface/rails4/has_many_as_polymorph'
-    else
-      autoload :HasManyAsPolymorph, 'polymorpheus/interface/rails3/has_many_as_polymorph'
-    end
+    autoload :HasManyAsPolymorph, 'polymorpheus/interface/has_many_as_polymorph'
   end
 
   class InterfaceBuilder
@@ -23,16 +18,8 @@ module Polymorpheus
   module ConnectionAdapters
     autoload :SchemaStatements, 'polymorpheus/schema_statements'
   end
-
-  def self.require_foreigner?
-    ActiveRecord::VERSION::MAJOR < 5 &&
-    !(::ActiveRecord::VERSION::MAJOR >= 4 &&
-      ::ActiveRecord::VERSION::MINOR >= 2)
-  end
 end
 
-require 'foreigner' if ::Polymorpheus.require_foreigner?
-
 Polymorpheus::Adapter.register 'mysql2', 'polymorpheus/mysql_adapter'
 Polymorpheus::Adapter.register 'postgresql', 'polymorpheus/postgresql_adapter'
 

data/polymorpheus.gemspec

@@ -12,13 +12,14 @@ Gem::Specification.new do |s|
   s.summary     = "Provides a database-friendly method for polymorphic relationships"
   s.description = "Provides a database-friendly method for polymorphic relationships"
 
+  s.required_ruby_version = ">= 2.6"
   s.required_rubygems_version = ">= 1.3.6"
   s.files = Dir.glob(%w[{lib,spec}/**/*.rb [A-Z]*.{txt,rdoc,md} *.gemspec]) + %w{Rakefile}
   s.extra_rdoc_files = ["README.md", "LICENSE.txt"]
   s.license = 'MIT'
 
-  s.add_dependency('activerecord', '>= 3.2', '< 5.2')
+  s.add_dependency('activerecord', '>= 5.2', '< 7.1')
 
-  s.add_development_dependency('rake', '~> 10.4.2')
-  s.add_development_dependency('rspec', '~> 2.14.0')
+  s.add_development_dependency('rake', '~> 12.3.3')
+  s.add_development_dependency('rspec', '~> 3.9.0')
 end

data/spec/interface/belongs_to_polymorphic_spec.rb

@@ -15,9 +15,12 @@ describe Polymorpheus::Interface::BelongsToPolymorphic do
     create_table :villains
   end
 
-  specify { StoryArc::POLYMORPHEUS_ASSOCIATIONS.should == %w[hero villain] }
-  specify { Superpower::POLYMORPHEUS_ASSOCIATIONS.should == %w[superhero
-                                                               supervillain] }
+  specify do
+    expect(StoryArc::POLYMORPHEUS_ASSOCIATIONS).to eq(%w[hero villain])
+  end
+  specify do
+    expect(Superpower::POLYMORPHEUS_ASSOCIATIONS).to eq(%w[superhero supervillain])
+  end
 
   describe "setter methods for ActiveRecord objects" do
     let(:story_arc) { StoryArc.new(attributes) }
@@ -25,37 +28,38 @@ describe Polymorpheus::Interface::BelongsToPolymorphic do
 
     it "sets the correct attribute value for the setter" do
       story_arc.character = hero
-      story_arc.hero_id.should == hero.id
-      story_arc.villain_id.should == nil
+      expect(story_arc.hero_id).to eq(hero.id)
+      expect(story_arc.villain_id).to eq(nil)
     end
 
     it "sets competing associations to nil" do
       story_arc.character = hero
-      story_arc.hero_id.should == hero.id
+      expect(story_arc.hero_id).to eq(hero.id)
       story_arc.character = villain
-      story_arc.villain_id.should == villain.id
-      story_arc.hero_id.should == nil
+      expect(story_arc.villain_id).to eq(villain.id)
+      expect(story_arc.hero_id).to eq(nil)
     end
 
     it "throws an error if the assigned object isn't a valid type" do
       create_table :trees
 
       tree = Tree.create!
-      expect { story_arc.character = tree }
-        .to raise_error(Polymorpheus::Interface::InvalidTypeError,
-                        "Invalid type. Must be one of {hero, villain}")
+      expect { story_arc.character = tree }.to raise_error(
+        Polymorpheus::Interface::InvalidTypeError,
+        "Invalid type. Must be one of {hero, villain}"
+      )
     end
 
     it "does not throw an error if the assigned object is a subclass of a
     valid type" do
       expect { story_arc.character = superhero }.not_to raise_error
-      story_arc.hero_id.should == superhero.id
+      expect(story_arc.hero_id).to eq(superhero.id)
     end
 
     it "does not throw an error if the assigned object is a descendant of a
     valid type" do
       expect { story_arc.character = alien_demigod }.not_to raise_error
-      story_arc.hero_id.should == alien_demigod.id
+      expect(story_arc.hero_id).to eq(alien_demigod.id)
     end
   end
 
@@ -79,12 +83,12 @@ describe Polymorpheus::Interface::BelongsToPolymorphic do
 
     it "works if the assigned object is of the specified class" do
       expect { superpower.wielder = superhero }.not_to raise_error
-      superpower.superhero_id.should == superhero.id
+      expect(superpower.superhero_id).to eq(superhero.id)
     end
 
     it "works if the assigned object is an instance of a child class" do
       expect { superpower.wielder = alien_demigod }.not_to raise_error
-      superpower.superhero_id.should == alien_demigod.id
+      expect(superpower.superhero_id).to eq(alien_demigod.id)
     end
   end
 
@@ -94,42 +98,52 @@ describe Polymorpheus::Interface::BelongsToPolymorphic do
     context 'when there is no relationship defined' do
       let(:story_arc) { StoryArc.new }
 
-      its(:associations) { should match_associations(:hero, :villain) }
-      its(:active_association) { should == nil }
-      its(:query_condition) { should == nil }
+      specify do
+        expect(interface.associations).to match_associations(:hero, :villain)
+      end
+      specify { expect(interface.active_association).to eq nil }
+      specify { expect(interface.query_condition).to eq nil }
     end
 
     context 'when there is are multiple relationships defined' do
       let(:story_arc) { StoryArc.new(hero_id: hero.id, villain_id: villain.id) }
 
-      its(:associations) { should match_associations(:hero, :villain) }
-      its(:active_association) { should == nil }
-      its(:query_condition) { should == nil }
+      specify do
+        expect(interface.associations).to match_associations(:hero, :villain)
+      end
+      specify { expect(interface.active_association).to eq nil }
+      specify { expect(interface.query_condition).to eq nil }
     end
 
     context 'when there is one relationship defined through the id value' do
       let(:story_arc) { StoryArc.new(hero_id: hero.id) }
 
-      its(:associations) { should match_associations(:hero, :villain) }
-      its(:active_association) { be_association(:hero) }
-      its(:query_condition) { should == { 'hero_id' => hero.id } }
+      specify do
+        expect(interface.associations).to match_associations(:hero, :villain)
+      end
+      specify { expect(interface.active_association).to be_association(:hero) }
+      specify { expect(interface.query_condition).to eq('hero_id' => hero.id) }
     end
 
     context 'when there is one relationship defined through the setter' do
       let(:story_arc) { StoryArc.new(character: hero) }
 
-      its(:associations) { should match_associations(:hero, :villain) }
-      its(:active_association) { be_association(:hero) }
-      its(:query_condition) { should == { 'hero_id' => hero.id } }
+      specify do
+        expect(interface.associations).to match_associations(:hero, :villain)
+      end
+      specify { expect(interface.active_association).to be_association(:hero) }
+      specify { expect(interface.query_condition).to eq('hero_id' => hero.id) }
     end
 
     context 'when there is one association, to a new record' do
       let(:new_hero) { Hero.new }
       let(:story_arc) { StoryArc.new(character: new_hero) }
 
-      its(:associations) { should match_associations(:hero, :villain) }
-      its(:active_association) { be_association(:hero) }
-      its(:query_condition) { should == nil }
+      specify do
+        expect(interface.associations).to match_associations(:hero, :villain)
+      end
+      specify { expect(interface.active_association).to be_association(:hero) }
+      specify { expect(interface.query_condition).to eq nil }
     end
   end
 end

data/spec/interface/has_many_as_polymorph_spec.rb

@@ -16,54 +16,71 @@ describe Polymorpheus::Interface::HasManyAsPolymorph do
 
   it 'sets conditions on association to ensure we retrieve correct result' do
     hero = Hero.create!
-    hero.story_arcs.to_sql
-      .should match_sql(%{SELECT `story_arcs`.* FROM `story_arcs`
-                          WHERE `story_arcs`.`hero_id` = #{hero.id}
-                          AND `story_arcs`.`villain_id` IS NULL})
+    expect(hero.story_arcs.to_sql).to match_sql <<-EOS
+      SELECT `story_arcs`.* FROM `story_arcs`
+      WHERE `story_arcs`.`hero_id` = #{hero.id}
+      AND `story_arcs`.`villain_id` IS NULL
+    EOS
   end
 
   it 'supports existing conditions on the association' do
     villain = Villain.create!
-    villain.story_arcs.to_sql
-      .should match_sql(%{SELECT `story_arcs`.* FROM `story_arcs`
-                          WHERE `story_arcs`.`villain_id` = #{villain.id}
-                          AND `story_arcs`.`hero_id` IS NULL
-                          ORDER BY id DESC})
+    expect(villain.story_arcs.to_sql).to match_sql <<-EOS
+      SELECT `story_arcs`.* FROM `story_arcs`
+      WHERE `story_arcs`.`villain_id` = #{villain.id}
+      AND `story_arcs`.`hero_id` IS NULL
+      ORDER BY id DESC
+    EOS
   end
 
   it 'returns the correct result when used with new records' do
     villain = Villain.create!
     story_arc = StoryArc.create!(villain: villain, issue_id: 10)
-    Hero.new.story_arcs.where(issue_id: 10).should == []
+    expect(Hero.new.story_arcs.where(issue_id: 10)).to eq([])
   end
 
   it 'sets conditions on associations with enough specificity that they work
   in conjunction with has_many :through relationships' do
     hero = Hero.create!
-    hero.battles.to_sql
-      .should match_sql(%{SELECT `battles`.* FROM `battles`
-                          INNER JOIN `story_arcs`
-                          ON `battles`.`id` = `story_arcs`.`battle_id`
-                          WHERE `story_arcs`.`hero_id` = #{hero.id}
-                          AND `story_arcs`.`villain_id` IS NULL})
+    expect(hero.battles.to_sql).to match_sql <<-EOS
+      SELECT `battles`.* FROM `battles`
+      INNER JOIN `story_arcs`
+      ON `battles`.`id` = `story_arcs`.`battle_id`
+      WHERE `story_arcs`.`hero_id` = #{hero.id}
+      AND `story_arcs`.`villain_id` IS NULL
+    EOS
   end
 
   it 'uses the correct association table name when used in conjunction with a
   join condition' do
     battle = Battle.create!
-    battle.heros.to_sql
-      .should match_sql(%{SELECT `heros`.* FROM `heros`
-                          INNER JOIN `story_arcs`
-                          ON `heros`.`id` = `story_arcs`.`hero_id`
-                          WHERE `story_arcs`.`battle_id` = #{battle.id}})
+    expect(battle.heros.to_sql).to match_sql <<-EOS
+      SELECT `heros`.* FROM `heros`
+      INNER JOIN `story_arcs`
+      ON `heros`.`id` = `story_arcs`.`hero_id`
+      WHERE `story_arcs`.`battle_id` = #{battle.id}
+    EOS
 
-    battle.heros.joins(:story_arcs).to_sql
-      .should match_sql(%{SELECT `heros`.* FROM `heros`
-                          INNER JOIN `story_arcs` `story_arcs_heros`
-                          ON `story_arcs_heros`.`hero_id` = `heros`.`id`
-                          AND `story_arcs_heros`.`villain_id` IS NULL
-                          INNER JOIN `story_arcs`
-                          ON `heros`.`id` = `story_arcs`.`hero_id`
-                          WHERE `story_arcs`.`battle_id` = #{battle.id}})
+    if ActiveRecord::VERSION::MAJOR >= 6
+      expect(battle.heros.joins(:story_arcs).to_sql).to match_sql <<-EOS
+        SELECT `heros`.* FROM `heros`
+        INNER JOIN `story_arcs`
+        ON `heros`.`id` = `story_arcs`.`hero_id`
+        INNER JOIN `story_arcs` `story_arcs_heros`
+        ON `story_arcs_heros`.`villain_id` IS NULL
+        AND `story_arcs_heros`.`hero_id` = `heros`.`id`
+        WHERE `story_arcs`.`battle_id` = #{battle.id}
+      EOS
+    else
+      expect(battle.heros.joins(:story_arcs).to_sql).to match_sql <<-EOS
+        SELECT `heros`.* FROM `heros`
+        INNER JOIN `story_arcs` `story_arcs_heros`
+        ON `story_arcs_heros`.`hero_id` = `heros`.`id`
+        AND `story_arcs_heros`.`villain_id` IS NULL
+        INNER JOIN `story_arcs`
+        ON `heros`.`id` = `story_arcs`.`hero_id`
+        WHERE `story_arcs`.`battle_id` = #{battle.id}
+      EOS
+    end
   end
 end

data/spec/interface/validates_polymorph_spec.rb

@@ -13,23 +13,25 @@ describe Polymorpheus::Interface::ValidatesPolymorph do
     create_table(:villains)
   end
 
-  specify { StoryArc.new(character: hero).valid?.should == true }
-  specify { StoryArc.new(character: villain).valid?.should == true }
-  specify { StoryArc.new(hero_id: hero.id).valid?.should == true }
-  specify { StoryArc.new(hero: hero).valid?.should == true }
-  specify { StoryArc.new(hero: Hero.new).valid?.should == true }
+  specify { expect(StoryArc.new(character: hero).valid?).to eq(true) }
+  specify { expect(StoryArc.new(character: villain).valid?).to eq(true) }
+  specify { expect(StoryArc.new(hero_id: hero.id).valid?).to eq(true) }
+  specify { expect(StoryArc.new(hero: hero).valid?).to eq(true) }
+  specify { expect(StoryArc.new(hero: Hero.new).valid?).to eq(true) }
 
   it 'is invalid if no association is specified' do
     story_arc = StoryArc.new
-    story_arc.valid?.should == false
-    story_arc.errors[:base].should ==
+    expect(story_arc.valid?).to eq(false)
+    expect(story_arc.errors[:base]).to eq(
       ["You must specify exactly one of the following: {hero, villain}"]
+    )
   end
 
   it 'is invalid if multiple associations are specified' do
     story_arc = StoryArc.new(hero_id: hero.id, villain_id: villain.id)
-    story_arc.valid?.should == false
-    story_arc.errors[:base].should ==
+    expect(story_arc.valid?).to eq(false)
+    expect(story_arc.errors[:base]).to eq(
       ["You must specify exactly one of the following: {hero, villain}"]
+    )
   end
 end

data/spec/interface_spec.rb

@@ -7,10 +7,10 @@ describe Polymorpheus::Interface do
       create_table :books
       create_table :binders
 
-      Drawing.new.association(:book).reflection.inverse_of.should == nil
-      Drawing.new.association(:binder).reflection.inverse_of.should == nil
-      Book.new.association(:drawings).reflection.inverse_of.should == nil
-      Binder.new.association(:drawings).reflection.inverse_of.should == nil
+      expect(Drawing.new.association(:book).reflection.inverse_of).to eq(nil)
+      expect(Drawing.new.association(:binder).reflection.inverse_of).to eq(nil)
+      expect(Book.new.association(:drawings).reflection.inverse_of).to eq(nil)
+      expect(Binder.new.association(:drawings).reflection.inverse_of).to eq(nil)
     end
 
     it 'with options' do
@@ -18,10 +18,10 @@ describe Polymorpheus::Interface do
       create_table :web_pages
       create_table :printed_works
 
-      Picture.new.association(:web_page).reflection.inverse_of.name.should == :pictures
-      Picture.new.association(:printed_work).reflection.inverse_of.name.should == :pictures
-      WebPage.new.association(:pictures).reflection.inverse_of.name.should == :web_page
-      PrintedWork.new.association(:pictures).reflection.inverse_of.name.should == :printed_work
+      expect(Picture.new.association(:web_page).reflection.inverse_of.name).to eq(:pictures)
+      expect(Picture.new.association(:printed_work).reflection.inverse_of.name).to eq(:pictures)
+      expect(WebPage.new.association(:pictures).reflection.inverse_of.name).to eq(:web_page)
+      expect(PrintedWork.new.association(:pictures).reflection.inverse_of.name).to eq(:printed_work)
     end
   end
 end

data/spec/schema_dumper_spec.rb

@@ -30,10 +30,10 @@ describe Polymorpheus::SchemaDumper do
   end
 
   specify "the schema statement is part of the dump" do
-    subject.index(schema_statement).should be_a(Integer)
+    expect(subject.index(schema_statement)).to be_a(Integer)
   end
 
   specify "there is exactly one instance of the schema statement" do
-    subject.index(schema_statement).should == subject.rindex(schema_statement)
+    expect(subject.index(schema_statement)).to eq(subject.rindex(schema_statement))
   end
 end

data/spec/spec_helper.rb

@@ -2,13 +2,14 @@ require 'active_record'
 require 'polymorpheus'
 require 'stringio'
 
-require 'support/active_record/connection_adapters/abstract_mysql_adapter'
-
-ActiveRecord::Base.establish_connection({
+ActiveRecord::Base.establish_connection(
   adapter: 'mysql2',
-  username: 'travis',
-  database: 'polymorpheus_test'
-})
+  database: ENV.fetch('DB_NAME', 'polymorpheus_test'),
+  host: ENV.fetch('DB_HOST', '127.0.0.1'),
+  password: ENV.fetch('DB_PASSWORD', ''),
+  port: ENV.fetch('DB_PORT', '3306'),
+  username: ENV.fetch('DB_USERNAME', 'root')
+)
 
 Dir[File.dirname(__FILE__) + '/support/*.rb'].sort.each { |path| require path }
 
@@ -27,7 +28,7 @@ RSpec.configure do |config|
   config.include SqlTestHelpers
 
   config.after do
-    data_sources.each do |table|
+    ActiveRecord::Base.connection.tables.each do |table|
       ActiveRecord::Base.connection.drop_table(table)
     end
   end

data/spec/support/connection_helpers.rb

@@ -3,14 +3,6 @@ module ConnectionHelpers
     connection.add_polymorphic_constraints(*args)
   end
 
-  def data_sources
-    if ActiveRecord::VERSION::MAJOR >= 5
-      ActiveRecord::Base.connection.data_sources
-    else
-      ActiveRecord::Base.connection.tables
-    end
-  end
-
   def remove_polymorphic_constraints(*args)
     connection.remove_polymorphic_constraints(*args)
   end

data/spec/support/custom_matchers.rb

@@ -1,31 +1,31 @@
 RSpec::Matchers.define :be_association do |association_name|
   match do |actual|
-    actual.should be_instance_of(Polymorpheus::InterfaceBuilder::Association)
-    actual.name.should == association_name.to_s
+    expect(actual).to be_instance_of Polymorpheus::InterfaceBuilder::Association
+    expect(actual.name).to eq association_name.to_s
   end
 end
 
 RSpec::Matchers.define :match_associations do |*association_names|
   match do |actual|
-    actual.length.should == association_names.length
+    expect(actual.length).to eq association_names.length
     actual.each_with_index do |item, ind|
-      item.should be_association(association_names[ind])
+      expect(item).to be_association(association_names[ind])
     end
   end
 end
 
 RSpec::Matchers.define :match_sql do |expected|
   match do |actual|
-    format(expected).should == format(actual)
+    expect(format(expected)).to eq format(actual)
   end
 
-  failure_message_for_should do |actual|
+  failure_message do |actual|
     "expected the following SQL statements to match:
     #{format(actual)}
     #{format(expected)}"
   end
 
   def format(sql)
-    sql.gsub(/\s+/, ' ')
+    sql.squish
   end
 end

data/spec/support/schema_helpers.rb

@@ -2,7 +2,7 @@ module SchemaHelpers
   def create_table(name, options = {})
     options.merge!(force: true)
     ActiveRecord::Schema.define do
-      create_table(name, options) do |t|
+      create_table(name, **options) do |t|
         yield(t) if block_given?
       end
     end

data/spec/support/sql_query_subscriber.rb

@@ -0,0 +1,17 @@
+module Polymorpheus
+  class SqlQuerySubscriber
+    attr_reader :sql_statements
+
+    def initialize
+      @sql_statements = []
+    end
+
+    def call(_name, _start, _finish, _id, payload)
+      sql_statements << payload[:sql]
+    end
+
+    def clear_sql_history
+      @sql_statements.clear
+    end
+  end
+end

data/spec/support/sql_test_helpers.rb

@@ -2,22 +2,16 @@ module SqlTestHelpers
   extend ActiveSupport::Concern
 
   included do
-    before(:all) do
-      class << ActiveRecord::Base.connection
-        include Polymorpheus::SqlLogger
-        alias_method :original_execute, :execute
-        alias_method :execute, :log_sql_statements
-      end
+    before do
+      ActiveSupport::Notifications.subscribe('sql.active_record', sql_logger)
     end
 
-    after(:all) do
-      class << ActiveRecord::Base.connection
-        alias_method :execute, :original_execute
-      end
+    after do
+      ActiveSupport::Notifications.unsubscribe(sql_logger)
     end
 
     let(:connection) { ActiveRecord::Base.connection }
-    let(:sql) { connection.sql_statements }
+    let(:sql_logger) { Polymorpheus::SqlQuerySubscriber.new }
 
     def clean_sql(sql_string)
       sql_string
@@ -31,11 +25,15 @@ module SqlTestHelpers
     end
 
     def clear_sql_history
-      connection.clear_sql_history
+      sql_logger.clear_sql_history
     end
 
     def should_execute_sql(expected)
-      expect(clean_sql(sql.join("\n"))).to include(clean_sql(expected.squish))
+      expect(clean_sql(sql.join("\n"))).to include(clean_sql(expected))
+    end
+
+    def sql
+      sql_logger.sql_statements
     end
   end
 end

data/spec/trigger_spec.rb

@@ -19,27 +19,39 @@ describe Polymorpheus::Trigger do
   let(:collation_connection) { "utf8_general_ci" }
   let(:db_collation) { "utf8_unicode_ci" }
 
-  subject do
-    described_class.new([name, event, table, statement, timing, created,
-                         sql_mode, definer, charset, collation_connection,
-                         db_collation])
+  let(:trigger) do
+    described_class.new(
+      [
+        name,
+        event,
+        table,
+        statement,
+        timing,
+        created,
+        sql_mode,
+        definer,
+        charset,
+        collation_connection,
+        db_collation
+      ]
+    )
   end
 
-  its(:name) { should == name }
-  its(:event) { should == event }
-  its(:table) { should == table }
-  its(:statement) { should == statement }
-  its(:timing) { should == timing }
-  its(:created) { should == created }
-  its(:sql_mode) { should == sql_mode }
-  its(:definer) { should == definer }
-  its(:charset) { should == charset }
-  its(:collation_connection) { should == collation_connection }
-  its(:db_collation) { should == db_collation }
+  specify { expect(trigger.name).to eq name }
+  specify { expect(trigger.event).to eq event }
+  specify { expect(trigger.table).to eq table }
+  specify { expect(trigger.statement).to eq statement }
+  specify { expect(trigger.timing).to eq timing }
+  specify { expect(trigger.created).to eq created }
+  specify { expect(trigger.sql_mode).to eq sql_mode }
+  specify { expect(trigger.definer).to eq definer }
+  specify { expect(trigger.charset).to eq charset }
+  specify { expect(trigger.collation_connection).to eq collation_connection }
+  specify { expect(trigger.db_collation).to eq db_collation }
 
-  its(:columns) { should == %w{dog_id kitty_id} }
+  specify { expect(trigger.columns).to eq %w[dog_id kitty_id] }
 
-  its(:schema_statement) do
-    should == %{  add_polymorphic_triggers(:pets, ["dog_id", "kitty_id"])}
+  specify do
+    expect(trigger.schema_statement).to eq %{  add_polymorphic_triggers(:pets, ["dog_id", "kitty_id"])}
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polymorpheus
 version: !ruby/object:Gem::Version
-  version: 3.1.1
+  version: 3.4.0
 platform: ruby
 authors:
 - Barun Singh
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-06-16 00:00:00.000000000 Z
+date: 2022-03-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,48 +16,48 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '5.2'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '5.2'
+        version: '7.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '5.2'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '5.2'
+        version: '7.1'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 10.4.2
+        version: 12.3.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 10.4.2
+        version: 12.3.3
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.14.0
+        version: 3.9.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.14.0
+        version: 3.9.0
 description: Provides a database-friendly method for polymorphic relationships
 email: bsingh@wegowise.com
 executables: []
@@ -73,13 +73,11 @@ files:
 - lib/polymorpheus/adapter.rb
 - lib/polymorpheus/interface.rb
 - lib/polymorpheus/interface/belongs_to_polymorphic.rb
-- lib/polymorpheus/interface/rails3/has_many_as_polymorph.rb
-- lib/polymorpheus/interface/rails4/has_many_as_polymorph.rb
+- lib/polymorpheus/interface/has_many_as_polymorph.rb
 - lib/polymorpheus/interface/validates_polymorph.rb
 - lib/polymorpheus/interface_builder.rb
 - lib/polymorpheus/interface_builder/association.rb
 - lib/polymorpheus/mysql_adapter.rb
-- lib/polymorpheus/mysql_adapter/foreigner_constraints.rb
 - lib/polymorpheus/postgresql_adapter.rb
 - lib/polymorpheus/railtie.rb
 - lib/polymorpheus/schema_dumper.rb
@@ -94,19 +92,18 @@ files:
 - spec/mysql2_adapter_spec.rb
 - spec/schema_dumper_spec.rb
 - spec/spec_helper.rb
-- spec/support/active_record/connection_adapters/abstract_mysql_adapter.rb
 - spec/support/class_defs.rb
 - spec/support/connection_helpers.rb
 - spec/support/custom_matchers.rb
 - spec/support/schema_helpers.rb
-- spec/support/sql_logger.rb
+- spec/support/sql_query_subscriber.rb
 - spec/support/sql_test_helpers.rb
 - spec/trigger_spec.rb
 homepage: http://github.com/wegowise/polymorpheus
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -114,16 +111,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.12
-signing_key: 
+rubygems_version: 3.3.6
+signing_key:
 specification_version: 4
 summary: Provides a database-friendly method for polymorphic relationships
 test_files: []

data/lib/polymorpheus/interface/rails3/has_many_as_polymorph.rb

@@ -1,29 +0,0 @@
-module Polymorpheus
-  module Interface
-    module HasManyAsPolymorph
-      def has_many_as_polymorph(association, options = {})
-        options.symbolize_keys!
-        fkey = name.foreign_key
-
-        class_name = options[:class_name] || association.to_s.classify
-
-        options[:conditions] = proc do
-          keys = class_name.constantize
-                  .const_get('POLYMORPHEUS_ASSOCIATIONS')
-                  .map(&:foreign_key)
-          keys.delete(fkey)
-
-          nil_columns = keys.reduce({}) { |hash, key| hash.merge!(key => nil) }
-
-          if self.is_a?(ActiveRecord::Associations::JoinDependency::JoinAssociation)
-            { aliased_table_name => nil_columns }
-          else
-            { association => nil_columns }
-          end
-        end
-
-        has_many association, options
-      end
-    end
-  end
-end

data/lib/polymorpheus/mysql_adapter/foreigner_constraints.rb

@@ -1,30 +0,0 @@
-module Polymorpheus
-  module ConnectionAdapters
-    module MysqlAdapter
-      def generate_constraints(options)
-        constraints = []
-
-        ['delete', 'update'].each do |event|
-          option = "on_#{event}".to_sym
-          next unless options.has_key?(option) &&
-                      options[option].respond_to?(:to_sym)
-
-          action = case options[option].to_sym
-            when :nullify then 'SET NULL'
-            when :cascade then 'CASCADE'
-            when :restrict then 'RESTRICT'
-            else
-              fail ArgumentError, <<-EOS
-'#{options[option]}' is not supported for :on_update or :on_delete.
-Supported values are: :nullify, :cascade, :restrict
-              EOS
-          end
-
-          constraints << "ON #{event.upcase} #{action}"
-        end
-
-        { :options => constraints.join(' ') }
-      end
-    end
-  end
-end

data/spec/support/active_record/connection_adapters/abstract_mysql_adapter.rb

@@ -1,9 +0,0 @@
-# Patch support for MySQL 5.7+ onto ActiveRecord < 4.1.
-if ActiveRecord::VERSION::MAJOR < 4 ||
-   (ActiveRecord::VERSION::MAJOR == 4 && ActiveRecord::VERSION::MINOR < 1)
-
-  require 'active_record/connection_adapters/abstract_mysql_adapter'
-  class ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter
-    NATIVE_DATABASE_TYPES[:primary_key] = "int(11) auto_increment PRIMARY KEY"
-  end
-end

data/spec/support/sql_logger.rb

@@ -1,30 +0,0 @@
-module Polymorpheus
-  module SqlLogger
-
-    def sql_statements
-      @sql_statements ||= []
-    end
-
-    def clear_sql_history
-      @sql_statements = nil
-    end
-
-    def stub_sql(statement, response)
-      @stubbed ||= {}
-      @stubbed[statement] = response
-    end
-
-    private
-
-    def log_sql_statements(sql, name = nil)
-      if @stubbed && @stubbed.has_key?(sql)
-        @stubbed[sql]
-      else
-        sql_statements << sql
-        original_execute(sql, name)
-      end
-    end
-
-  end
-end
-