added unit testing

Author: thirtysixthspan

Rakefile

@@ -0,0 +1,24 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the class_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 class_table_inheritance plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ClassTableInheritance'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

init.rb

@@ -1,2 +1 @@
-require 'model'
-require 'migration'
+require 'cti'

lib/cti.rb

@@ -0,0 +1,2 @@
+require 'cti/model'
+require 'cti/migration'

lib/cti/migration.rb

@@ -0,0 +1,26 @@
+require 'active_record'
+
+module ClassTableInheritanceMigration  
+      
+  def create_cti_table(table_name, options = {})
+    options[:id] ||= false if options[:has_parent]
+    create_table(table_name, options) do |table_defintion|
+      if options[:has_parent]
+        association_type = Object.const_get(options[:has_parent].to_s.capitalize)
+        association_instance = association_type.send(:new)
+        attribute_column = association_instance.column_for_attribute(association_type.primary_key)
+        field_option = {:primary_key => true, :null => false}
+        field_option[:limit] = attribute_column.limit if attribute_column.limit                
+        table_defintion.column "#{options[:has_parent]}_id", attribute_column.type, field_option
+      end
+      if options[:has_children]
+        table_defintion.column "child_type", "string"
+        table_defintion.column "child_id", "integer"
+      end
+      yield table_defintion  
+    end 
+  end
+
+end
+
+ActiveRecord::ConnectionAdapters::AbstractAdapter::send :include, ClassTableInheritanceMigration

lib/cti/model.rb

@@ -0,0 +1,178 @@
+require 'active_record'
+
+class ActiveRecord::Base
+  
+  attr_reader :reflection
+  def self.has_children
+    class << self
+      self.class.instance_variable_set(:@cti,true)
+      alias_method :child_find_by_sql, :find_by_sql
+      def find_by_sql(sql)
+        objects = child_find_by_sql(sql)
+        if self.class.instance_variable_get(:@cti)
+          puts "cti #{self.class.instance_variable_get(:@cti)}"
+          objects.collect! do |obj|
+            if obj.child_type
+              child_class = Object.const_get(obj.child_type)
+              obj = child_class.find(obj.child_id)
+            end
+            obj
+          end
+        end  
+        objects
+      end
+      def cti
+        self.class.instance_variable_get(:@cti)
+      end
+      def cti=(value)
+        self.class.instance_variable_set(:@cti,value)
+      end
+    end
+  end
+
+  def self.has_parent(parent_class_name)
+
+    has_one parent_class_name, :as => :child
+
+    set_primary_key "#{parent_class_name}_id"
+    
+    # Fetch or build a parent instance
+    define_method(parent_class_name) do  
+      parent_id = "#{parent_class_name}_id"
+      @parent ||= send("build_#{parent_class_name}") unless eval(parent_id)
+      if !@parent
+        eval("#{parent_class_name.capitalize}.cti=false")     
+        @parent ||= eval("#{parent_class_name.capitalize}.find(#{parent_id})")     
+        eval("#{parent_class_name.capitalize}.cti=true")
+      end  
+      @parent
+    end
+
+    define_method('parent') do
+      send(parent_class_name)
+    end
+
+    before_save :save_parent
+
+    define_method("save_parent") do 
+      parent.save
+      self["#{parent_class_name}_id"] = parent.id
+      true
+    end  
+    
+    validate :parent_valid
+
+    # Assure parent is a valid class
+    define_method("parent_valid") do
+      unless valid = parent.valid?
+        parent.errors.each do |attr, message|
+          errors.add(attr, message)
+        end
+      end
+      valid
+    end    
+
+    # Determine and save parent class
+    reflection = create_reflection(:has_one, parent_class_name, {}, self)
+    parent_class = Object.const_get(reflection.class_name)
+    self.instance_variable_set(:@parent_class,parent_class) 
+
+    # Determine inherits from parent
+    columns = parent_class.column_names.reject { |c| self.column_names.grep(c).length > 0 || c == "child_type"}
+    methods = parent_class.reflections.map { |key,value| key.to_s }
+    methods = methods.reject { |c| self.reflections.map {|key, value| key.to_s }.include?(c) }
+    inherits = columns + methods
+    inherits.delete('id')
+    inherits.delete('parent')
+        
+    inherits.each do |name|
+      define_method name do
+        parent.send(name)
+      end	
+    	define_method "#{name}=" do |new_value|
+        parent.send("#{name}=", new_value)
+    	end
+    end
+
+    # Inherit constants
+    constants = parent_class.constants.reject { |c| self.constants.grep(c).length > 0}
+    constants.each do |name|
+      const_set(name,parent_class.const_get(name))
+    end
+    
+    class << self
+      alias_method :child_find, :find
+      def find(*args)
+        begin
+          child_find(*args)
+        rescue
+          @parent_class.find(*args) if @parent_class
+        end
+      end
+    end        
+  end
+  
+end
+
+
+class ActiveRecord::Relation
+
+  alias_method :child_first, :first
+  def first(*args)
+    begin
+      child_first(*args)
+    rescue
+      klass = @klass.instance_variable_get(:@parent_class)
+      if klass
+        @klass = klass
+        @table = klass.arel_table
+      end
+      child_first(*args)
+    end
+  end
+  
+  alias_method :child_last, :last
+  def last(*args)
+    begin
+      child_last(*args)
+    rescue
+      klass = @klass.instance_variable_get(:@parent_class)
+      if klass
+        @klass = klass
+        @table = klass.arel_table
+      end
+      child_last(*args)
+    end
+  end
+
+  # alias_method :child_to_a, :to_a
+  # def to_a
+  #   begin
+  #     child_to_a
+  #   rescue
+  #     klass = @klass.instance_variable_get(:@parent_class)
+  #     if klass
+  #       @klass = klass
+  #       @table = klass.arel_table
+  #     end
+  #     child_to_a
+  #   end
+  # end
+  # 
+
+  alias_method :child_find, :find
+  def find(*args)
+    begin
+      child_find(*args)
+    rescue
+      klass = @klass.instance_variable_get(:@parent_class)
+      if klass
+        @klass = klass
+        @table = klass.arel_table
+      end
+      child_find(*args)
+    end
+  end
+  
+end    
+

