multiple_table_inheritance 0.1.0 → 0.1.1

data/.gitignore

@@ -0,0 +1,4 @@
+.rvmrc
+db
+Gemfile.lock
+*.gem

data/CHANGELOG.md

@@ -0,0 +1,10 @@
+0.1.1
+
+* Fixed bidirectional deletion of records.
+* Implemented find_by_id for classes and instances that inherit from other
+  models.
+* Added several unit tests.
+
+0.1.0
+
+* Initial release.

data/README.md

@@ -65,6 +65,13 @@ extended.
       acts_as_superclass
     end
 
+As mentioned in the migration section, the name of the subtype column can be
+defined here if it's something other than the default of "subtype".
+
+    class Employee < ActiveRecord::Base
+      acts_as_superclass, :subtype => 'employee_type'
+    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.
@@ -193,19 +200,19 @@ Associations will also work in the same way as other attributes.
       belongs_to :team
     end
     
-    class ::Programmer < ActiveRecord::Base
+    class Programmer < ActiveRecord::Base
       inherits_from :employee
       has_many :known_languages
       has_many :languages, :through => :known_languages
     end
     
-    class ::Language < ActiveRecord::Base
+    class Language < ActiveRecord::Base
       attr_accessible :name
       has_many :known_languages
       has_many :programmers, :through => :known_languages
     end
     
-    class ::KnownLanguage < ActiveRecord::Base
+    class KnownLanguage < ActiveRecord::Base
       belongs_to :programmer
       belongs_to :language
     end

data/Rakefile

@@ -4,44 +4,3 @@ 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

@@ -16,6 +16,8 @@ module MultipleTableInheritance
           options = Child::default_options.merge(options.to_options.reject { |k,v| v.nil? })
           inherit_methods = options.delete(:inherit_methods)
           
+          extend SharedMethods
+          include SharedMethods
           include InstanceMethods
           include DelegateMethods if inherit_methods
           
@@ -72,6 +74,12 @@ module MultipleTableInheritance
         end
       end
       
+      module SharedMethods
+        def find_by_id(*args)
+          send("find_by_#{parent_association_name}_id", *args)
+        end
+      end
+      
       module InstanceMethods
         private
         

data/lib/multiple_table_inheritance/active_record/migration.rb

@@ -2,18 +2,14 @@ module MultipleTableInheritance
   module ActiveRecord
     module Migration
       def self.included(base)
-        base.class_eval do
-          alias_method_chain :create_table, :inherits
-        end
+        base.extend ClassMethods
       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  
+      module ClassMethods
+        def create_table(table_name, options = {}, &block)
+          options[:primary_key] = "#{options[:inherits]}_id" if options[:inherits]
+          super(table_name, options, &block)
+        end
       end
     end
   end

data/lib/multiple_table_inheritance/active_record/parent.rb

@@ -6,7 +6,7 @@ module MultipleTableInheritance
       end
       
       def self.included(base)
-        base.extend(ClassMethods)
+        base.extend ClassMethods
         base.class_attribute :subtype_column
       end
       
@@ -15,20 +15,20 @@ module MultipleTableInheritance
           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
+          if column_names.include?(subtype_column.to_s)
+            extend FinderMethods
+            include InstanceMethods
+            before_destroy :destroy_child_association
           end
         end
-        
-        private
-        
-        def find_by_sql_with_inherits(*args)
-          parent_records = find_by_sql_without_inherits(*args)
+      end
+      
+      module FinderMethods
+        def find_by_sql(*args)
+          parent_records = super(*args)
           child_records = []
           
-          # find all child records
+          # Find all child records.
           ids_by_type(parent_records).each do |type, ids|
             begin
               klass = type.constantize
@@ -38,20 +38,25 @@ module MultipleTableInheritance
             end
           end
           
-          # associate the parent records with the child records to reduce SQL calls and prevent recursion
+          # 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
+          # Order the child_records array to match the order of the parent_records array.
+          child_records.sort! do |a, b|
+            a_index = parent_records.index { |parent| parent.id == a.id }
+            b_index = parent_records.index { |parent| parent.id == b.id }
+            a_index <=> b_index
+          end
         end
         
+        private
+        
         def ids_by_type(records)
-          subtypes = records.collect(&self.subtype_column.to_sym).uniq
+          subtypes = records.collect(&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 }
@@ -60,6 +65,21 @@ module MultipleTableInheritance
           Hash[subtypes]
         end
       end
+      
+      module InstanceMethods
+        def destroy_child_association
+          child_class = send(subtype_column.to_sym).constantize
+          if child = child_class.find_by_id(id)
+            child.delete
+          end
+        rescue NameError => e
+          # TODO log error
+        end
+        
+        def find_by_subtype(*args)
+          super || send("find_by_#{subtype_column}", *args)
+        end
+      end
     end
   end
 end

data/lib/multiple_table_inheritance/version.rb

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

