multiple_table_inheritance 0.1.0

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/README.md

@@ -0,0 +1,215 @@
+Multiple Table Inheritance
+==========================
+
+Multiple Table Inheritance is a plugin designed to allow for multiple table
+inheritance between your database tables and your ActiveRecord models.
+
+This plugin is a derivative of the original class-table-inheritance gem, which
+can be found at http://github.com/brunofrank/class-table-inheritance
+
+
+Compatibility
+=============
+
+Multiple Table Inheritance is Rails 3.x compatible.
+
+
+How to Install
+==============
+
+From the command line:
+
+    gem install multiple-table-inheritance
+
+From your Gemfile:
+
+    gem 'multiple_table_inheritance', '~> 0.1.0'
+
+Usage
+=====
+
+Running Migrations
+------------------
+
+When creating your tables, the table representing the superclass must include a
+`subtype` string column.  (Optionally, you can provide a custom name for this
+field and provide the custom name in your model options.)  It is recommended
+that this column be non-null for sanity.
+
+    create_table :employees do |t|
+      t.string :subtype, :null => false
+      t.string :first_name, :null => false
+      t.string :last_name, :null => false
+      t.integer :salary, :null => false
+      t.timestamps
+    end
+
+When creating tables that are derived from your superclass table, simple
+provide the `:inherits` hash option to your `create_table` call.
+
+    create_table :programmers, :inherits => :employee do |t|
+      t.datetime :training_completed_at
+    end
+    
+    create_table :managers, :inherits => :employee do |t|
+      t.integer :bonus, :null => false
+    end
+
+Creating Models
+---------------
+
+The `acts_as_superclass` method is used to represent that a model can be
+extended.
+
+    class Employee < ActiveRecord::Base
+      acts_as_superclass
+    end
+
+Conversely, the `inherits_from` method is used to represent that a given model
+extends another model.  It takes one optional parameter, which is the symbol
+desired for referencing the relationship.
+
+    class Programmer < ActiveRecord::Base
+      inherits_from :employee
+    end
+    
+    class Manager < ActiveRecord::Base
+      inherits_from :employee
+    end
+
+Additional options can be passed to represent the exact relationship structure.
+Specifically, any option that can be provided to `belongs_to` can be provided
+to `inherits_from`.  (Presently, this has only be tested to work with the
+`:class_name` option.)
+
+    class Resources::Manager < ActiveRecord::Base
+      inherits_from :employee, :class_name => 'Resources::Employee'
+    end
+
+Creating Records
+----------------
+
+    Programmer.create(
+        :first_name => 'Bob',
+        :last_name => 'Smith',
+        :salary => 65000,
+        :training_completed_at => 3.years.ago)
+
+    Manager.create(
+        :first_name => 'Joe'
+        :last_name => 'Schmoe',
+        :salary => 75000,
+        :bonus => 5000)
+
+Retrieving Records
+------------------
+
+Records can be retrieved explicitly by their own type.
+
+    programmer = Programmer.first  # <Programmer employee_id: 1 training_completed_at: "2009-03-06 00:30:00">
+    programmer.id                  # 1
+    programmer.first_name          # "Bob"
+    programmer.last_name           # "Smith"
+    programmer.salary              # 65000
+
+Records can be retrieved implicitly by the superclass type.
+
+    employees = Employee.limit(2)  # [<Programmer employee_id: 1 training_completed_at: "2009-03-06 00:30:00">,
+                                      <Manager employee_id: 2 bonus: 5000>]
+    employees.first.class          # Programmer
+    employees.last.class           # Manager
+    employees.first.bonus          # undefined method `bonus`
+    employees.last.bonus           # 5000
+
+Deleting Records
+----------------
+
+Records can be deleted by either the parent or child reference.
+
+    Manager.first.destroy          # destroys associated Employee reference as well
+    Employee.first.destroy         # destroys associated Manager reference as well
+
+Validation
+----------
+
+When creating a new record that inherits from another model, validation is
+taken into consideration across both models.
+
+    class ::Employee < ActiveRecord::Base
+      acts_as_superclass
+      validates :first_name, :presence => true
+      validates :last_name, :presence => true
+      validates :salary, :presence => true, :numericality => { :min => 0 }
+    end
+    
+    class ::Programmer < ActiveRecord::Base
+      inherits_from :employee
+    end
+    
+    class ::Manager < ActiveRecord::Base
+      inherits_from :employee
+      validates :bonus, :presence => true, :numericality => true
+    end
+    
+    Programmer.create(:first_name => 'Bob', :last_name => 'Jones', :salary => -50)
+    # fails because :salary must be >= 0
+    
+    Manager.create!(:first_name => 'Bob', :last_name => 'Jones', :salary => 75000)
+    # fails because :bonus is not present
+
+Mass Assignment Security
+------------------------
+
+Mass assignment security can optionally be used in the same manner you would
+for a normal ActiveRecord model.
+
+    class Employee < ActiveRecord::Base
+      acts_as_superclass
+      attr_accessible :first_name, :last_name, :salary
+    end
+    
+    class Manager < ActiveRecord::Base
+      inherits_from :employee
+      attr_accessible :bonus
+    end
+
+**NOTE:** When an ActiveRecord model does not make a call to `attr_accessible`,
+all its fields are presumed to be accessible.  Currently, when using
+MultipleTableInheritance, if a parent class does not call `attr_accesible` and
+one of its children does, then the parent's attributes cannot properly be
+stored.  This will be fixed in a future release.
+
+Associations
+------------
+
+Associations will also work in the same way as other attributes.
+
+    class Team < ActiveRecord::Base
+      attr_accessible :name
+    end
+    
+    class Employee < ActiveRecord::Base
+      acts_as_superclass
+      belongs_to :team
+    end
+    
+    class ::Programmer < ActiveRecord::Base
+      inherits_from :employee
+      has_many :known_languages
+      has_many :languages, :through => :known_languages
+    end
+    
+    class ::Language < ActiveRecord::Base
+      attr_accessible :name
+      has_many :known_languages
+      has_many :programmers, :through => :known_languages
+    end
+    
+    class ::KnownLanguage < ActiveRecord::Base
+      belongs_to :programmer
+      belongs_to :language
+    end
+    
+    programmer = Programmer.first           # <Programmer employee_id: 1 training_completed_at: "2009-03-06 00:30:00">
+    programmer.languages.collect(&:name)    # ['Java', 'C++']
+    programmer.team.name                    # 'Website Front-End'

