store_base_sti_class_for_3_1 0.0.1

data/CHANGELOG

@@ -0,0 +1,2 @@
+0.0.1
+  - Initial release

data/Gemfile

@@ -0,0 +1,10 @@
+source :rubygems
+
+gem "activerecord", ">= 3.1.0"
+
+group :development do
+  gem "mysql2", "=0.3.7"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.2"
+  gem "rcov", ">= 0"
+end

data/Gemfile.lock

@@ -0,0 +1,37 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.1.3)
+      activesupport (= 3.1.3)
+      builder (~> 3.0.0)
+      i18n (~> 0.6)
+    activerecord (3.1.3)
+      activemodel (= 3.1.3)
+      activesupport (= 3.1.3)
+      arel (~> 2.2.1)
+      tzinfo (~> 0.3.29)
+    activesupport (3.1.3)
+      multi_json (~> 1.0)
+    arel (2.2.1)
+    builder (3.0.0)
+    git (1.2.5)
+    i18n (0.6.0)
+    jeweler (1.5.2)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    multi_json (1.0.4)
+    mysql2 (0.3.7)
+    rake (0.9.1)
+    rcov (0.9.9)
+    tzinfo (0.3.31)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (>= 3.1.0)
+  bundler (~> 1.0.0)
+  jeweler (~> 1.5.2)
+  mysql2 (= 0.3.7)
+  rcov

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 AppFolio, inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,61 @@
+== Description
+
+Given the following class definitions,
+
+  class Address
+    belongs_to :addressable, :polymorphic => true
+  end
+
+  class Person
+    has_many :addresses, :as => addressable
+  end
+
+  class Vendor < Person
+  end
+
+and given the following code,
+
+  vendor = Vendor.create(...)
+  address = vendor.addresses.create(...)
+
+  p vendor
+  p address
+
+will output,
+
+  #<Vendor id: 1, type: "Vendor" ...>
+  #<Address id: 1, addressable_id: 1, addressable_type: 'Person' ...>
+
+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 characteristic 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 add ActiveRecord::Base.store_base_sti_class configuration option. It defaults to true for backwards compatibility. Setting it 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' ...>
+
+== Usage
+
+Add the following line to your Gemfile,
+
+  gem 'store_base_sti_class_for_3_1'
+
+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
+
+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
+
+The gem has used the test cases from https://github.com/pkmiec/store_base_sti_class_for_3_0, but has been completely rewritten for 3.1.  It currently works with ActiveRecord 3.1.0 through 3.1.3.
+
+== Copyright
+
+Copyright (c) 2011 AppFolio, inc. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,76 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "store_base_sti_class_for_3_1"
+  gem.homepage = "http://github.com/appfolio/store_base_sti_class_for_3_1"
+  gem.license = "MIT"
+  gem.summary = %Q{
+    Modifies ActiveRecord 3.1.x with the ability to store the actual class (instead of the base class) in polymorhic _type columns when using STI
+  }
+  gem.description = %Q{
+    ActiveRecord has always stored the base class in polymorphic _type columns when using STI. This can have non-trivial
+    performance implications in certain cases. This gem adds 'store_base_sti_class' configuration options which controls
+    whether ActiveRecord will store the base class or the actual class. Default to true for backwards compatibility.
+  }
+  gem.email = "andrew.mutz@appfolio.com"
+  gem.authors = ["Andrew Mutz"]
+  
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "store_base_sti_class_for_3_1 #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+namespace :mysql do
+  desc 'Build the MySQL test databases'
+  task :build_databases do
+    %x( echo "create DATABASE storebasestiname_unittest DEFAULT CHARACTER SET utf8 DEFAULT COLLATE utf8_unicode_ci " | mysql --user=root)
+  end
+
+  desc 'Drop the MySQL test databases'
+  task :drop_databases do
+    %x( mysqladmin --user=root -f drop storebasestiname_unittest )
+  end
+
+  desc 'Rebuild the MySQL test databases'
+  task :rebuild_databases => [:drop_databases, :build_databases]
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/store_base_sti_class_for_3_1.rb

