store_base_sti_class 1.0.0 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 8a8f045c90c480e658eb8ac2a877d4bfb31fd01c
-  data.tar.gz: 9f1e796ef7836c594fea2e9a107939771e2669dd
+SHA256:
+  metadata.gz: 59deb36c4e242478eb3aea835560dd54845a59120e798e7c3d2945609da51fc7
+  data.tar.gz: c2320ddcb07a37711a13dfe9d700da253c419f85a9aebec37a7c33c468fa0ac4
 SHA512:
-  metadata.gz: 39a2df8993be2a04d27b318dadd3d3bc23005c418828e587592f67946b2c144caebe0101606f722b196537a654d648d332e16ddc58a30504c132aec176fd7cf7
-  data.tar.gz: a901606a746a6c093e0086a5886d101099ae4d8a5aefca9f27cc6c5eeb99cfbd093b60192fc309f0094dafff3ff53ac405c0ccdf2f2d29522b84ee41b4124d6b
+  metadata.gz: 03e0e8037ed8d2642e239be605ea68e7fdd808c94e76741767c2d822b3045b814c04e24dff970188fd9a283e735eda67cd4f5334b347b9dab1f3d02fbd5fa957
+  data.tar.gz: 8314c4ff6de5199bdad4605ef5a042cdec5935f0e3102ed99637dd7e5d90c4616d8571eec34e64da758207e14834eb98ef05a3aa99503e8efbac3f408dc2af6c

data/Appraisals

@@ -1,56 +1,15 @@
-RAILS_VERSIONS = %w(
-  4.0.0
-  4.0.1
-  4.0.2
-  4.0.3
-  4.0.4
-  4.0.5
-  4.0.6
-  4.0.7
-  4.0.8
-  4.0.9
-  4.0.10
-  4.0.11
-  4.0.11.1
-  4.0.12
-  4.0.13
-  4.1.0
-  4.1.1
-  4.1.2
-  4.1.3
-  4.1.4
-  4.1.5
-  4.1.6
-  4.1.7
-  4.1.7.1
-  4.1.8
-  4.1.9
-  4.1.10
-  4.1.11
-  4.1.12
-  4.1.13
-  4.1.14
-  4.1.14.1
-  4.1.14.2
-  4.1.15
-  4.2.0
-  4.2.1
-  4.2.2
-  4.2.3
-  4.2.4
-  4.2.5
-  4.2.5.1
-  4.2.5.2
-  4.2.6
-  4.2.7
-  4.2.7.1
-  5.0.0
-  5.0.0.1
-  5.0.1
-)
+RAILS_VERSIONS = %w[
+  5.0.7
+  5.1.7
+  5.2.3
+  5.2.4
+  6.0.3
+  6.1.0
+].freeze
 
 RAILS_VERSIONS.each do |version|
   appraise "rails_#{version}" do
     gem 'activerecord', version
+    gem 'sqlite3', ['6.0.3', '6.1.0'].include?(version) ? '~> 1.4.0' : '~> 1.3.0'
   end
 end

data/Gemfile.lock

@@ -1,40 +1,36 @@
 PATH
   remote: .
   specs:
-    store_base_sti_class (1.0.0)
+    store_base_sti_class (2.0.2)
       activerecord (>= 4.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activemodel (4.2.6)
-      activesupport (= 4.2.6)
-      builder (~> 3.1)
-    activerecord (4.2.6)
-      activemodel (= 4.2.6)
-      activesupport (= 4.2.6)
-      arel (~> 6.0)
-    activesupport (4.2.6)
-      i18n (~> 0.7)
-      json (~> 1.7, >= 1.7.7)
-      minitest (~> 5.1)
-      thread_safe (~> 0.3, >= 0.3.4)
-      tzinfo (~> 1.1)
-    appraisal (2.1.0)
+    activemodel (6.1.0)
+      activesupport (= 6.1.0)
+    activerecord (6.1.0)
+      activemodel (= 6.1.0)
+      activesupport (= 6.1.0)
+    activesupport (6.1.0)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
+    appraisal (2.3.0)
       bundler
       rake
       thor (>= 0.14.0)
-    arel (6.0.4)
-    builder (3.2.3)
-    i18n (0.8.0)
-    json (1.8.6)
-    minitest (5.8.4)
-    rake (11.1.2)
-    sqlite3 (1.3.11)
-    thor (0.19.1)
-    thread_safe (0.3.5)
-    tzinfo (1.2.2)
-      thread_safe (~> 0.1)
+    concurrent-ruby (1.1.7)
+    i18n (1.8.5)
+      concurrent-ruby (~> 1.0)
+    minitest (5.14.2)
+    rake (13.0.1)
+    thor (1.0.1)
+    tzinfo (2.0.3)
+      concurrent-ruby (~> 1.0)
+    zeitwerk (2.4.2)
 
 PLATFORMS
   ruby
@@ -43,5 +39,7 @@ DEPENDENCIES
   appraisal
   bundler
   minitest (>= 4.0)
-  sqlite3
   store_base_sti_class!
+
+BUNDLED WITH
+   2.1.4

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2011-2015 AppFolio, inc.
+Copyright (c) 2011-2019 AppFolio, inc.
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,4 +1,5 @@
-[![Build Status](https://travis-ci.org/appfolio/store_base_sti_class.svg?branch=master)](https://travis-ci.org/appfolio/store_base_sti_class)
+[![CI](https://github.com/appfolio/store_base_sti_class/workflows/CI/badge.svg)](https://github.com/appfolio/store_base_sti_class/actions)
+
 ## Description
 
 Given the following class definitions:
@@ -35,12 +36,18 @@ will output:
 
 Notice that addressable_type column is Person even though the actual class is Vendor.
 
-Normally, this isn't a problem, however, it can have negative performance characteristics in certain circumstances. The most obvious one is that
-a join with persons or an extra query is required to find out the actual type of addressable.
+Normally, this isn't a problem, however, it can have negative performance
+characteristics in certain circumstances. The most obvious one is that a join
+with persons or an extra query is required to find out the actual type of
+addressable.
 
-This gem adds the ActiveRecord::Base.store_base_sti_class configuration option. It defaults to true for backwards compatibility. Setting it to false will alter ActiveRecord's behavior to store the actual class in polymorphic _type columns when STI is used.
+This gem adds the ActiveRecord::Base.store_base_sti_class configuration
+option. It defaults to true for backwards compatibility. Setting it to false
+will alter ActiveRecord's behavior to store the actual class in polymorphic
+_type columns when STI is used.
 
 In the example above, if the ActiveRecord::Base.store_base_sti_class is false, the output will be,
+
 ```
   #<Vendor id: 1, type: "Vendor" ...>
   #<Address id: 1, addressable_id: 1, addressable_type: 'Vendor' ...>
@@ -54,21 +61,41 @@ Add the following line to your Gemfile,
 gem 'store_base_sti_class'
 ```
 
-then bundle install. Once you have the gem installed, add the following to one of the initializers (or make a new one) in config/initializers,
+then bundle install. Once you have the gem installed, add the following to one
+of the initializers (or make a new one) in config/initializers,
 
-  ActiveRecord::Base.store_base_sti_class = false
+    ActiveRecord::Base.store_base_sti_class = false
 
-When changing this behavior, you will have write a migration to update all of your existing _type columns accordingly. You may also need to change your application if it explicitly relies on the _type columns.
+When changing this behavior, you will have write a migration to update all of
+your existing _type columns accordingly. You may also need to change your
+application if it explicitly relies on the _type columns.
 
 ## Notes
 
 This gem incorporates work from:
+
 - https://github.com/codepodu/store_base_sti_class_for_4_0
 
-It currently works with ActiveRecord 4.0.x through 5.0.x. If you need support for ActiveRecord 3.x, use a pre-1.0 version of the gem.
+It currently works with ActiveRecord 4.2.x through 6.0.x. If you need support
+for ActiveRecord 3.x, use a pre-1.0 version of the gem, or ActiveRecord < 4.2
+use a pre-2.0 version of the gem.
+
+## Conflicts
+
+This gem produces known conflicts with these other gems:
+
+### friendly_id
+
+When using [friendly_id](https://github.com/norman/friendly_id) >= 5.2.5 with the [History module](https://norman.github.io/friendly_id/FriendlyId/History.html) enabled, duplicate slugs will be generated for STI subclasses with the same sluggable identifier (ex: name). This will either cause saves to fail if you have the proper indexes in place, or will cause slug lookups to be non-deterministic, either of which is undesirable.
+
+## History
+
+* https://github.com/rails/rails/issues/724
+* https://github.com/rails/rails/issues/5441#issuecomment-4563865
+* https://github.com/rails/rails/issues/4729#issuecomment-5729297
+* https://github.com/rails/rails/issues/5441#issuecomment-264871920
 
 ## Copyright
 
-Copyright (c) 2011-2017 AppFolio, inc. See LICENSE.txt for
+Copyright (c) 2011-2019 AppFolio, inc. See LICENSE.txt for
 further details.
-

data/gemfiles/rails_5.0.7.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "5.0.7"
+gem "sqlite3", "~> 1.3.0"
+
+gemspec path: "../"

data/gemfiles/rails_5.1.7.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "5.1.7"
+gem "sqlite3", "~> 1.3.0"
+
+gemspec path: "../"

data/gemfiles/rails_5.2.3.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "5.2.3"
+gem "sqlite3", "~> 1.3.0"
+
+gemspec path: "../"

data/gemfiles/rails_5.2.4.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "5.2.4"
+gem "sqlite3", "~> 1.3.0"
+
+gemspec path: "../"

data/gemfiles/rails_6.0.3.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "6.0.3"
+gem "sqlite3", "~> 1.4.0"
+
+gemspec path: "../"

data/gemfiles/rails_6.1.0.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "6.1.0"
+gem "sqlite3", "~> 1.4.0"
+
+gemspec path: "../"

data/lib/store_base_sti_class.rb

@@ -1,13 +1,15 @@
 require 'active_record'
 
-if ActiveRecord::VERSION::STRING =~ /^4\.0/
-  require 'store_base_sti_class_for_4_0'
-elsif ActiveRecord::VERSION::STRING =~ /^4\.1/
-  require 'store_base_sti_class_for_4_1'
-elsif ActiveRecord::VERSION::STRING =~ /^4\.2/
-  require 'store_base_sti_class_for_4_2'
-elsif ActiveRecord::VERSION::STRING =~ /^5\.0/
+if ActiveRecord::VERSION::STRING =~ /^5\.0/
   require 'store_base_sti_class_for_5_0'
+elsif ActiveRecord::VERSION::STRING =~ /^5\.1/
+  require 'store_base_sti_class_for_5_1'
+elsif ActiveRecord::VERSION::STRING =~ /^5\.2/
+  require 'store_base_sti_class_for_5_2'
+elsif ActiveRecord::VERSION::STRING =~ /^6\.0/
+  require 'store_base_sti_class_for_6_0'
+elsif ActiveRecord::VERSION::STRING =~ /^6\.1/
+  require 'store_base_sti_class_for_6_1'
 end
 
 module StoreBaseSTIClass

data/lib/store_base_sti_class/version.rb

@@ -1,3 +1,3 @@
 module StoreBaseSTIClass
-  VERSION = '1.0.0'.freeze
+  VERSION = '2.0.2'.freeze
 end

data/lib/store_base_sti_class_for_5_0.rb

@@ -8,6 +8,22 @@ if ActiveRecord::VERSION::STRING =~ /^5\.0/
       self.store_base_sti_class = true
     end
 
+    class PredicateBuilder
+      class AssociationQueryHandler
+        def call(attribute, value)
+          queries = {}
+
+          table = value.associated_table
+          if value.base_class
+            queries[table.association_foreign_type.to_s] = ActiveRecord::Base.store_base_sti_class ? value.base_class.name : value.value.class.name
+          end
+
+          queries[table.association_foreign_key.to_s] = value.ids
+          predicate_builder.build_from_hash(queries)
+        end
+      end
+    end
+
     module Associations
       class Association
         private

data/lib/{store_base_sti_class_for_4_2.rb → store_base_sti_class_for_5_1.rb}

@@ -1,6 +1,6 @@
 require 'active_record/associations/join_dependency/join_part'
 
-if ActiveRecord::VERSION::STRING =~ /^4\.2/
+if ActiveRecord::VERSION::STRING =~ /^5\.1/
   module ActiveRecord
 
     class Base
@@ -8,8 +8,25 @@ if ActiveRecord::VERSION::STRING =~ /^4\.2/
       self.store_base_sti_class = true
     end
 
+    class PredicateBuilder
+      class AssociationQueryHandler
+        def call(attribute, value)
+          queries = {}
+
+          table = value.associated_table
+          if value.base_class
+            queries[table.association_foreign_type.to_s] = ActiveRecord::Base.store_base_sti_class ? value.base_class.name : value.value.class.name
+          end
+
+          queries[table.association_foreign_key.to_s] = value.ids
+          predicate_builder.build_from_hash(queries)
+        end
+      end
+    end
+
     module Associations
       class Association
+        private
 
         def creation_attributes
           attributes = {}
@@ -33,43 +50,35 @@ if ActiveRecord::VERSION::STRING =~ /^4\.2/
 
       class JoinDependency # :nodoc:
         class JoinAssociation < JoinPart # :nodoc:
-          def join_constraints(foreign_table, foreign_klass, node, join_type, tables, scope_chain, chain)
+          def join_constraints(foreign_table, foreign_klass, join_type, tables, chain)
             joins         = []
-            bind_values   = []
+            binds         = []
             tables        = tables.reverse
 
-            scope_chain_index = 0
-            scope_chain = scope_chain.reverse
-
             # The chain starts with the target table, but we want to end with it here (makes
             # more sense in this context), so we reverse
             chain.reverse_each do |reflection|
               table = tables.shift
               klass = reflection.klass
 
-              join_keys   = reflection.join_keys(klass)
+              join_keys   = reflection.join_keys
               key         = join_keys.key
               foreign_key = join_keys.foreign_key
 
               constraint = build_constraint(klass, table, key, foreign_table, foreign_key)
 
-              scope_chain_items = scope_chain[scope_chain_index].map do |item|
-                if item.is_a?(Relation)
-                  item
-                else
-                  ActiveRecord::Relation.create(klass, table).instance_exec(node, &item)
-                end
-              end
-              scope_chain_index += 1
+              predicate_builder = PredicateBuilder.new(TableMetadata.new(klass, table))
+              scope_chain_items = reflection.join_scopes(table, predicate_builder)
+              klass_scope       = reflection.klass_join_scope(table, predicate_builder)
 
-              scope_chain_items.concat [klass.send(:build_default_scope, ActiveRecord::Relation.create(klass, table))].compact
+              scope_chain_items.concat [klass_scope].compact
 
               rel = scope_chain_items.inject(scope_chain_items.shift) do |left, right|
                 left.merge right
               end
 
               if rel && !rel.arel.constraints.empty?
-                bind_values.concat rel.bind_values
+                binds += rel.bound_attributes
                 constraint = constraint.and rel.arel.constraints
               end
 
@@ -81,9 +90,8 @@ if ActiveRecord::VERSION::STRING =~ /^4\.2/
                 # END PATCH
                 column = klass.columns_hash[reflection.type.to_s]
 
-                substitute = klass.connection.substitute_at(column)
-                bind_values.push [column, value]
-                constraint = constraint.and table[reflection.type].eq substitute
+                binds << Relation::QueryAttribute.new(column.name, value, klass.type_for_attribute(column.name))
+                constraint = constraint.and klass.arel_attribute(reflection.type, table).eq(Arel::Nodes::BindParam.new)
               end
 
               joins << table.create_join(table, table.create_on(constraint), join_type)
@@ -92,7 +100,7 @@ if ActiveRecord::VERSION::STRING =~ /^4\.2/
               foreign_table, foreign_klass = table, klass
             end
 
-            JoinInformation.new joins, bind_values
+            JoinInformation.new joins, binds
           end
         end
       end
@@ -115,23 +123,34 @@ if ActiveRecord::VERSION::STRING =~ /^4\.2/
 
       class Preloader
         class Association
+          private
 
           def build_scope
             scope = klass.unscoped
 
-            values         = reflection_scope.values
-            reflection_binds = reflection_scope.bind_values
+            values = reflection_scope.values
             preload_values = preload_scope.values
-            preload_binds  = preload_scope.bind_values
 
-            scope.where_values      = Array(values[:where])      + Array(preload_values[:where])
+            scope.where_clause = reflection_scope.where_clause + preload_scope.where_clause
             scope.references_values = Array(values[:references]) + Array(preload_values[:references])
-            scope.bind_values       = (reflection_binds + preload_binds)
 
-            scope._select!   preload_values[:select] || values[:select] || table[Arel.star]
+            if preload_values[:select] || values[:select]
+              scope._select!(preload_values[:select] || values[:select])
+            end
             scope.includes! preload_values[:includes] || values[:includes]
-            scope.joins! preload_values[:joins] || values[:joins]
-            scope.order! preload_values[:order] || values[:order]
+            if preload_scope.joins_values.any?
+              scope.joins!(preload_scope.joins_values)
+            else
+              scope.joins!(reflection_scope.joins_values)
+            end
+
+            if order_values = preload_values[:order] || values[:order]
+              scope.order!(order_values)
+            end
+
+            if preload_values[:reordering] || values[:reordering]
+              scope.reordering_value = true
+            end
 
             if preload_values[:readonly] || values[:readonly]
               scope.readonly!
@@ -147,7 +166,7 @@ if ActiveRecord::VERSION::STRING =~ /^4\.2/
               # END PATCH
             end
 
-            scope.unscope_values = Array(values[:unscope])
+            scope.unscope_values = Array(values[:unscope]) + Array(preload_values[:unscope])
             klass.default_scoped.merge(scope)
           end
         end
@@ -162,24 +181,26 @@ if ActiveRecord::VERSION::STRING =~ /^4\.2/
               # BEGIN PATCH
               # original: scope.where! reflection.foreign_type => options[:source_type]
 
-              adjusted_foreign_type = if ActiveRecord::Base.store_base_sti_class
-                options[:source_type]
-              else
-                ([options[:source_type].constantize] + options[:source_type].constantize.descendants).map(&:to_s)
-              end
+              adjusted_foreign_type =
+                if ActiveRecord::Base.store_base_sti_class
+                  options[:source_type]
+                else
+                  ([options[:source_type].constantize] + options[:source_type].constantize.descendants).map(&:to_s)
+                end
 
               scope.where! reflection.foreign_type => adjusted_foreign_type
 
               # END PATCH
             else
-              unless reflection_scope.where_values.empty?
+              unless reflection_scope.where_clause.empty?
                 scope.includes_values = Array(reflection_scope.values[:includes] || options[:source])
-                scope.where_values    = reflection_scope.values[:where]
-                scope.bind_values     = reflection_scope.bind_values
+                scope.where_clause = reflection_scope.where_clause
               end
 
               scope.references! reflection_scope.values[:references]
-              scope = scope.order reflection_scope.values[:order] if scope.eager_loading?
+              if scope.eager_loading? && order_values = reflection_scope.values[:order]
+                scope = scope.order(order_values)
+              end
             end
 
             scope
@@ -188,6 +209,7 @@ if ActiveRecord::VERSION::STRING =~ /^4\.2/
       end
 
       class AssociationScope
+
         def self.get_bind_values(owner, chain)
           binds = []
           last_reflection = chain.last
@@ -211,8 +233,10 @@ if ActiveRecord::VERSION::STRING =~ /^4\.2/
           binds
         end
 
-        def next_chain_scope(scope, table, reflection, tracker, assoc_klass, foreign_table, next_reflection)
-          join_keys = reflection.join_keys(assoc_klass)
+        private
+
+        def next_chain_scope(scope, table, reflection, foreign_table, next_reflection)
+          join_keys = reflection.join_keys
           key = join_keys.key
           foreign_key = join_keys.foreign_key
 
@@ -220,49 +244,46 @@ if ActiveRecord::VERSION::STRING =~ /^4\.2/
 
           if reflection.type
             # BEGIN PATCH
-            # original: 
-            # value    = next_reflection.klass.base_class.name
-            # bind_val = bind scope, table.table_name, reflection.type, value, tracker
-            # scope    = scope.where(table[reflection.type].eq(bind_val))
+            # original:
+            # value = transform_value(next_reflection.klass.base_class.name)
+            # scope = scope.where(table.name => { reflection.type => value })
             if ActiveRecord::Base.store_base_sti_class
-              value    = next_reflection.klass.base_class.name
-              bind_val = bind scope, table.table_name, reflection.type, value, tracker
-              scope    = scope.where(table[reflection.type].eq(bind_val))
+              value = transform_value(next_reflection.klass.base_class.name)
             else
-              value    = next_reflection.klass.name
-              klass    = next_reflection.klass
-              scope    = scope.where(table[reflection.type].in(([klass] + klass.descendants).map(&:name)))
+              klass = next_reflection.klass
+              value = ([klass] + klass.descendants).map(&:name)
             end
+            scope = scope.where(table.name => { reflection.type => value })
             # END PATCH
-            
           end
 
           scope = scope.joins(join(foreign_table, constraint))
         end
 
-        def last_chain_scope(scope, table, reflection, owner, tracker, assoc_klass)
-          join_keys = reflection.join_keys(assoc_klass)
+        def last_chain_scope(scope, table, reflection, owner)
+          join_keys = reflection.join_keys
           key = join_keys.key
           foreign_key = join_keys.foreign_key
 
-          bind_val = bind scope, table.table_name, key.to_s, owner[foreign_key], tracker
-          scope    = scope.where(table[key].eq(bind_val))
+          value = transform_value(owner[foreign_key])
+          scope = scope.where(table.name => { key => value })
 
           if reflection.type
             # BEGIN PATCH
-            # original: owner.class.base_class.name
-            value    = ActiveRecord::Base.store_base_sti_class ? owner.class.base_class.name : owner.class.name
+            # polymorphic_type = transform_value(owner.class.base_class.name)
+            polymorphic_type = transform_value(ActiveRecord::Base.store_base_sti_class ? owner.class.base_class.name : owner.class.name)
             # END PATCH
-            bind_val = bind scope, table.table_name, reflection.type, value, tracker
-            scope    = scope.where(table[reflection.type].eq(bind_val))
-          else
-            scope
+            scope = scope.where(table.name => { reflection.type => polymorphic_type })
           end
+
+          scope
         end
-        
+
       end
 
       module ThroughAssociation
+        private
+
         def construct_join_attributes(*records)
           ensure_mutable
 
@@ -296,10 +317,10 @@ if ActiveRecord::VERSION::STRING =~ /^4\.2/
             join_attributes
           end
         end
-
       end
 
       class HasManyThroughAssociation
+        private
 
         def build_through_record(record)
           @through_records[record.object_id] ||= begin
@@ -323,37 +344,23 @@ if ActiveRecord::VERSION::STRING =~ /^4\.2/
     end
 
     module Reflection
-      class ThroughReflection
-        def scope_chain
-          @scope_chain ||= begin
-            scope_chain = source_reflection.scope_chain.map(&:dup)
+      class PolymorphicReflection
+        def source_type_info
+          type = @previous_reflection.foreign_type
+          source_type = @previous_reflection.options[:source_type]
 
-            # Add to it the scope from this reflection (if any)
-            scope_chain.first << scope if scope
-
-            through_scope_chain = through_reflection.scope_chain.map(&:dup)
-
-            if options[:source_type]
-              type = foreign_type
-              # START PATCH
-              # original: source_type = options[:source_type]
-              source_type = if ActiveRecord::Base.store_base_sti_class
-                options[:source_type]
-              else
-                ([options[:source_type].constantize] + options[:source_type].constantize.descendants).map(&:to_s)
-              end
-              # END PATCH
-              through_scope_chain.first << lambda { |object|
-                where(type => source_type)
-              }
+          # START PATCH
+          adjusted_source_type =
+            if ActiveRecord::Base.store_base_sti_class
+              source_type
+            else
+              ([source_type.constantize] + source_type.constantize.descendants).map(&:to_s)
             end
+          # END PATCH
 
-            # Recursively fill out the rest of the array from the through reflection
-            scope_chain + through_scope_chain
-          end
+          lambda { |object| where(type => adjusted_source_type) }
         end
       end
-
     end
   end