data/Rakefile

@@ -0,0 +1,47 @@
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+
+desc 'Default: run unit specs.'
+task :default => :spec
+
+# require 'rake'
+# require 'rake/testtask'
+# require 'rake/rdoctask'
+# 
+# desc 'Default: run unit tests.'
+# task :default => :test
+# 
+# desc 'Test the multiple_table_inheritance plugin.'
+# Rake::TestTask.new(:test) do |t|
+#   t.libs << 'lib'
+#   t.libs << 'test'
+#   t.pattern = 'test/**/*_test.rb'
+#   t.verbose = true
+# end
+# 
+# desc 'Generate documentation for the multiple_table_inheritance plugin.'
+# Rake::RDocTask.new(:rdoc) do |rdoc|
+#   rdoc.rdoc_dir = 'rdoc'
+#   rdoc.title    = 'MultipleTableInheritance'
+#   rdoc.options << '--line-numbers' << '--inline-source'
+#   rdoc.rdoc_files.include('README')
+#   rdoc.rdoc_files.include('lib/**/*.rb')
+# end
+# 
+# begin
+#   require 'jeweler'
+#   Jeweler::Tasks.new do |gem|
+#     gem.name = "multiple_table_inheritance"
+#     gem.summary = "ActiveRecord plugin designed to allow simple multiple table inheritance."
+#     gem.description = "ActiveRecord plugin designed to allow simple multiple table inheritance."
+#     gem.email = "tvdeyen@gmail.com"
+#     gem.homepage = "http://github.com/tvdeyen/multiple_table_inheritance"
+#     gem.authors = `git log --pretty=format:"%an"`.split("\n").uniq.sort
+#     gem.add_dependency "activerecord", ">=3.0.0"
+#   end
+#   Jeweler::GemcutterTasks.new
+# rescue LoadError
+#   puts "Jeweler (or a dependency) not available."
+#   puts "Install it with: gem install jeweler"
+# end