test/model_test.rb

@@ -0,0 +1,50 @@
+require 'test_helper'
+require 'pp'
+
+class TestModel < MiniTest::Unit::TestCase
+
+    def setup_db
+      return if defined?(@@db) && @@db
+      @@db = true
+
+      puts "DB Setup"
+      db_name = 'test/test.db'
+      system("rm -f #{db_name}")
+      SQLite3::Database.new(db_name)
+      ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => db_name)
+      require 'test_db'
+    end
+    
+    def setup
+      setup_db  
+    end
+
+    def teardown
+      ActiveRecord::Base.send(:descendants).each do |klass|
+        klass.delete_all
+      end
+    end
+    
+    def test_create_parent
+      pp obj = Product.create(:title=>'GI Joe Action figure',
+                           :price=>24.99)
+      assert_equal obj.class.name, 'Product'
+    end
+
+    def test_create_child
+      pp obj = Book.create(:title=>'War and Peace',
+                        :price=>8.50,
+                        :page_count=>700)
+      assert_equal obj.class.name, 'Book'
+    end
+
+    def test_create_grandchild
+      pp obj = Novel.create(:title=>'Neuromancer',
+                        :price=>5.25,
+                        :page_count=>250)
+      assert_equal obj.class.name, 'Novel'
+    end
+
+  
+  
+  end

test/test_db.rb

@@ -0,0 +1,42 @@
+
+ActiveRecord::Base.connection.create_cti_table :products, :has_children => true do |t|
+  t.string :title
+  t.decimal :price
+  t.timestamps
+end
+
+class Product < ActiveRecord::Base
+  has_children 
+end
+
+ActiveRecord::Base.connection.create_cti_table :books, :has_parent => :product do |t|
+  t.integer :page_count
+end
+
+class Book < ActiveRecord::Base
+  has_parent :product
+end
+
+ActiveRecord::Base.connection.create_cti_table :novels, :has_parent => :book do |t|
+  t.integer :chapter_count
+end
+
+class Novel < ActiveRecord::Base
+  has_parent :book
+end
+
+ActiveRecord::Base.connection.create_cti_table :encyclopedias, :has_parent => :book do |t|
+  t.integer :entry_count
+end
+
+class Encyclopedia < ActiveRecord::Base
+  has_parent :book
+end
+
+ActiveRecord::Base.connection.create_cti_table :videos, :has_parent => :product do |t|
+  t.integer :duration_in_minutes
+end
+
+class Video < ActiveRecord::Base
+  has_parent :product
+end

test/test_helper.rb

@@ -0,0 +1,4 @@
+require 'minitest/autorun'
+require 'sqlite3'
+require 'active_record'
+require 'cti'