data/multiiple_table_inheritance.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |s|
   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.rubygems_version = %q{1.3.6}
   
   s.add_dependency('activerecord', '>= 3.0.0')
   s.add_dependency('activesupport', '>= 3.0.0')

data/spec/active_record/child_spec.rb

@@ -2,46 +2,7 @@ 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
+    pending "todo"
   end
   
   context 'creating records' do
@@ -55,4 +16,37 @@ describe MultipleTableInheritance::ActiveRecord::Child do
   context 'deleting records' do
     pending "todo"
   end
+  
+  context 'when instructed to inherit parent methods' do
+    it 'should inherit parent methods' do
+      pending "todo"
+    end
+  end
+  
+  context 'searching by id' do
+    context 'at the class level' do
+      before do
+        @employee_id = Employee.first.id
+        @employee = Employee.find_by_id(@employee_id)
+      end
+      
+      it 'should return a valid record' do
+        @employee.should be_instance_of(@employee.subtype.constantize)
+        @employee.id.should be(@employee_id)
+      end
+    end
+    
+    context 'at the instance level' do
+      before do
+        team = Team.first
+        @employee_id = team.employees.first.id
+        @employee = team.employees.find_by_id(@employee_id)
+      end
+      
+      it 'should return a valid record' do
+        @employee.should be_instance_of(@employee.subtype.constantize)
+        @employee.id.should be(@employee_id)
+      end
+    end
+  end
 end

data/spec/active_record/helper_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe MultipleTableInheritanceSpecHelper do
+  it 'should allow records to be found without inheritance' do
+    pending "find_without_inheritance is not working as intended"
+    employees = Employee.find_without_inheritance { Employee.all }
+    employees.each do |employee|
+      employee.should be_instance_of(Employee)
+    end
+  end
+end

data/spec/active_record/parent_spec.rb

@@ -1,7 +1,72 @@
 require 'spec_helper'
 
 describe MultipleTableInheritance::ActiveRecord::Parent do
-  it 'should do something' do
-    pending "test everything"
+  context 'retrieving records' do
+    it 'should only fetch child records' do
+      Employee.find_each do |employee|
+        employee.should_not be_instance_of(Employee)
+        ['Programmer', 'Manager'].should include(employee.class.to_s)
+      end
+    end
+    
+    it 'should fetch all child records' do
+      pending "find_without_inheritance is not working as intended"
+      modified_results = Employee.all
+      original_results = Employee.find_without_inheritance { Employee.all }
+      modified_results.size.should == original_results.size
+    end
+    
+    it 'should maintain result order' do
+      pending "find_without_inheritance is not working as intended"
+      modified_results = Employee.order("id desc").all
+      original_results = Employee.find_without_inheritance { Employee.order("id desc").all }
+      modified_results.collect(&:id).should == original_results.collect(&:id)
+    end
+    
+    context 'an invalid subtype exists' do
+      before do
+        @employee = Employee.create!(:first_name => 'Sub', :last_name => 'Type', :salary => 50000, :team => @team) do |employee|
+          employee.subtype = 'DoesNotExist'
+        end
+      end
+      
+      it 'should return successfully' do
+        @employee.should be_instance_of(Employee)
+      end
+      
+      it 'should log an error' do
+        pending "logger.error should have been called"
+      end
+    end
+    
+    context 'default subtype used' do
+      pending "test_everything"
+    end
+    
+    context 'custom subtype used' do
+      pending "test_everything"
+    end
+    
+    context 'namespaced classes are being used' do
+      pending "test_everything"
+    end
+  end
+  
+  context 'deleting records' do
+    before do
+      programmer = Programmer.create!(:first_name => 'Billy', :last_name => 'Ray', :salary => 50000, :team => @team)
+      @employee = programmer.employee
+      @employee_id = programmer.id
+    end
+    
+    it 'should delete the parent record' do
+      @employee.destroy.should be_true
+      Employee.find_by_id(@employee_id).should be_nil
+    end
+    
+    it 'should delete the child record' do
+      @employee.destroy.should be_true
+      Programmer.find_by_id(@employee_id).should be_nil
+    end
   end
 end

data/spec/spec_helper.rb

@@ -1,25 +1,38 @@
 require 'active_record'
 require 'database_cleaner'
-require File.expand_path(File.join(File.dirname(__FILE__), '../lib/multiple_table_inheritance'))
+require 'multiple_table_inheritance'
+
+MultipleTableInheritance::ActiveRecord::Parent::ClassMethods.module_eval do
+  def find_without_inheritance(&block)
+    # remove_method :find_by_sql
+    extend ActiveRecord::Querying
+    result = yield
+    extend MultipleTableInheritance::ActiveRecord::Parent::FinderMethods
+    result
+  end
+end
+
+MultipleTableInheritance::Railtie.insert
+
 require 'support/tables'
-require 'support/classes'
+require 'support/models'
 
 module MultipleTableInheritanceSpecHelper
   def mock_everything