data/lib/multiple_table_inheritance/active_record/child.rb

@@ -0,0 +1,125 @@
+module MultipleTableInheritance
+  module ActiveRecord
+    module Child
+      def self.default_options
+        { :dependent => :destroy, :inherit_methods => false }
+      end
+      
+      def self.included(base)
+        base.extend ClassMethods
+        base.class_attribute :parent_association_name
+      end
+      
+      module ClassMethods
+        def inherits_from(association_name, options={})
+          # Standardize options, and remove those that should not affect the belongs_to relationship
+          options = Child::default_options.merge(options.to_options.reject { |k,v| v.nil? })
+          inherit_methods = options.delete(:inherit_methods)
+          
+          include InstanceMethods
+          include DelegateMethods if inherit_methods
+          
+          # Set association references.
+          self.parent_association_name = association_name.to_sym
+          self.primary_key = "#{parent_association_name}_id"
+          
+          # Ensure parent association is always returned.
+          define_method("#{parent_association_name}_with_autobuild") do
+            send("#{parent_association_name}_without_autobuild") || send("build_#{parent_association_name}")
+          end
+          
+          # Allow getting and setting of parent attributes and relationships.
+          inherited_columns_and_associations.each do |name|
+            delegate name, "#{name}=", :to => parent_association_name
+          end
+          
+          # Ensure parent's accessible attributes are accessible in child.
+          parent_association_class.accessible_attributes.each do |attr|
+            attr_accessible attr.to_sym
+          end
+          
+          # Bind relationship, handle validation, and save properly.
+          belongs_to parent_association_name, options
+          alias_method_chain parent_association_name, :autobuild
+          before_validation :set_association_subtype
+          validate :parent_association_must_be_valid
+          before_save :parent_association_must_be_saved
+        end
+        
+        private
+        
+        def parent_association_class
+          reflection = create_reflection(:belongs_to, parent_association_name, {}, self)
+          reflection.class_name.constantize
+        end
+        
+        def inherited_columns_and_associations
+          # Get the associated columns and relationship names
+          inherited_columns = parent_association_class.column_names
+          inherited_methods = parent_association_class.reflections.map { |key, value| key.to_s }
+          
+          # Filter out columns that the class already has
+          # inherited_columns = inherited_columns.reject do |column|
+          #   (self.column_names.grep(column).length > 0) || (column == 'type') || (column == parent_association_class.subtype_column)
+          # end
+          
+          # Filter out methods that the class already has
+          inherited_methods = inherited_methods.reject do |method|
+            self.reflections.map { |key, value| key.to_s }.include?(method)
+          end
+          
+          inherited_columns + inherited_methods - ['id']
+        end
+      end
+      
+      module InstanceMethods
+        private
+        
+        def parent_association
+          send(self.class.parent_association_name)
+        end
+        
+        def set_association_subtype
+          association = parent_association
+          if association.attribute_names.include?(association.class.subtype_column)
+            association[association.class.subtype_column] = self.class.to_s
+          end
+        end
+        
+        def parent_association_must_be_valid
+          association = parent_association
+          
+          unless valid = association.valid?
+            association.errors.each do |attr, message|
+              errors.add(attr, message)
+            end
+          end
+          
+          valid
+        end
+        
+        def parent_association_must_be_saved
+          association = parent_association
+          association.save(:validate => false)
+          self.id = association.id
+        end
+      end
+      
+      module DelegateMethods
+        private
+        
+        def method_missing(name, *args)
+          if parent_association.respond_to?(name)
+            parent_association.public_send(name, *args)
+          else
+            super(name, *args)
+          end
+        end
+        
+        def respond_to?(name)
+          parent_association.respond_to?(name) || super
+        end
+      end
+    end
+  end
+end

data/lib/multiple_table_inheritance/active_record/child.rb.bak