@@ -0,0 +1,304 @@
+require 'active_record'
+
+if ActiveRecord::VERSION::STRING =~ /^3\.1/
+  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.macro.in?([:has_one, :has_many]) && !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_to(relation)
+
+            tables        = @tables.dup
+            foreign_table = parent_table
+            foreign_klass = parent.active_record
+
+            # 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_with_index do |reflection, i|
+              table = tables.shift
+
+              case reflection.source_macro
+              when :belongs_to
+                key         = reflection.association_primary_key
+                foreign_key = reflection.foreign_key
+              when :has_and_belongs_to_many
+                # Join the join table first...
+                relation.from(join(
+                  table,
+                  table[reflection.foreign_key].
+                    eq(foreign_table[reflection.active_record_primary_key])
+                ))
+
+                foreign_table, table = table, tables.shift
+
+                key         = reflection.association_primary_key
+                foreign_key = reflection.association_foreign_key
+              else
+                key         = reflection.foreign_key
+                foreign_key = reflection.active_record_primary_key
+              end
+
+              constraint = build_constraint(reflection, table, key, foreign_table, foreign_key)
+
+              conditions = self.conditions[i].dup
+              
+              # START PATCH
+              # original:
+              # conditions << { reflection.type => foreign_klass.base_class.name } if reflection.type
+              
+              if ActiveRecord::Base.store_base_sti_class
+                conditions << { reflection.type => foreign_klass.base_class.name } if reflection.type
+              else
+                conditions << { reflection.type => ([foreign_klass] + foreign_klass.descendants).map(&:name) } if reflection.type
+              end
+              
+              # END PATCH
+
+              unless conditions.empty?
+                constraint = constraint.and(sanitize(conditions, table))
+              end
+
+              relation.from(join(table, constraint))
+
+              # The current table in this iteration becomes the foreign table in the next
+              foreign_table, foreign_klass = table, reflection.klass
+            end
+
+            relation
+          end
+        end      
+      end
+      
+      
+      class BelongsToPolymorphicAssociation < BelongsToAssociation #:nodoc:
+
+        private
+
+        def replace_keys(record)
+          super
+          # START PATCH
+          # original: owner[reflection.foreign_type] = record && record.class.base_class.name
+          unless ActiveRecord::Base.store_base_sti_class
+            owner[reflection.foreign_type] = record && record.class.sti_name
+          else
+            owner[reflection.foreign_type] = record && record.class.base_class.name
+          end
+          #END PATCH
+        end
+      end
+    end
+    module Associations
+      class Preloader
+        class Association
+          private
+          def build_scope
+
+            scope = klass.scoped
+
+            scope = scope.where(process_conditions(options[:conditions]))
+            scope = scope.where(process_conditions(preload_options[:conditions]))
+
+            scope = scope.select(preload_options[:select] || options[:select] || table[Arel.star])
+            scope = scope.includes(preload_options[:include] || options[:include])
+
+
+
+            if options[:as]
+              scope = scope.where(
+                klass.table_name => {
+                  #START PATCH
+                  #original: reflection.type => model.base_class.sti_name
+                  reflection.type => ActiveRecord::Base.store_base_sti_class ? model.base_class.sti_name : model.sti_name
+                  #END PATCH
+                  
+                }
+              )
+            end
+
+            scope
+          end
+        end
+        
+        module ThroughAssociation
+          def through_options
+            through_options = {}
+            if options[:source_type]
+              #START PATCH
+              #original: through_options[:conditions] = { reflection.foreign_type => options[:source_type] }
+              through_options[:conditions] = { reflection.foreign_type =>  ([options[:source_type].constantize] + options[:source_type].constantize.descendants).map(&:to_s)  }
+              #END PATCH
+            else
+              if options[:conditions]
+                through_options[:include]    = options[:include] || options[:source]
+                through_options[:conditions] = options[:conditions]
+              end
+
+              through_options[:order] = options[:order]
+            end
+            through_options
+          end
+        end
+      end
+      
+      class AssociationScope
+        def add_constraints(scope)
+          
+          tables = construct_tables
+
+          chain.each_with_index do |reflection, i|
+            table, foreign_table = tables.shift, tables.first
+
+            if reflection.source_macro == :has_and_belongs_to_many
+              join_table = tables.shift
+
+              scope = scope.joins(join(
+                join_table,
+                table[reflection.association_primary_key].
+                  eq(join_table[reflection.association_foreign_key])
+              ))
+
+              table, foreign_table = join_table, tables.first
+            end
+
+            if reflection.source_macro == :belongs_to
+              if reflection.options[:polymorphic]
+                # START PATCH
+                # This line exists to support multiple versions of AR 3.1
+                # original in 3.1.3: key         = reflection.association_primary_key
+                
+                key = (reflection.method(:association_primary_key).arity == 0) ? reflection.association_primary_key : reflection.association_primary_key(klass)
+                # END PATCH
+              else
+                key = reflection.association_primary_key
+              end
+
+              foreign_key = reflection.foreign_key
+            else
+              key         = reflection.foreign_key
+              foreign_key = reflection.active_record_primary_key
+            end
+
+            conditions = self.conditions[i]
+
+            if reflection == chain.last
+              scope = scope.where(table[key].eq(owner[foreign_key]))
+
+              if reflection.type
+                # START PATCH
+                # original: scope = scope.where(table[reflection.type].eq(owner.class.base_class.name))
+                
+                unless ActiveRecord::Base.store_base_sti_class
+                  scope = scope.where(table[reflection.type].eq(owner.class.name))
+                else
+                  scope = scope.where(table[reflection.type].eq(owner.class.base_class.name))
+                end
+                
+                # END PATCH
+              end
+
+              conditions.each do |condition|
+                if options[:through] && condition.is_a?(Hash)
+                  condition = { table.name => condition }
+                end
+
+                scope = scope.where(interpolate(condition))
+              end
+            else
+              constraint = table[key].eq(foreign_table[foreign_key])
+
+              if reflection.type
+                # START PATCH
+                # original: type = chain[i + 1].klass.base_class.name
+                #           constraint = constraint.and(table[reflection.type].eq(type))
+                
+                if ActiveRecord::Base.store_base_sti_class
+                  type = chain[i + 1].klass.base_class.name
+                  constraint = constraint.and(table[reflection.type].eq(type))
+                else
+                  klass = chain[i + 1].klass
+                  constraint = constraint.and(table[reflection.type].in(([klass] + klass.descendants).map(&:name)))
+                end
+                
+                # END PATCH
+              end
+
+              scope = scope.joins(join(foreign_table, constraint))
+
+              unless conditions.empty?
+                scope = scope.where(sanitize(conditions, table))
+              end
+            end
+          end
+
+          scope
+        end
+        
+      end
+    end
+    module Reflection
+      class ThroughReflection < AssociationReflection
+    
+        def conditions
+          @conditions ||= begin
+            conditions = source_reflection.conditions.map { |c| c.dup }
+
+            # Add to it the conditions from this reflection if necessary.
+            conditions.first << options[:conditions] if options[:conditions]
+
+            through_conditions = through_reflection.conditions
+
+            if options[:source_type]
+              # START PATCH
+              # original: through_conditions.first << { foreign_type => options[:source_type] }
+              
+              unless ActiveRecord::Base.store_base_sti_class
+                through_conditions.first << { foreign_type => ([options[:source_type].constantize] + options[:source_type].constantize.descendants).map(&:to_s) }
+              else
+                through_conditions.first << { foreign_type => options[:source_type] }
+              end
+              
+              # END PATCH
+            end
+
+            # Recursively fill out the rest of the array from the through reflection
+            conditions += through_conditions
+
+            # And return
+            conditions
+          end
+        end
+      end
+    end    
+    
+  end
+
+end