-    @team = Team.create!(:name => 'Website')
-    @java = Language.create!(:name => 'Java')
-    @cpp = Language.create!(:name => 'C++')
-    @programmer = Programmer.create!(
+    team = Team.create!(:name => 'Website')
+    java = Language.create!(:name => 'Java')
+    cpp = Language.create!(:name => 'C++')
+    Programmer.create!(
         :first_name => 'Mario',
         :last_name => 'Mario',
         :salary => 65000,
-        :team => @team,
-        :languages => [@java, @cpp])  # programmer-specific relationship
-    @manager = Manager.create!(
+        :team => team,
+        :languages => [java, cpp])  # programmer-specific relationship
+    Manager.create!(
         :first_name => 'King',
         :last_name => 'Koopa',
         :salary => 70000,
-        :team => @team,
+        :team => team,
         :bonus => 5000)  # manager-specific field
   end
 end

data/spec/support/{classes.rb → models.rb}

@@ -1,38 +1,39 @@
-class ::Employee < ActiveRecord::Base
+class Employee < ActiveRecord::Base
   acts_as_superclass
-  attr_accessible :first_name, :last_name, :salary
+  attr_accessible :first_name, :last_name, :salary, :team, :team_id
   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
+class Programmer < ActiveRecord::Base
   inherits_from :employee
+  attr_accessible :languages, :language_ids
   has_many :known_languages
   has_many :languages, :through => :known_languages
 end
 
-class ::Manager < ActiveRecord::Base
+class Manager < ActiveRecord::Base
   inherits_from :employee
   attr_accessible :bonus
   validates :bonus, :numericality => true
 end
 
-class ::Team < ActiveRecord::Base
+class Team < ActiveRecord::Base
   attr_accessible :name, :description
   has_many :employees
   validates :name, :presence => true, :uniqueness => true
 end
 
-class ::Language < ActiveRecord::Base
+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
+class KnownLanguage < ActiveRecord::Base
   belongs_to :programmer
   belongs_to :language
   validates :programmer_id, :presence => true

data/spec/support/tables.rb

@@ -1,7 +1,3 @@
-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'))

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: multiple_table_inheritance
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-06 00:00:00.000000000Z
+date: 2012-03-08 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
-  requirement: &2153063820 !ruby/object:Gem::Requirement
+  requirement: &2155943940 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: 3.0.0
   type: :runtime
   prerelease: false
-  version_requirements: *2153063820
+  version_requirements: *2155943940
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: &2153063240 !ruby/object:Gem::Requirement
+  requirement: &2155943220 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: 3.0.0
   type: :runtime
   prerelease: false
-  version_requirements: *2153063240
+  version_requirements: *2155943220
 - !ruby/object:Gem::Dependency
   name: rspec-rails
-  requirement: &2153062780 !ruby/object:Gem::Requirement
+  requirement: &2155942320 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: 2.8.0
   type: :development
   prerelease: false
-  version_requirements: *2153062780
+  version_requirements: *2155942320
 - !ruby/object:Gem::Dependency
   name: rspec_tag_matchers
-  requirement: &2153062140 !ruby/object:Gem::Requirement
+  requirement: &2155941500 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,10 @@ dependencies:
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *2153062140
+  version_requirements: *2155941500
 - !ruby/object:Gem::Dependency
   name: sqlite3-ruby
-  requirement: &2153061480 !ruby/object:Gem::Requirement
+  requirement: &2155940740 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +65,10 @@ dependencies:
         version: 1.3.3
   type: :development
   prerelease: false
-  version_requirements: *2153061480
+  version_requirements: *2155940740
 - !ruby/object:Gem::Dependency
   name: database_cleaner
-  requirement: &2153060780 !ruby/object:Gem::Requirement
+  requirement: &2155939560 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,7 +76,7 @@ dependencies:
         version: 0.7.1
   type: :development
   prerelease: false
-  version_requirements: *2153060780
+  version_requirements: *2155939560
 description: ActiveRecord plugin designed to allow simple multiple table inheritance.
 email:
 - matt@matthuggins.com
@@ -85,23 +85,25 @@ extensions: []
 extra_rdoc_files:
 - README.md
 files:
+- .gitignore
 - .rspec
+- CHANGELOG.md
 - 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/helper_spec.rb
 - spec/active_record/parent_spec.rb
 - spec/spec_helper.rb
-- spec/support/classes.rb
+- spec/support/models.rb
 - spec/support/tables.rb
 homepage: http://github.com/mhuggins/multiple_table_inheritance
 licenses: []
@@ -130,7 +132,8 @@ specification_version: 3
 summary: ActiveRecord plugin designed to allow simple multiple table inheritance.
 test_files:
 - spec/active_record/child_spec.rb
+- spec/active_record/helper_spec.rb
 - spec/active_record/parent_spec.rb
 - spec/spec_helper.rb
-- spec/support/classes.rb
+- spec/support/models.rb
 - spec/support/tables.rb

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

@@ -1,132 +0,0 @@
-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