@@ -0,0 +1,132 @@
+module MultipleTableInheritance
+  module ActiveRecord
+    module Child
+      def self.default_options
+        { :dependent => :destroy, :inherit_methods => false }
+      end
+      
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      
+      module ClassMethods
+        def inherits_from(association_name, options={})
+          # Standardize parameters.
+          association_name = association_name.to_sym
+          options = Child::default_options.merge(options.to_options.reject { |k,v| v.nil? })
+          
+          # Remove options that should not affect the belongs_to relationship.
+          inherit_methods = options.delete(:inherit_methods)
+          
+          # Add an association, and set the foreign key.
+          belongs_to association_name, options
+          
+          # Set the primary key since the inheriting table includes no `id` column.
+          self.primary_key = "#{association_name}_id"
+          
+          # Always return an instance of the parent class, whether it be an existing or new instance.
+          always_return_association(association_name)
+          
+          # Ensure the parent specifies the current class as the subtype.
+          associate_before_validation(association_name)
+          
+          # Bind the validation of association.
+          validate_association(association_name)
+          
+          # Ensure both the parent and the child records are saved.
+          save_association(association_name)
+          
+          # Create proxy methods for instances of this class.
+          create_instance_methods(association_name)
+          
+          # Delegate all missing method calls to the parent association if preferred.
+          delegate_parent_methods(association_name) if inherit_methods
+        end
+        
+        private
+        
+        def always_return_association(association_name)
+          define_method("#{association_name}_with_autobuild") do
+            send("#{association_name}_without_autobuild") || send("build_#{association_name}")
+          end
+          
+          alias_method_chain association_name, :autobuild    
+        end
+        
+        def associate_before_validation(association_name)
+          define_method(:set_subtype) do
+            association = send(association_name)
+            if association.attribute_names.include?(association.class.subtype_column)
+              association[association.class.subtype_column] = self.class.to_s
+            end
+          end
+          
+          before_validation :set_subtype
+        end
+        
+        def validate_association(association_name)
+          define_method(:parent_association_must_be_valid) do
+            association = send(association_name)
+            
+            unless valid = association.valid?
+              association.errors.each do |attr, message|
+                errors.add(attr, message)
+              end
+            end
+            
+            valid
+          end
+          
+          validate :parent_association_must_be_valid
+        end
+        
+        def save_association(association_name)
+          define_method(:parent_association_must_be_saved) do
+            association = send(association_name)
+            association.save(:validate => false)
+            self.id = association.id
+          end
+          
+          before_save :parent_association_must_be_saved
+        end
+        
+        def create_instance_methods(association_name)
+          inherited_columns_and_methods(association_name).each do |name|
+            delegate name, "#{name}=", :to => association_name
+          end
+        end
+        
+        def inherited_columns_and_methods(association_name)
+          # Get the class of association by reflection
+          reflection = create_reflection(:belongs_to, association_name, {}, self)
+          association_class = reflection.class_name.constantize
+          inherited_columns = association_class.column_names
+          inherited_methods = association_class.reflections.map { |key, value| key.to_s }
+          
+          # Filter out columns that the class already has
+          inherited_columns = inherited_columns.reject do |column|
+            (self.column_names.grep(column).length > 0) || (column == 'type') || (column == association_class.subtype_column)
+          end
+          
+          # Filter out columns that the class already has
+          inherited_methods = inherited_methods.reject do |method|
+            self.reflections.map { |key, value| key.to_s }.include?(method)
+          end
+          
+          inherited_columns + inherited_methods - ['id']
+        end
+        
+        def delegate_parent_methods(association_name)
+          define_method("method_missing") do |name, *args|
+            association = self.public_send(association_name)
+            if association.present? && association.respond_to?(name)
+              association.send(name, *args)
+            else
+              super(name, *args)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/multiple_table_inheritance/active_record/migration.rb

@@ -0,0 +1,20 @@
+module MultipleTableInheritance
+  module ActiveRecord
+    module Migration
+      def self.included(base)
+        base.class_eval do
+          alias_method_chain :create_table, :inherits
+        end
+      end
+      
+      # Generate the association field.
+      def create_table_with_inherits(table_name, options = {}, &block)
+        options[:primary_key] = "#{options[:inherits]}_id" if options[:inherits]
+        
+        create_table_without_inherits(table_name, options) do |table_defintion|
+          yield table_defintion   
+        end  
+      end
+    end
+  end
+end

data/lib/multiple_table_inheritance/active_record/parent.rb