data/polymorphic_and_sti_fix_for_rails_3_1.diff

@@ -0,0 +1,111 @@
+diff --git a/activerecord/lib/active_record/associations/association_scope.rb b/activerecord/lib/active_record/associations/association_scope.rb
+index 9e6d9e7..cbf176e 100644
+--- a/activerecord/lib/active_record/associations/association_scope.rb
++++ b/activerecord/lib/active_record/associations/association_scope.rb
+@@ -81,7 +81,11 @@ module ActiveRecord
+             scope = scope.where(table[key].eq(owner[foreign_key]))
+ 
+             if reflection.type
+-              scope = scope.where(table[reflection.type].eq(owner.class.base_class.name))
++              unless ActiveRecord::Base.store_base_sti_class
++                scope = scope.where(table[reflection.type].eq(owner.class.name))
++              else
++                scope = scope.where(table[reflection.type].eq(owner.class.base_class.name))
++              end
+             end
+ 
+             conditions.each do |condition|
+diff --git a/activerecord/lib/active_record/associations/belongs_to_polymorphic_association.rb b/activerecord/lib/active_record/associations/belongs_to_polymorphic_association.rb
+index 2ee5dbb..837abfb 100644
+--- a/activerecord/lib/active_record/associations/belongs_to_polymorphic_association.rb
++++ b/activerecord/lib/active_record/associations/belongs_to_polymorphic_association.rb
+@@ -11,7 +11,11 @@ module ActiveRecord
+ 
+         def replace_keys(record)
+           super
+-          owner[reflection.foreign_type] = record && record.class.base_class.name
++          unless ActiveRecord::Base.store_base_sti_class
++            owner[reflection.foreign_type] = record && record.class.sti_name
++          else
++            owner[reflection.foreign_type] = record && record.class.base_class.name
++          end
+         end
+ 
+         def different_target?(record)
+diff --git a/activerecord/lib/active_record/associations/join_dependency/join_association.rb b/activerecord/lib/active_record/associations/join_dependency/join_association.rb
+index 03963ab..3ad1aeb 100644
+--- a/activerecord/lib/active_record/associations/join_dependency/join_association.rb
++++ b/activerecord/lib/active_record/associations/join_dependency/join_association.rb
+@@ -93,7 +93,12 @@ module ActiveRecord
+             constraint = build_constraint(reflection, table, key, foreign_table, foreign_key)
+ 
+             conditions = self.conditions[i].dup
+-            conditions << { reflection.type => foreign_klass.base_class.name } if reflection.type
++
++            if ActiveRecord::Base.store_base_sti_class
++              conditions << { reflection.type => foreign_klass.base_class.name } if reflection.type
++            else
++              conditions << { reflection.type => ([foreign_klass.base_class] + foreign_klass.base_class.descendants).map(&:name) } if reflection.type
++            end
+ 
+             unless conditions.empty?
+               constraint = constraint.and(sanitize(conditions, table))
+diff --git a/activerecord/lib/active_record/associations/preloader/association.rb b/activerecord/lib/active_record/associations/preloader/association.rb
+index 779f816..e99cfcb 100644
+--- a/activerecord/lib/active_record/associations/preloader/association.rb
++++ b/activerecord/lib/active_record/associations/preloader/association.rb
+@@ -104,7 +104,7 @@ module ActiveRecord
+           if options[:as]
+             scope = scope.where(
+               klass.table_name => {
+-                reflection.type => model.base_class.sti_name
++                reflection.type => ActiveRecord::Base.store_base_sti_class ? model.base_class.sti_name : model.sti_name
+               }
+             )
+           end
+diff --git a/activerecord/lib/active_record/associations/preloader/through_association.rb b/activerecord/lib/active_record/associations/preloader/through_association.rb
+index ad6374d..7e14fa0 100644
+--- a/activerecord/lib/active_record/associations/preloader/through_association.rb
++++ b/activerecord/lib/active_record/associations/preloader/through_association.rb
+@@ -49,7 +49,7 @@ module ActiveRecord
+           through_options = {}
+ 
+           if options[:source_type]
+-            through_options[:conditions] = { reflection.foreign_type => options[:source_type] }
++            through_options[:conditions] = { reflection.foreign_type =>  ([options[:source_type].constantize] + options[:source_type].constantize.descendants).map(&:to_s)  }
+           else
+             if options[:conditions]
+               through_options[:include]    = options[:include] || options[:source]
+diff --git a/activerecord/lib/active_record/base.rb b/activerecord/lib/active_record/base.rb
+index c866736..3673294 100644
+--- a/activerecord/lib/active_record/base.rb
++++ b/activerecord/lib/active_record/base.rb
+@@ -424,6 +424,11 @@ module ActiveRecord #:nodoc:
+     # Determine whether to store the full constant name including namespace when using STI
+     class_attribute :store_full_sti_class
+     self.store_full_sti_class = true
++    
++    # Store the actual class (instead of the base class) in polymorhic _type columns when using STI
++    class_attribute :store_base_sti_class
++    self.store_base_sti_class = true
++    
+ 
+     # Stores the default scope for the class
+     class_attribute :default_scopes, :instance_writer => false
+diff --git a/activerecord/lib/active_record/reflection.rb b/activerecord/lib/active_record/reflection.rb
+index 6ddf76e..6affef3 100644
+--- a/activerecord/lib/active_record/reflection.rb
++++ b/activerecord/lib/active_record/reflection.rb
+@@ -451,7 +451,11 @@ module ActiveRecord
+           through_conditions = through_reflection.conditions
+ 
+           if options[:source_type]
+-            through_conditions.first << { foreign_type => options[:source_type] }
++            unless ActiveRecord::Base.store_base_sti_class
++              through_conditions.first << { foreign_type => ([options[:source_type].constantize] + options[:source_type].constantize.descendants).map(&:to_s) }
++            else
++              through_conditions.first << { foreign_type => options[:source_type] }
++            end
+           end
+ 
+           # Recursively fill out the rest of the array from the through reflection

