store_base_sti_class 0.0.1

data/lib/store_base_sti_class_for_3_1_and_above.rb

@@ -0,0 +1,304 @@
+require 'active_record'
+
+if ActiveRecord::VERSION::STRING =~ /^3\.(1|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.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/store_base_sti_class.gemspec

@@ -0,0 +1,111 @@
+# 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 = "store_base_sti_class"
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Andrew Mutz"]
+  s.date = "2012-05-09"
+  s.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  "
+  s.email = "andrew.mutz@appfolio.com"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    "Appraisals",
+    "CHANGELOG",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "db/storebasestiname_unittest.sql",
+    "gemfiles/rails_3.0.10.gemfile",
+    "gemfiles/rails_3.0.10.gemfile.lock",
+    "gemfiles/rails_3.0.11.gemfile",
+    "gemfiles/rails_3.0.11.gemfile.lock",
+    "gemfiles/rails_3.0.12.gemfile",
+    "gemfiles/rails_3.0.12.gemfile.lock",
+    "gemfiles/rails_3.0.3.gemfile",
+    "gemfiles/rails_3.0.3.gemfile.lock",
+    "gemfiles/rails_3.0.4.gemfile",
+    "gemfiles/rails_3.0.4.gemfile.lock",
+    "gemfiles/rails_3.0.5.gemfile",
+    "gemfiles/rails_3.0.5.gemfile.lock",
+    "gemfiles/rails_3.0.6.gemfile",
+    "gemfiles/rails_3.0.6.gemfile.lock",
+    "gemfiles/rails_3.0.7.gemfile",
+    "gemfiles/rails_3.0.7.gemfile.lock",
+    "gemfiles/rails_3.0.8.gemfile",
+    "gemfiles/rails_3.0.8.gemfile.lock",
+    "gemfiles/rails_3.0.9.gemfile",
+    "gemfiles/rails_3.0.9.gemfile.lock",
+    "gemfiles/rails_3.1.0.gemfile",
+    "gemfiles/rails_3.1.0.gemfile.lock",
+    "gemfiles/rails_3.1.1.gemfile",
+    "gemfiles/rails_3.1.1.gemfile.lock",
+    "gemfiles/rails_3.1.2.gemfile",
+    "gemfiles/rails_3.1.2.gemfile.lock",
+    "gemfiles/rails_3.1.3.gemfile",
+    "gemfiles/rails_3.1.3.gemfile.lock",
+    "gemfiles/rails_3.1.4.gemfile",
+    "gemfiles/rails_3.1.4.gemfile.lock",
+    "gemfiles/rails_3.2.0.gemfile",
+    "gemfiles/rails_3.2.0.gemfile.lock",
+    "gemfiles/rails_3.2.1.gemfile",
+    "gemfiles/rails_3.2.1.gemfile.lock",
+    "gemfiles/rails_3.2.2.gemfile",
+    "gemfiles/rails_3.2.2.gemfile.lock",
+    "gemfiles/rails_3.2.3.gemfile",
+    "gemfiles/rails_3.2.3.gemfile.lock",
+    "lib/store_base_sti_class.rb",
+    "lib/store_base_sti_class_for_3_0.rb",
+    "lib/store_base_sti_class_for_3_1_and_above.rb",
+    "store_base_sti_class.gemspec",
+    "storebasestiname_unittest.sql",
+    "test/connection.rb",
+    "test/helper.rb",
+    "test/models.rb",
+    "test/schema.rb",
+    "test/test_store_base_sti_class.rb"
+  ]
+  s.homepage = "http://github.com/appfolio/store_base_sti_class"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.21"
+  s.summary = "Modifies ActiveRecord 3.0.5+ with the ability to store the actual class (instead of the base class) in polymorhic _type columns when using STI"
+
+  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<appraisal>, [">= 0"])
+      s.add_runtime_dependency(%q<activerecord>, [">= 0"])
+      s.add_runtime_dependency(%q<sqlite3>, [">= 0"])
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, [">= 0"])
+    else
+      s.add_dependency(%q<appraisal>, [">= 0"])
+      s.add_dependency(%q<activerecord>, [">= 0"])
+      s.add_dependency(%q<sqlite3>, [">= 0"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+      s.add_dependency(%q<bundler>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<appraisal>, [">= 0"])
+    s.add_dependency(%q<activerecord>, [">= 0"])
+    s.add_dependency(%q<sqlite3>, [">= 0"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+    s.add_dependency(%q<bundler>, [">= 0"])
+  end
+end
+

data/test/connection.rb

@@ -0,0 +1,22 @@
+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.configurations = {
+  'unittest' => {
+    :adapter  => 'sqlite3',
+    :database => 'db/storebasestiname_unittest.sql',
+  }
+}
+
+ActiveRecord::Base.establish_connection 'unittest'

data/test/helper.rb

@@ -0,0 +1,63 @@
+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'
+
+require 'connection'
+
+# silence verbose schema loading
+original_stdout = $stdout
+$stdout = StringIO.new
+begin
+  require "schema.rb"
+ensure
+  $stdout = original_stdout
+end
+
+require 'models'
+
+# the following is needed because ActiveRecord::TestCase uses ActiveRecord::SQLCounter, which is 
+# not bundled as part of the gem
+if ActiveRecord::VERSION::STRING =~ /^3\.2/
+  module ActiveRecord
+    class SQLCounter
+      cattr_accessor :ignored_sql
+      self.ignored_sql = [/^PRAGMA (?!(table_info))/, /^SELECT currval/, /^SELECT CAST/, /^SELECT @@IDENTITY/, /^SELECT @@ROWCOUNT/, /^SAVEPOINT/, /^ROLLBACK TO SAVEPOINT/, /^RELEASE SAVEPOINT/, /^SHOW max_identifier_length/, /^BEGIN/, /^COMMIT/]
+
+      # FIXME: this needs to be refactored so specific database can add their own
+      # ignored SQL.  This ignored SQL is for Oracle.
+      ignored_sql.concat [/^select .*nextval/i, /^SAVEPOINT/, /^ROLLBACK TO/, /^\s*select .* from all_triggers/im]
+
+      cattr_accessor :log
+      self.log = []
+
+      attr_reader :ignore
+
+      def initialize(ignore = self.class.ignored_sql)
+        @ignore   = ignore
+      end
+
+      def call(name, start, finish, message_id, values)
+        sql = values[:sql]
+
+        # FIXME: this seems bad. we should probably have a better way to indicate
+        # the query was cached
+        return if 'CACHE' == values[:name] || ignore.any? { |x| x =~ sql }
+        self.class.log << sql
+      end
+    end
+
+    ActiveSupport::Notifications.subscribe('sql.active_record', SQLCounter.new)
+  end  
+end
+

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