@@ -0,0 +1,65 @@
+module MultipleTableInheritance
+  module ActiveRecord
+    module Parent
+      def self.default_options
+        { :subtype => 'subtype' }
+      end
+      
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.class_attribute :subtype_column
+      end
+      
+      module ClassMethods
+        def acts_as_superclass(options={})
+          options = Parent::default_options.merge(options.to_options.reject { |k,v| v.nil? })
+          self.subtype_column = options[:subtype]
+          
+          if self.column_names.include?(subtype_column.to_s)
+            class << self
+              alias_method_chain :find_by_sql, :inherits
+            end
+          end
+        end
+        
+        private
+        
+        def find_by_sql_with_inherits(*args)
+          parent_records = find_by_sql_without_inherits(*args)
+          child_records = []
+          
+          # find all child records
+          ids_by_type(parent_records).each do |type, ids|
+            begin
+              klass = type.constantize
+              child_records += klass.find(ids)
+            rescue NameError => e
+              # TODO log error
+            end
+          end
+          
+          # associate the parent records with the child records to reduce SQL calls and prevent recursion
+          child_records.each do |child|
+            association_name = to_s.demodulize.underscore
+            parent = parent_records.find { |parent| child.id == parent.id }
+            child.send("#{association_name}=", parent)
+          end
+          
+          # TODO order the child_records array to match the order of the parent_records array (by comparing id's)
+          
+          child_records
+        end
+        
+        def ids_by_type(records)
+          subtypes = records.collect(&self.subtype_column.to_sym).uniq
+          subtypes = subtypes.collect do |subtype|
+            subtype_records = records.select { |record| record[subtype_column.to_sym] == subtype}
+            subtype_ids = subtype_records.collect { |record| record.id }
+            [subtype, subtype_ids]
+          end
+          Hash[subtypes]
+        end
+      end
+    end
+  end
+end

data/lib/multiple_table_inheritance/active_record.rb

@@ -0,0 +1,9 @@
+module MultipleTableInheritance
+  module ActiveRecord
+    extend ActiveSupport::Autoload
+    
+    autoload :Child
+    autoload :Parent
+    autoload :Migration
+  end
+end

data/lib/multiple_table_inheritance/railtie.rb

@@ -0,0 +1,22 @@
+module MultipleTableInheritance
+  if defined?(Rails::Railtie)
+    class Railtie < Rails::Railtie
+      initializer 'multiple_table_inheritance.insert_into_active_record' do
+        ::ActiveSupport.on_load(:active_record) { Railtie.insert }
+      end
+    end
+  end
+  
+  class Railtie
+    def self.insert
+      ::ActiveRecord::Base.module_eval do
+        include MultipleTableInheritance::ActiveRecord::Child
+        include MultipleTableInheritance::ActiveRecord::Parent
+      end
+      
+      ::ActiveRecord::ConnectionAdapters::SchemaStatements.module_eval do
+        include MultipleTableInheritance::ActiveRecord::Migration
+      end
+    end
+  end
+end

data/lib/multiple_table_inheritance/version.rb

@@ -0,0 +1,3 @@
+module MultipleTableInheritance
+  VERSION = "0.1.0"
+end

data/lib/multiple_table_inheritance.rb

@@ -0,0 +1,7 @@
+require 'multiple_table_inheritance/railtie'
+
+module MultipleTableInheritance
+  extend ActiveSupport::Autoload
+  
+  autoload :ActiveRecord
+end

data/multiiple_table_inheritance.gemspec