data/store_base_sti_class_for_3_1.gemspec

@@ -0,0 +1,77 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{store_base_sti_class_for_3_1}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = [%q{Andrew Mutz}]
+  s.date = %q{2011-12-23}
+  s.description = %q{
+    ActiveRecord has always stored the base class in polymorphic _type columns when using STI. This can have non-trivial
+    performance implications in certain cases. This gem adds 'store_base_sti_class' configuration options which controls
+    whether ActiveRecord will store the base class or the actual class. Default to true for backwards compatibility.
+  }
+  s.email = %q{andrew.mutz@appfolio.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    "CHANGELOG",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "lib/store_base_sti_class_for_3_1.rb",
+    "polymorphic_and_sti_fix_for_rails_3_1.diff",
+    "store_base_sti_class_for_3_1.gemspec",
+    "test/connection.rb",
+    "test/helper.rb",
+    "test/models.rb",
+    "test/schema.rb",
+    "test/test_store_base_sti_class_for_3_1.rb"
+  ]
+  s.homepage = %q{http://github.com/appfolio/store_base_sti_class_for_3_1}
+  s.licenses = [%q{MIT}]
+  s.require_paths = [%q{lib}]
+  s.rubygems_version = %q{1.8.5}
+  s.summary = %q{Modifies ActiveRecord 3.1.x with the ability to store the actual class (instead of the base class) in polymorhic _type columns when using STI}
+  s.test_files = [
+    "test/connection.rb",
+    "test/helper.rb",
+    "test/models.rb",
+    "test/schema.rb",
+    "test/test_store_base_sti_class_for_3_1.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activerecord>, [">= 3.1.0"])
+      s.add_development_dependency(%q<mysql2>, ["= 0.3.7"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+    else
+      s.add_dependency(%q<activerecord>, [">= 3.1.0"])
+      s.add_dependency(%q<mysql2>, ["= 0.3.7"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<activerecord>, [">= 3.1.0"])
+    s.add_dependency(%q<mysql2>, ["= 0.3.7"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+  end
+end
+

data/test/connection.rb

@@ -0,0 +1,16 @@
+require 'logger'
+
+ActiveRecord::Base.logger = Logger.new("debug.log")
+
+# GRANT ALL PRIVILEGES ON storebasestiname_unittest.* to 'root'@'localhost';
+
+ActiveRecord::Base.configurations = {
+  'unittest' => {
+    :adapter  => 'mysql2',
+    :username => 'root',
+    :encoding => 'utf8',
+    :database => 'storebasestiname_unittest',
+  }
+}
+
+ActiveRecord::Base.establish_connection 'unittest'

data/test/helper.rb

@@ -0,0 +1,27 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'store_base_sti_class_for_3_1'
+
+require 'connection'
+
+# silence verbose schema loading
+original_stdout = $stdout
+$stdout = StringIO.new
+begin
+  require "schema.rb"
+ensure
+  $stdout = original_stdout
+end
+
+require 'models'

data/test/models.rb

@@ -0,0 +1,48 @@
+class Author < ActiveRecord::Base
+  has_many :posts
+  
+  has_many :tagging,  :through => :posts                       # through polymorphic has_one
+  has_many :taggings, :through => :posts, :source => :taggings # through polymorphic has_many
+  has_many :tags,     :through => :posts                       # through has_many :through
+end
+
+class Post < ActiveRecord::Base
+  belongs_to :author
+  
+  has_one  :tagging, :as => :taggable
+  has_many :taggings, :as => :taggable
+  has_many :tags, :through => :taggings
+end
+
+class SpecialPost < Post
+end
+
+class Tagging < ActiveRecord::Base
+  belongs_to :tag, :include => :tagging
+  belongs_to :polytag, :polymorphic => true
+  belongs_to :taggable, :polymorphic => true, :counter_cache => true  
+end
+
+class Tag < ActiveRecord::Base
+  has_one  :tagging
+
+  has_many :taggings
+  has_many :taggables, :through => :taggings
+  has_many :tagged_posts, :through => :taggings, :source => :taggable, :source_type => 'Post'
+  
+  has_many :polytaggings, :as => :polytag, :class_name => 'Tagging'
+  has_many :polytagged_posts, :through => :polytaggings, :source => :taggable, :source_type => 'Post'
+
+  has_many :authors, :class_name => "Author", :finder_sql => proc {
+    <<-SQL
+      SELECT authors.* FROM authors
+        INNER JOIN posts p ON authors.id = p.author_id
+        INNER JOIN taggings tgs ON tgs.taggable_id = p.id AND tgs.taggable_type = "Post"
+        WHERE tgs.tag_id = #{self.id}
+    SQL
+  }
+
+end
+
+class SpecialTag < Tag
+end

data/test/schema.rb

@@ -0,0 +1,35 @@
+ActiveRecord::Schema.define do
+
+  # Please keep these create table statements in alphabetical order
+  # unless the ordering matters.  In which case, define them below
+
+  create_table :authors, :force => true do |t|
+    t.string :name, :null => false
+  end
+
+  create_table :posts, :force => true do |t|
+    t.string  :type
+
+    t.integer :author_id
+    t.string  :title, :null => false
+    t.text    :body, :null => false
+    t.integer :taggings_count, :default => 0
+  end
+
+  create_table :taggings, :force => true do |t|
+    t.integer :tag_id
+
+    t.integer :polytag_id
+    t.string  :polytag_type
+    
+    t.string  :taggable_type
+    t.integer :taggable_id
+  end
+
+  create_table :tags, :force => true do |t|
+    t.string  :type
+    t.string  :name
+    t.integer :taggings_count, :default => 0
+  end
+
+end

data/test/test_store_base_sti_class_for_3_1.rb

@@ -0,0 +1,161 @@
+require 'helper'
+require 'active_record/test_case'
+
+class TestStoreBaseStiNameFor30 < ActiveRecord::TestCase
+
+  def setup
+    @old_store_base_sti_class = ActiveRecord::Base.store_base_sti_class
+    ActiveRecord::Base.store_base_sti_class = false
+    
+    @thinking_post = SpecialPost.create(:title => 'Thinking')
+    @misc_tag = Tag.create(:name => 'Misc')
+  end
+
+  def teardown
+    ActiveRecord::Base.store_base_sti_class = @old_store_base_sti_class
+  end
+
+  def test_polymorphic_belongs_to_assignment_with_inheritance
+    # should update when assigning a saved record
+    tagging = Tagging.new
+    post = SpecialPost.create(:title => 'Budget Forecasts Bigger 2011 Deficit')
+    tagging.taggable = post
+    assert_equal post.id, tagging.taggable_id
+    assert_equal "SpecialPost", tagging.taggable_type
+  
+    # should update when assigning a new record
+    tagging = Tagging.new
+    post = SpecialPost.new(:title => 'Budget Forecasts Bigger 2011 Deficit')
+    tagging.taggable = post
+    assert_nil tagging.taggable_id
+    assert_equal "SpecialPost", tagging.taggable_type
+  end
+  
+  def test_polymorphic_has_many_create_model_with_inheritance
+    post = SpecialPost.new(:title => 'Budget Forecasts Bigger 2011 Deficit')
+  
+    tagging = @misc_tag.taggings.create(:taggable => post)
+    assert_equal "SpecialPost", tagging.taggable_type
+  
+    post.reload
+    assert_equal [tagging], post.taggings
+  end
+  
+  def test_polymorphic_has_one_create_model_with_inheritance
+    post = SpecialPost.new(:title => 'Budget Forecasts Bigger 2011 Deficit')
+  
+    tagging = @misc_tag.create_tagging(:taggable => post)
+    assert_equal "SpecialPost", tagging.taggable_type
+  
+    post.reload
+    assert_equal tagging, post.tagging
+  end
+  
+  def test_polymorphic_has_many_create_via_association
+    tag = SpecialTag.create!(:name => 'Special')
+    tagging = tag.polytaggings.create!
+    
+    assert_equal "SpecialTag", tagging.polytag_type
+  end
+
+  def test_polymorphic_has_many_through_create_via_association
+    tag = SpecialTag.create!(:name => 'Special')
+    post = tag.polytagged_posts.create!(:title => 'To Be or Not To Be?')
+    
+    assert_equal "SpecialTag", tag.polytaggings.first.polytag_type
+  end
+  
+  def test_include_polymorphic_has_one
+    post = SpecialPost.create!(:title => 'Budget Forecasts Bigger 2011 Deficit')
+    tagging = post.create_tagging(:tag => @misc_tag)
+  
+    post = Post.find(post.id, :include => :tagging)
+    assert_equal tagging, assert_no_queries { post.tagging }
+  end
+  
+  def test_include_polymorphic_has_many
+    tag = SpecialTag.create!(:name => 'Special')
+    tag.polytagged_posts << SpecialPost.create!(:title => 'Budget Forecasts Bigger 2011 Deficit')
+    tag.polytagged_posts << @thinking_post
+  
+    tag = Tag.find(tag.id, :include => :polytaggings)
+    assert_equal 2, assert_no_queries { tag.polytaggings.length }
+  end
+  
+  def test_include_polymorphic_has_many_through
+    tag = SpecialTag.create!(:name => 'Special')
+    tag.polytagged_posts << SpecialPost.create!(:title => 'Budget Forecasts Bigger 2011 Deficit')
+    tag.polytagged_posts << @thinking_post
+  
+    tag = Tag.find(tag.id, :include => :polytagged_posts)
+    assert_equal 2, assert_no_queries { tag.polytagged_posts.length }
+  end
+  
+  def test_join_polymorhic_has_many
+    tag = SpecialTag.create!(:name => 'Special')
+    tag.polytagged_posts << SpecialPost.create!(:title => 'Budget Forecasts Bigger 2011 Deficit')
+    tag.polytagged_posts << @thinking_post
+  
+    assert Tag.find_by_id(tag.id, :joins => :polytaggings, :conditions => [ 'taggings.id = ?', tag.polytaggings.first.id ])
+  end
+  
+  def test_join_polymorhic_has_many_through
+    tag = SpecialTag.create!(:name => 'Special')
+    tag.polytagged_posts << SpecialPost.create!(:title => 'Budget Forecasts Bigger 2011 Deficit')
+    tag.polytagged_posts << @thinking_post
+  
+    assert Tag.find_by_id(tag.id, :joins => :polytagged_posts, :conditions => [ 'posts.id = ?', tag.polytaggings.first.taggable_id ])
+  end
+  
+  def test_has_many_through_polymorphic_has_one
+    author       = Author.create!(:name => 'Bob')
+    post         = Post.create!(:title => 'Budget Forecasts Bigger 2011 Deficit', :author => author)
+    special_post = SpecialPost.create!(:title => 'IBM Watson''s Jeopardy play', :author => author)
+    special_tag  = SpecialTag.create!(:name => 'SpecialGeneral')
+  
+    taggings = [ post.taggings.create(:tag => special_tag), special_post.taggings.create(:tag => special_tag) ]
+    assert_equal taggings.sort_by(&:id), author.tagging.sort_by(&:id)
+  end
+    
+  def test_has_many_polymorphic_with_source_type
+    tag = SpecialTag.create!(:name => 'Special')
+    tag.polytagged_posts << SpecialPost.create!(:title => 'Budget Forecasts Bigger 2011 Deficit')
+    tag.polytagged_posts << @thinking_post
+
+    tag.save!
+    tag.reload
+    
+    tag = Tag.find(tag.id)
+    assert_equal 2, tag.polytagged_posts.length
+  end
+  
+  def test_polymorphic_has_many_through_with_double_sti_on_join_model
+    tag = SpecialTag.create!(:name => 'Special')
+    post = @thinking_post
+    
+    tag.polytagged_posts << post
+    
+    
+    tag.reload
+    
+    assert_equal 1, tag.polytaggings.length
+    
+    tagging = tag.polytaggings.first
+
+    assert_equal 'SpecialTag',  tagging.polytag_type
+    assert_equal 'SpecialPost', tagging.taggable_type
+  
+    assert_equal tag,  tagging.polytag
+    assert_equal post, tagging.taggable
+  end
+
+  def test_finder_sql_is_supported
+    author       = Author.create!(:name => 'Bob')
+    post         = Post.create!(:title => 'Budget Forecasts Bigger 2011 Deficit', :author => author)
+    special_tag  = Tag.create!(:name => 'SpecialGeneral')
+    post.taggings.create(:tag => special_tag)
+
+    assert_equal [author], special_tag.authors
+  end
+
+end

metadata

@@ -0,0 +1,161 @@
+--- !ruby/object:Gem::Specification 
+name: store_base_sti_class_for_3_1
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Andrew Mutz
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-01-14 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :runtime
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 3
+        - 1
+        - 0
+        version: 3.1.0
+  requirement: *id001
+  name: activerecord
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 29
+        segments: 
+        - 0
+        - 3
+        - 7
+        version: 0.3.7
+  requirement: *id002
+  name: mysql2
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  requirement: *id003
+  name: bundler
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 1
+        - 5
+        - 2
+        version: 1.5.2
+  requirement: *id004
+  name: jeweler
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  version_requirements: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id005
+  name: rcov
+description: "\n    ActiveRecord has always stored the base class in polymorphic _type columns when using STI. This can have non-trivial\n    performance implications in certain cases. This gem adds 'store_base_sti_class' configuration options which controls\n    whether ActiveRecord will store the base class or the actual class. Default to true for backwards compatibility.\n  "
+email: andrew.mutz@appfolio.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- CHANGELOG
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/store_base_sti_class_for_3_1.rb
+- polymorphic_and_sti_fix_for_rails_3_1.diff
+- store_base_sti_class_for_3_1.gemspec
+- test/connection.rb
+- test/helper.rb
+- test/models.rb
+- test/schema.rb
+- test/test_store_base_sti_class_for_3_1.rb
+homepage: http://github.com/appfolio/store_base_sti_class_for_3_1
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.5
+signing_key: 
+specification_version: 3
+summary: Modifies ActiveRecord 3.1.x with the ability to store the actual class (instead of the base class) in polymorhic _type columns when using STI
+test_files: 
+- test/connection.rb
+- test/helper.rb
+- test/models.rb
+- test/schema.rb
+- test/test_store_base_sti_class_for_3_1.rb