Ensure uniquness validation matcher works with STI

The uniqueness validation matcher generates a fake class when the
scope name ends on _type. This fake class is a duplicate of the
original class. In most cases this is not a problem, however when
using single table inheritance (STI), this new fake class is not
a subclass of the original class and therefore ActiveRecord will
throw an error. See thoughtbot#1245

A similar thing happens when the original class is using an AASM
state machine. The state machine settings are stored in a global
registry. So when the fake class is initialized, AASM cannot find
the settings of the set state machines (due to duplication) in the
registry. See thoughtbot#854

These problems are fixed by making the fake class inherrit from the
original class. Therefore it closes thoughtbot#1245 and closes thoughtbot#854

gemfiles/rails_5_2.gemfile

@@ -36,3 +36,4 @@ gem "listen", "~> 3.0.5"
 gem "spring-watcher-listen", "~> 2.0.0"
 gem "pg", "~> 0.18"
 gem "sqlite3", "~> 1.3.6"
+gem "aasm"

gemfiles/rails_6_0.gemfile

@@ -37,3 +37,4 @@ gem "webdrivers"
 gem "actiontext", "~> 6.0.4"
 gem "pg", ">= 0.18", "< 2.0"
 gem "sqlite3", "~> 1.4"
+gem "aasm"

gemfiles/rails_6_0.gemfile.lock

@@ -1,6 +1,8 @@
 GEM
   remote: https://rubygems.org/
   specs:
+    aasm (5.2.0)
+      concurrent-ruby (~> 1.0)
     actioncable (6.0.4)
       actionpack (= 6.0.4)
       nio4r (~> 2.0)
@@ -260,6 +262,7 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
+  aasm
   actiontext (~> 6.0.4)
   appraisal (= 2.2.0)
   bcrypt (~> 3.1.7)

lib/shoulda/matchers/active_record/uniqueness/model.rb

@@ -29,7 +29,7 @@ def next
           end
 
           def symlink_to(parent)
-            namespace.set(name, parent.dup)
+            namespace.set(name, Class.new(parent))
           end
 
           def to_s

spec/support/unit/model_creation_strategies/active_record.rb

@@ -74,7 +74,7 @@ def class_name
       end
 
       def table_name
-        class_name.tableize.gsub('/', '_')
+        options.fetch(:table_name, class_name.tableize.gsub('/', '_'))
       end
 
       def parent_class

spec/unit/shoulda/matchers/active_record/validate_uniqueness_of_matcher_spec.rb

@@ -1292,6 +1292,66 @@ def configure_validation_matcher(matcher)
           scoped_to(:favoriteable_type)
       end
     end
+
+    context 'if the model the *_type column refers to is using AASM state machines' do
+      it 'still works' do
+        require 'aasm'
+        user_columns = {
+          aasm_state: { type: :string },
+        }
+        user_model = define_model 'User', user_columns do
+          include AASM
+          aasm do
+            state :foo, :bar
+          end
+        end
+        favorite_columns = {
+          favoriteable_id: { type: :integer, options: { null: false } },
+          favoriteable_type: { type: :string, options: { null: false } },
+        }
+        favorite_model = define_model 'Favorite', favorite_columns do
+          belongs_to :favoriteable, polymorphic: true
+          validates :favoriteable, presence: true
+          validates :favoriteable_id, uniqueness: { scope: :favoriteable_type }
+        end
+
+        user = user_model.create!
+        favorite_model.create!(favoriteable: user)
+        new_favorite = favorite_model.new
+
+        expect(new_favorite).
+          to validate_uniqueness_of(:favoriteable_id).
+          scoped_to(:favoriteable_type)
+      end
+    end
+
+    context 'if the model the *_type column refers to an STI class' do
+      it 'still works' do
+        animal_columns = {
+          type: { type: :string, options: { null: false } },
+        }
+        animal_model = define_model 'Animal', animal_columns do
+          has_many :classifications, as: :classifiable
+        end
+        bird_model = define_model 'Bird', animal_columns, parent_class: animal_model, table_name: 'animals'
+
+        classification_columns = {
+          classifiable_id: { type: :integer },
+          classifiable_type: { type: :string },
+        }
+        classification_model = define_model 'Classification', classification_columns do
+          belongs_to :classifiable, polymorphic: true
+          validates :classifiable_id, uniqueness: { scope: :classifiable_type }
+        end
+
+        bird = bird_model.create!
+        classification = classification_model.new(classifiable: bird)
+
+        expect(classification).
+          to validate_uniqueness_of(:classifiable_id).
+          scoped_to(:classifiable_type)
+      end
+    end
   end
 
   context 'when the model does not have the attribute being tested' do