@@ -0,0 +1,33 @@
+# encoding: utf-8
+$:.push File.expand_path("../lib", __FILE__)
+require "multiple_table_inheritance/version"
+
+Gem::Specification.new do |s|
+  s.name        = "multiple_table_inheritance"
+  s.version     = MultipleTableInheritance::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Matt Huggins"]
+  s.email       = ["matt@matthuggins.com"]
+  s.homepage    = "http://github.com/mhuggins/multiple_table_inheritance"
+  s.summary     = "ActiveRecord plugin designed to allow simple multiple table inheritance."
+  s.description = "ActiveRecord plugin designed to allow simple multiple table inheritance."
+  
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  
+  s.rdoc_options     = ["--charset=UTF-8"]
+  s.extra_rdoc_files = ["README.md"]
+  
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.rubygems_version = %q{0.1.0}
+  
+  s.add_dependency('activerecord', '>= 3.0.0')
+  s.add_dependency('activesupport', '>= 3.0.0')
+  s.add_development_dependency('rspec-rails', '~> 2.8.0')
+  s.add_development_dependency('rspec_tag_matchers', '>= 1.0.0')
+  s.add_development_dependency('sqlite3-ruby', '>= 1.3.3')
+  s.add_development_dependency('database_cleaner', '>= 0.7.1')
+  # s.add_development_dependency('appraisal')
+end

data/spec/active_record/child_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe MultipleTableInheritance::ActiveRecord::Child do
+  context 'retrieving records' do
+    it 'should only fetch subtypes' do
+      subtypes = Employee.all.collect(&:subtype).uniq
+      subtypes.each do |subtype|
+        ['Programmer', 'Manager'].should include(subtype)
+      end
+    end
+    
+    it 'should fetch all child records' do
+      pending "find_by_sql_without_inherit.size.should == find_by_sql_with_inherit.size"
+    end
+    
+    context 'an invalid subtype is included' do
+      it 'should return successfully' do
+        pending "error should not be thrown"
+      end
+      
+      it 'should generate log entry' do
+        pending "logger.error should have been called"
+      end
+    end
+    
+    it 'should maintain result order' do
+      pending "find_by_sql_without_inherit.collect(&:id).should == find_by_sql_with_inherit.collect(&:id)"
+    end
+    
+    context 'default subtype used' do
+      pending "test_everything"
+    end
+    
+    context 'custom subtype used' do
+      pending "test_everything"
+    end
+    
+    it 'should work with namespaced classes' do
+      pending "test_everything"
+    end
+    
+    it 'should inherit parent methods' do
+      pending 'todo'
+    end
+  end
+  
+  context 'creating records' do
+    pending "todo"
+  end
+  
+  context 'updating records' do
+    pending "todo"
+  end
+  
+  context 'deleting records' do
+    pending "todo"
+  end
+end

data/spec/active_record/parent_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe MultipleTableInheritance::ActiveRecord::Parent do
+  it 'should do something' do
+    pending "test everything"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,48 @@
+require 'active_record'
+require 'database_cleaner'
+require File.expand_path(File.join(File.dirname(__FILE__), '../lib/multiple_table_inheritance'))
+require 'support/tables'
+require 'support/classes'
+
+module MultipleTableInheritanceSpecHelper
+  def mock_everything
+    @team = Team.create!(:name => 'Website')
+    @java = Language.create!(:name => 'Java')
+    @cpp = Language.create!(:name => 'C++')
+    @programmer = Programmer.create!(
+        :first_name => 'Mario',
+        :last_name => 'Mario',
+        :salary => 65000,
+        :team => @team,
+        :languages => [@java, @cpp])  # programmer-specific relationship
+    @manager = Manager.create!(
+        :first_name => 'King',
+        :last_name => 'Koopa',
+        :salary => 70000,
+        :team => @team,
+        :bonus => 5000)  # manager-specific field
+  end
+end
+
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  include MultipleTableInheritanceSpecHelper
+  
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  
+  config.before(:suite) do
+    DatabaseCleaner.strategy = :transaction
+    DatabaseCleaner.clean_with(:truncation)
+  end
+  
+  config.before(:each) do
+    DatabaseCleaner.start
+    mock_everything
+  end
+  
+  config.after(:each) do
+    DatabaseCleaner.clean
+  end
+end

data/spec/support/classes.rb

