store_base_sti_class 2.0.1 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d905b8e881303f37a959af003a8ae10b9a8c47d936a6adb9afc75bf149dbbd68
-  data.tar.gz: 53baeb1bf2222de935343215b1bfa036d3cbd4c26ae6087ead371e0918e11754
+  metadata.gz: 59deb36c4e242478eb3aea835560dd54845a59120e798e7c3d2945609da51fc7
+  data.tar.gz: c2320ddcb07a37711a13dfe9d700da253c419f85a9aebec37a7c33c468fa0ac4
 SHA512:
-  metadata.gz: 285c2c32254eb69039e4cc5337065dcde7f1a99f65fdc6902e1027e6dbd380a36bd488ae87c0e5b2c718d463ce0f4a5fb82f1993246bab4f7ccee0ca2914c2ab
-  data.tar.gz: 9be85dd36e7ed71a298d95dc434940e73a05de94d798d21cf46d9b805a683129272ee07688e684c056a46bc7ce9321e06a6f2ece71f2f4219eeab11f902ef1f9
+  metadata.gz: 03e0e8037ed8d2642e239be605ea68e7fdd808c94e76741767c2d822b3045b814c04e24dff970188fd9a283e735eda67cd4f5334b347b9dab1f3d02fbd5fa957
+  data.tar.gz: 8314c4ff6de5199bdad4605ef5a042cdec5935f0e3102ed99637dd7e5d90c4616d8571eec34e64da758207e14834eb98ef05a3aa99503e8efbac3f408dc2af6c

data/Appraisals

@@ -1,15 +1,15 @@
 RAILS_VERSIONS = %w[
-  4.2.11
   5.0.7
-  5.1.6
+  5.1.7
   5.2.3
   5.2.4
-  6.0.1
+  6.0.3
+  6.1.0
 ].freeze
 
 RAILS_VERSIONS.each do |version|
   appraise "rails_#{version}" do
     gem 'activerecord', version
-    gem 'sqlite3', version == '6.0.1' ? '~> 1.4.0' : '~> 1.3.0'
+    gem 'sqlite3', ['6.0.3', '6.1.0'].include?(version) ? '~> 1.4.0' : '~> 1.3.0'
   end
 end

data/Gemfile.lock

@@ -1,37 +1,36 @@
 PATH
   remote: .
   specs:
-    store_base_sti_class (2.0.0)
+    store_base_sti_class (2.0.2)
       activerecord (>= 4.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activemodel (6.0.1)
-      activesupport (= 6.0.1)
-    activerecord (6.0.1)
-      activemodel (= 6.0.1)
-      activesupport (= 6.0.1)
-    activesupport (6.0.1)
+    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 (>= 0.7, < 2)
-      minitest (~> 5.1)
-      tzinfo (~> 1.1)
-      zeitwerk (~> 2.2)
-    appraisal (2.2.0)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
+    appraisal (2.3.0)
       bundler
       rake
       thor (>= 0.14.0)
-    concurrent-ruby (1.1.5)
-    i18n (1.7.0)
+    concurrent-ruby (1.1.7)
+    i18n (1.8.5)
       concurrent-ruby (~> 1.0)
-    minitest (5.13.0)
+    minitest (5.14.2)
     rake (13.0.1)
-    thor (0.20.3)
-    thread_safe (0.3.6)
-    tzinfo (1.2.5)
-      thread_safe (~> 0.1)
-    zeitwerk (2.2.1)
+    thor (1.0.1)
+    tzinfo (2.0.3)
+      concurrent-ruby (~> 1.0)
+    zeitwerk (2.4.2)
 
 PLATFORMS
   ruby
@@ -43,4 +42,4 @@ DEPENDENCIES
   store_base_sti_class!
 
 BUNDLED WITH
-   1.17.2
+   2.1.4

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:
@@ -79,6 +80,21 @@ 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-2019 AppFolio, inc. See LICENSE.txt for

data/gemfiles/{rails_5.1.6.gemfile → rails_5.1.7.gemfile}

@@ -2,7 +2,7 @@
 
 source "https://rubygems.org"
 
-gem "activerecord", "5.1.6"
+gem "activerecord", "5.1.7"
 gem "sqlite3", "~> 1.3.0"
 
 gemspec path: "../"

data/gemfiles/{rails_6.0.1.gemfile → rails_6.0.3.gemfile}

@@ -2,7 +2,7 @@
 
 source "https://rubygems.org"
 
-gem "activerecord", "6.0.1"
+gem "activerecord", "6.0.3"
 gem "sqlite3", "~> 1.4.0"
 
 gemspec path: "../"

data/gemfiles/{rails_4.2.11.gemfile → rails_6.1.0.gemfile}

@@ -2,7 +2,7 @@
 
 source "https://rubygems.org"
 
-gem "activerecord", "4.2.11"
-gem "sqlite3", "~> 1.3.0"
+gem "activerecord", "6.1.0"
+gem "sqlite3", "~> 1.4.0"
 
 gemspec path: "../"

data/lib/store_base_sti_class.rb

@@ -1,8 +1,6 @@
 require 'active_record'
 
-if 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'
@@ -10,6 +8,8 @@ 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 = '2.0.1'.freeze
+  VERSION = '2.0.2'.freeze
 end

data/lib/store_base_sti_class_for_6_1.rb

@@ -0,0 +1,156 @@
+require 'active_record/associations/join_dependency/join_part'
+
+if ActiveRecord::VERSION::STRING =~ /^6\.1/
+  module ActiveRecord
+
+    class Base
+      class_attribute :store_base_sti_class
+      self.store_base_sti_class = true
+    end
+
+    module Inheritance
+      module ClassMethods
+        def polymorphic_name
+          ActiveRecord::Base.store_base_sti_class ? base_class.name : name
+        end
+      end
+    end
+
+    module Associations
+      class Preloader
+        class ThroughAssociation < Association
+          private
+
+          def through_scope
+            scope = through_reflection.klass.unscoped
+            options = reflection.options
+
+            values = reflection_scope.values
+            if annotations = values[:annotate]
+              scope.annotate!(*annotations)
+            end
+
+            if options[:source_type]
+              # 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
+
+              scope.where! reflection.foreign_type => adjusted_foreign_type
+              # END PATCH
+
+            elsif !reflection_scope.where_clause.empty?
+              scope.where_clause = reflection_scope.where_clause
+
+              if includes = values[:includes]
+                scope.includes!(source_reflection.name => includes)
+              else
+                scope.includes!(source_reflection.name)
+              end
+
+              if values[:references] && !values[:references].empty?
+                scope.references_values |= values[:references]
+              else
+                scope.references!(source_reflection.table_name)
+              end
+
+              if joins = values[:joins]
+                scope.joins!(source_reflection.name => joins)
+              end
+
+              if left_outer_joins = values[:left_outer_joins]
+                scope.left_outer_joins!(source_reflection.name => left_outer_joins)
+              end
+
+              if scope.eager_loading? && order_values = values[:order]
+                scope = scope.order(order_values)
+              end
+            end
+
+            scope
+          end
+        end
+      end
+
+      class AssociationScope
+        private
+
+        def next_chain_scope(scope, reflection, next_reflection)
+          primary_key = reflection.join_primary_key
+          foreign_key = reflection.join_foreign_key
+
+          table = reflection.aliased_table
+          foreign_table = next_reflection.aliased_table
+          constraint = table[primary_key].eq(foreign_table[foreign_key])
+
+          if reflection.type
+            # BEGIN PATCH
+            # original:
+            # value = transform_value(next_reflection.klass.polymorphic_name)
+            # scope = apply_scope(scope, table, reflection.type, value)
+
+            if ActiveRecord::Base.store_base_sti_class
+              value = transform_value(next_reflection.klass.polymorphic_name)
+            else
+              klass = next_reflection.klass
+              value = ([klass] + klass.descendants).map(&:name)
+            end
+            scope = apply_scope(scope, table, reflection.type, value)
+            # END PATCH
+          end
+
+          scope.joins!(join(foreign_table, constraint))
+        end
+
+      end
+
+      class HasManyThroughAssociation
+        private
+
+        def build_through_record(record)
+          @through_records[record.object_id] ||= begin
+            ensure_mutable
+
+            attributes = through_scope_attributes
+            attributes[source_reflection.name] = record
+
+            # START PATCH
+            if ActiveRecord::Base.store_base_sti_class
+              attributes[source_reflection.foreign_type] = options[:source_type] if options[:source_type]
+            end
+            # END PATCH
+
+            through_association.build(attributes)
+          end
+        end
+      end
+    end
+
+    module Reflection
+      class PolymorphicReflection
+        def source_type_scope
+          type = @previous_reflection.foreign_type
+          source_type = @previous_reflection.options[: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
+
+          lambda { |object| where(type => adjusted_source_type) }
+        end
+      end
+    end
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: store_base_sti_class
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.0.2
 platform: ruby
 authors:
 - AppFolio
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-12-12 00:00:00.000000000 Z
+date: 2020-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -84,25 +84,25 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- gemfiles/rails_4.2.11.gemfile
 - gemfiles/rails_5.0.7.gemfile
-- gemfiles/rails_5.1.6.gemfile
+- gemfiles/rails_5.1.7.gemfile
 - gemfiles/rails_5.2.3.gemfile
 - gemfiles/rails_5.2.4.gemfile
-- gemfiles/rails_6.0.1.gemfile
+- gemfiles/rails_6.0.3.gemfile
+- gemfiles/rails_6.1.0.gemfile
 - lib/store_base_sti_class.rb
 - lib/store_base_sti_class/version.rb
-- lib/store_base_sti_class_for_4_2.rb
 - lib/store_base_sti_class_for_5_0.rb
 - lib/store_base_sti_class_for_5_1.rb
 - lib/store_base_sti_class_for_5_2.rb
 - lib/store_base_sti_class_for_6_0.rb
+- lib/store_base_sti_class_for_6_1.rb
 - store_base_sti_class.gemspec
 homepage: http://github.com/appfolio/store_base_sti_class
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -117,8 +117,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: Modifies ActiveRecord 4.2.x - 6.0.x with the ability to store the actual
   class (instead of the base class) in polymorhic _type columns when using STI

data/lib/store_base_sti_class_for_4_2.rb

@@ -1,360 +0,0 @@
-require 'active_record/associations/join_dependency/join_part'
-
-if ActiveRecord::VERSION::STRING =~ /^4\.2/
-  module ActiveRecord
-
-    class Base
-      class_attribute :store_base_sti_class
-      self.store_base_sti_class = true
-    end
-
-    module Associations
-      class Association
-
-        def creation_attributes
-          attributes = {}
-
-          if (reflection.has_one? || reflection.collection?) && !options[:through]
-            attributes[reflection.foreign_key] = owner[reflection.active_record_primary_key]
-
-            if reflection.options[:as]
-              # START PATCH
-              # original:
-              # attributes[reflection.type] = owner.class.base_class.name
-
-              attributes[reflection.type] = ActiveRecord::Base.store_base_sti_class ? owner.class.base_class.name : owner.class.name
-              # END PATCH
-            end
-          end
-
-          attributes
-        end
-      end
-
-      class JoinDependency # :nodoc:
-        class JoinAssociation < JoinPart # :nodoc:
-          def join_constraints(foreign_table, foreign_klass, node, join_type, tables, scope_chain, chain)
-            joins         = []
-            bind_values   = []
-            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)
-              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
-
-              scope_chain_items.concat [klass.send(:build_default_scope, ActiveRecord::Relation.create(klass, table))].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
-                constraint = constraint.and rel.arel.constraints
-              end
-
-              if reflection.type
-                # START PATCH
-                # original:
-                # value = foreign_klass.base_class.name
-                value = ActiveRecord::Base.store_base_sti_class ? foreign_klass.base_class.name : foreign_klass.name
-                # 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
-              end
-
-              joins << table.create_join(table, table.create_on(constraint), join_type)
-
-              # The current table in this iteration becomes the foreign table in the next
-              foreign_table, foreign_klass = table, klass
-            end
-
-            JoinInformation.new joins, bind_values
-          end
-        end
-      end
-
-      class BelongsToPolymorphicAssociation
-        private
-
-        def replace_keys(record)
-          super
-
-          # START PATCH
-          # original:
-          # owner[reflection.foreign_type] = record.class.base_class.name
-
-          owner[reflection.foreign_type] = ActiveRecord::Base.store_base_sti_class ? record.class.base_class.name : record.class.name
-
-          # END PATCH
-        end
-      end
-
-      class Preloader
-        class Association
-
-          def build_scope
-            scope = klass.unscoped
-
-            values         = reflection_scope.values
-            reflection_binds = reflection_scope.bind_values
-            preload_values = preload_scope.values
-            preload_binds  = preload_scope.bind_values
-
-            scope.where_values      = Array(values[:where])      + Array(preload_values[:where])
-            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]
-            scope.includes! preload_values[:includes] || values[:includes]
-            scope.joins! preload_values[:joins] || values[:joins]
-            scope.order! preload_values[:order] || values[:order]
-
-            if preload_values[:readonly] || values[:readonly]
-              scope.readonly!
-            end
-
-            if options[:as]
-              # START PATCH
-              # original:
-              # scope.where!(klass.table_name => { reflection.type => model.base_class.sti_name })
-
-              scope.where!(klass.table_name => { reflection.type => ActiveRecord::Base.store_base_sti_class ? model.base_class.sti_name : model.sti_name })
-
-              # END PATCH
-            end
-
-            scope.unscope_values = Array(values[:unscope])
-            klass.default_scoped.merge(scope)
-          end
-        end
-
-        module ThroughAssociation
-          private
-
-          def through_scope
-            scope = through_reflection.klass.unscoped
-
-            if options[:source_type]
-              # 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
-
-              scope.where! reflection.foreign_type => adjusted_foreign_type
-
-              # END PATCH
-            else
-              unless reflection_scope.where_values.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
-              end
-
-              scope.references! reflection_scope.values[:references]
-              scope = scope.order reflection_scope.values[:order] if scope.eager_loading?
-            end
-
-            scope
-          end
-        end
-      end
-
-      class AssociationScope
-        def self.get_bind_values(owner, chain)
-          binds = []
-          last_reflection = chain.last
-
-          binds << last_reflection.join_id_for(owner)
-          if last_reflection.type
-            # START PATCH
-            # original: binds << owner.class.base_class.name
-            binds << (ActiveRecord::Base.store_base_sti_class ? owner.class.base_class.name : owner.class.name)
-            # END PATCH
-          end
-
-          chain.each_cons(2).each do |reflection, next_reflection|
-            if reflection.type
-              # START PATCH
-              # original: binds << next_reflection.klass.base_class.name
-              binds << (ActiveRecord::Base.store_base_sti_class ? next_reflection.klass.base_class.name : next_reflection.klass.name)
-              # END PATCH
-            end
-          end
-          binds
-        end
-
-        def next_chain_scope(scope, table, reflection, tracker, assoc_klass, foreign_table, next_reflection)
-          join_keys = reflection.join_keys(assoc_klass)
-          key = join_keys.key
-          foreign_key = join_keys.foreign_key
-
-          constraint = table[key].eq(foreign_table[foreign_key])
-
-          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))
-            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))
-            else
-              value    = next_reflection.klass.name
-              klass    = next_reflection.klass
-              scope    = scope.where(table[reflection.type].in(([klass] + klass.descendants).map(&:name)))
-            end
-            # 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)
-          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))
-
-          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
-            # END PATCH
-            bind_val = bind scope, table.table_name, reflection.type, value, tracker
-            scope    = scope.where(table[reflection.type].eq(bind_val))
-          else
-            scope
-          end
-        end
-        
-      end
-
-      module ThroughAssociation
-        def construct_join_attributes(*records)
-          ensure_mutable
-
-          if source_reflection.association_primary_key(reflection.klass) == reflection.klass.primary_key
-            join_attributes = { source_reflection.name => records }
-          else
-            join_attributes = {
-              source_reflection.foreign_key =>
-                records.map { |record|
-                  record.send(source_reflection.association_primary_key(reflection.klass))
-                }
-            }
-          end
-
-          if options[:source_type]
-
-            # START PATCH
-            # original:
-            # join_attributes[source_reflection.foreign_type] =
-            #  records.map { |record| record.class.base_class.name }
-
-            join_attributes[source_reflection.foreign_type] =
-              records.map { |record| ActiveRecord::Base.store_base_sti_class ? record.class.base_class.name : record.class.name }
-
-            # END PATCH
-          end
-
-          if records.count == 1
-            Hash[join_attributes.map { |k, v| [k, v.first] }]
-          else
-            join_attributes
-          end
-        end
-
-      end
-
-      class HasManyThroughAssociation
-
-        def build_through_record(record)
-          @through_records[record.object_id] ||= begin
-            ensure_mutable
-
-            through_record = through_association.build(*options_for_through_record)
-            through_record.send("#{source_reflection.name}=", record)
-
-            # START PATCH
-            if ActiveRecord::Base.store_base_sti_class
-              if options[:source_type]
-                through_record.send("#{source_reflection.foreign_type}=", options[:source_type])
-              end
-            end
-            # END PATCH
-
-            through_record
-          end
-        end
-      end
-    end
-
-    module Reflection
-      class ThroughReflection
-        def scope_chain
-          @scope_chain ||= begin
-            scope_chain = source_reflection.scope_chain.map(&:dup)
-
-            # 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)
-              }
-            end
-
-            # Recursively fill out the rest of the array from the through reflection
-            scope_chain + through_scope_chain
-          end
-        end
-      end
-
-    end
-  end
-
-end