@@ -0,0 +1,40 @@
+class ::Employee < ActiveRecord::Base
+  acts_as_superclass
+  attr_accessible :first_name, :last_name, :salary
+  belongs_to :team
+  validates :first_name, :presence => true
+  validates :last_name, :presence => true
+  validates :salary, :presence => true, :numericality => { :min => 0 }
+end
+
+class ::Programmer < ActiveRecord::Base
+  inherits_from :employee
+  has_many :known_languages
+  has_many :languages, :through => :known_languages
+end
+
+class ::Manager < ActiveRecord::Base
+  inherits_from :employee
+  attr_accessible :bonus
+  validates :bonus, :numericality => true
+end
+
+class ::Team < ActiveRecord::Base
+  attr_accessible :name, :description
+  has_many :employees
+  validates :name, :presence => true, :uniqueness => true
+end
+
+class ::Language < ActiveRecord::Base
+  attr_accessible :name
+  has_many :known_languages
+  has_many :programmers, :through => :known_languages
+  validates :name, :presence => true, :uniqueness => true
+end
+
+class ::KnownLanguage < ActiveRecord::Base
+  belongs_to :programmer
+  belongs_to :language
+  validates :programmer_id, :presence => true
+  validates :language_id, :presence => true, :uniqueness => { :scope => :programmer_id }
+end

data/spec/support/tables.rb

@@ -0,0 +1,42 @@
+require 'multiple_table_inheritance/railtie'
+
+MultipleTableInheritance::Railtie.insert
+
+ActiveRecord::Base.establish_connection(
+  :adapter => 'sqlite3',
+  :database => File.expand_path(File.join(File.dirname(__FILE__), '../../db/multiple_table_inheritance.db'))
+)
+
+ActiveRecord::Base.connection do
+  ['employees', 'programmers', 'managers', 'teams', 'languages', 'known_languages'].each do |table|
+    execute "DROP TABLE IF EXISTS '#{table}'"
+  end
+  
+  create_table :employees do |t|
+    t.string :subtype, :null => false
+    t.string :first_name, :null => false
+    t.string :last_name, :null => false
+    t.integer :salary, :null => false 
+    t.integer :team_id
+  end
+  
+  create_table :programmers, :inherits => :employee do |t|
+  end
+  
+  create_table :managers, :inherits => :employee do |t|
+    t.integer :bonus
+  end
+  
+  create_table :teams do |t|
+    t.string :name, :null => false
+  end
+  
+  create_table :languages do |t|
+    t.string :name, :null => false
+  end
+  
+  create_table :known_languages do |t|
+    t.integer :programmer_id, :null => false
+    t.integer :language_id, :null => false
+  end
+end

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification
+name: multiple_table_inheritance
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Matt Huggins
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-06 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &2153063820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *2153063820
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &2153063240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *2153063240
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: &2153062780 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+  type: :development
+  prerelease: false
+  version_requirements: *2153062780
+- !ruby/object:Gem::Dependency
+  name: rspec_tag_matchers
+  requirement: &2153062140 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *2153062140
+- !ruby/object:Gem::Dependency
+  name: sqlite3-ruby
+  requirement: &2153061480 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.3.3
+  type: :development
+  prerelease: false
+  version_requirements: *2153061480
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: &2153060780 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+  type: :development
+  prerelease: false
+  version_requirements: *2153060780
+description: ActiveRecord plugin designed to allow simple multiple table inheritance.
+email:
+- matt@matthuggins.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- .rspec
+- Gemfile
+- README.md
+- Rakefile
+- lib/multiple_table_inheritance.rb
+- lib/multiple_table_inheritance/active_record.rb
+- lib/multiple_table_inheritance/active_record/child.rb
+- lib/multiple_table_inheritance/active_record/child.rb.bak
+- lib/multiple_table_inheritance/active_record/migration.rb
+- lib/multiple_table_inheritance/active_record/parent.rb
+- lib/multiple_table_inheritance/railtie.rb
+- lib/multiple_table_inheritance/version.rb
+- multiiple_table_inheritance.gemspec
+- spec/active_record/child_spec.rb
+- spec/active_record/parent_spec.rb
+- spec/spec_helper.rb
+- spec/support/classes.rb
+- spec/support/tables.rb
+homepage: http://github.com/mhuggins/multiple_table_inheritance
+licenses: []
+post_install_message: 
+rdoc_options:
+- --charset=UTF-8
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: ActiveRecord plugin designed to allow simple multiple table inheritance.
+test_files:
+- spec/active_record/child_spec.rb
+- spec/active_record/parent_spec.rb
+- spec/spec_helper.rb
+- spec/support/classes.rb
+- spec/support/tables.rb