multiple_table_inheritance 0.1.3 → 0.1.4

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - ruby-head
+  - ree

data/CHANGELOG.md

@@ -1,6 +1,13 @@
+0.1.4
+
+* Fixed mass assignment when security is only defined in child model.
+* Added support for namespaced models.
+* Added many more unit tests.
+
 0.1.3
 
 * Fixed a bug that prevented migrations from being run properly.
+* Added several unit tests.
 
 0.1.2
 

data/README.md

@@ -1,6 +1,8 @@
 Multiple Table Inheritance
 ==========================
 
+[![Build Status](https://secure.travis-ci.org/mhuggins/multiple_table_inheritance.png)](http://travis-ci.org/mhuggins/multiple_table_inheritance)
+
 Multiple Table Inheritance is a plugin designed to allow for multiple table
 inheritance between your database tables and your ActiveRecord models.
 
@@ -19,15 +21,20 @@ How to Install
 
 From the command line:
 
-    gem install multiple-table-inheritance
+    gem install multiple_table_inheritance
 
 From your Gemfile:
 
-    gem 'multiple_table_inheritance', '~> 0.1.3'
+    gem 'multiple_table_inheritance', '~> 0.1.4'
 
 Usage
 =====
 
+The following sections attempt to explain full coverage for the Multiple Table
+Inheritance plugin.  For full code examples, take a look at the test database
+structure and associated models found in `spec/support/tables.rb` and
+`spec/support/models.rb`, respectively.
+
 Running Migrations
 ------------------
 
@@ -44,8 +51,10 @@ that this column be non-null for sanity.
       t.timestamps
     end
 
-When creating tables that are derived from your superclass table, simple
-provide the `:inherits` hash option to your `create_table` call.
+When creating tables that are derived from your superclass table, simply
+provide the `:inherits` hash option to your `create_table` call.  The value of
+the option represent the name by which the association is referenced in your
+model.
 
     create_table :programmers, :inherits => :employee do |t|
       t.datetime :training_completed_at
@@ -96,6 +105,11 @@ to `inherits_from`.  (Presently, this has only be tested to work with the
 Creating Records
 ----------------
 
+Records can be created directly from their inheriting (child) model classes.
+Given model names `Employee`, `Programmer`, and `Manager` based upon the table
+structures outlined in the "Running Migrations" section, records can be created
+in the following manner.
+
     Programmer.create(
         :first_name => 'Bob',
         :last_name => 'Smith',
@@ -142,18 +156,18 @@ Validation
 When creating a new record that inherits from another model, validation is
 taken into consideration across both models.
 
-    class ::Employee < ActiveRecord::Base
+    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
+    class Programmer < ActiveRecord::Base
       inherits_from :employee
     end
     
-    class ::Manager < ActiveRecord::Base
+    class Manager < ActiveRecord::Base
       inherits_from :employee
       validates :bonus, :presence => true, :numericality => true
     end
@@ -180,12 +194,6 @@ for a normal ActiveRecord model.
       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
 ------------
 
@@ -220,3 +228,31 @@ Associations will also work in the same way as other attributes.
     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'
+
+Methods
+-------
+
+When inheriting from another parent model, methods can optionally be called on
+the parent model automatically as well.  To do so, specify the `:methods`
+option when calling `inherits_from`.
+
+    class Employee < ActiveRecord::Base
+      acts_as_superclass
+      belongs_to :team
+      
+      def give_raise!(amount)
+        update_attribute!(:salary, self.salary + amount)
+        puts "Congrats on your well-deserved raise, #{self.first_name}!"
+      end
+    end
+    
+    class Programmer < ActiveRecord::Base
+      inherits_from :employee, :methods => true
+    end
+    
+    @programmer = Programmer.first
+    @programmer.give_raise!
+    # yields: "Congrats on your well-deserved raise, Mike!"
+
+NOTE: This is not fully implemented yet as of version 0.1.4.  Please wait until
+a future release to prior to using this feature.

data/lib/multiple_table_inheritance/child.rb

@@ -3,5 +3,6 @@ module MultipleTableInheritance
     extend ActiveSupport::Autoload
     
     autoload :Base
+    autoload :Sanitizer
   end
 end

data/lib/multiple_table_inheritance/child/base.rb

@@ -2,7 +2,7 @@ module MultipleTableInheritance
   module Child
     module Base
       def self.default_options
-        { :dependent => :destroy, :inherit_methods => false }
+        { :dependent => :destroy, :methods => false }
       end
       
       def self.included(base)
@@ -14,7 +14,7 @@ module MultipleTableInheritance
         def inherits_from(association_name, options={})
           # Standardize options, and remove those that should not affect the belongs_to relationship
           options = Base::default_options.merge(options.to_options)
-          inherit_methods = options.delete(:inherit_methods)
+          inherit_methods = options.delete(:methods)
           
           extend FinderMethods, SharedMethods
           include InstanceMethods, SharedMethods
@@ -39,6 +39,9 @@ module MultipleTableInheritance
             attr_accessible attr.to_sym
           end
           
+          # Sanitize attributes across parent and child
+          self.mass_assignment_sanitizer = Child::Sanitizer.new(self)
+          
           # Bind relationship, handle validation, and save properly.
           belongs_to parent_association_name, options
           alias_method_chain parent_association_name, :autobuild
@@ -47,13 +50,13 @@ module MultipleTableInheritance
           before_save :parent_association_must_be_saved
         end
         
-        private
-        
         def parent_association_class
           reflection = create_reflection(:belongs_to, parent_association_name, {}, self)
           reflection.klass
         end
         
+        private
+        
         def inherited_columns_and_associations
           # Get the associated columns and relationship names
           inherited_columns = parent_association_class.column_names
@@ -78,7 +81,8 @@ module MultipleTableInheritance
           child_records = super(*args)
           
           child_records.each do |child|
-            child.send(:parent_association=, parent_association_class.as_supertype.find_by_id(child.id))
+            parent = parent_association_class.as_supertype.find_by_id(child.id)
+            child.send(:parent_association=, parent)
           end
         end
       end
@@ -127,18 +131,17 @@ module MultipleTableInheritance
       end
       
       module DelegateMethods
-        private
-        
-        def method_missing(name, *args)
+        def method_missing(name, *args, &block)
           if parent_association.respond_to?(name)
-            parent_association.public_send(name, *args)
+            parent_association.send(name, *args, &block)
           else
-            super(name, *args)
+            super(name, *args, &block)
           end
         end
         
-        def respond_to?(name)
-          parent_association.respond_to?(name) || super
+        def respond_to?(name, *args)
+          return true if name.to_sym == :parent_association
+          super(name, *args) || parent_association.respond_to?(name)
         end
       end
     end

data/lib/multiple_table_inheritance/child/sanitizer.rb

@@ -0,0 +1,57 @@
+module MultipleTableInheritance
+  module Child
+    class Sanitizer < ActiveModel::MassAssignmentSecurity::LoggerSanitizer
+      def initialize(target)
+        @target = target
+        super
+      end
+      
+      def sanitize(attributes, authorizer)
+        sanitized_attributes = attributes.reject { |key, value| deny?(key) }
+        debug_protected_attribute_removal(attributes, sanitized_attributes)
+        sanitized_attributes
+      end
+      
+    protected
+      
+      def deny?(key)
+        return true if protected_attribute?(key)
+        return !accessible_attribute?(key)
+      end
+      
+      def protected_attribute?(key)
+        protected_attributes.include?(key)
+      end
+      
+      def accessible_attribute?(key)
+        return true if accessible_parent_attributes.empty? && parent_attribute_names.include?(key)
+        return true if accessible_child_attributes.empty? && child_attribute_names.include?(key)
+        accessible_attributes.include?(key)
+      end
+      
+      def protected_attributes
+        @protected_attributes ||= (@target.protected_attributes + @target.parent_association_class.protected_attributes)
+      end
+      
+      def accessible_attributes
+        @accessible_attributes ||= (@target.accessible_attributes + @target.parent_association_class.accessible_attributes)
+      end
+      
+      def accessible_child_attributes
+        @accessible_child_attributes ||= @target.accessible_attributes
+      end
+      
+      def accessible_parent_attributes
+        @accessible_parent_attributes ||= @target.parent_association_class.accessible_attributes
+      end
+      
+      def child_attribute_names
+        @child_attribute_names ||= @target.attribute_names
+      end
+      
+      def parent_attribute_names
+        @parent_attribute_names ||= @target.parent_association_class.attribute_names
+      end
+    end
+  end
+end

data/lib/multiple_table_inheritance/parent/base.rb

@@ -31,7 +31,7 @@ module MultipleTableInheritance
             child.delete
           end
         rescue NameError => e
-          # TODO log error
+          logger.warn "Can't find matching child association for deletion: #{self.class} ##{id}" if logger
         end
         
         def find_by_subtype(*args)

data/lib/multiple_table_inheritance/parent/relation.rb

@@ -19,7 +19,7 @@ module MultipleTableInheritance
             klass = type.constantize
             child_records += klass.find(ids)
           rescue NameError => e
-            # TODO log error
+            logger.warn "Can't find matching child association for deletion: #{type} #{ids.inspect}" if logger
           end
         end
         

data/lib/multiple_table_inheritance/version.rb

@@ -1,3 +1,3 @@
 module MultipleTableInheritance
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 end

data/spec/active_record/child_spec.rb

@@ -1,92 +1,415 @@
 require 'spec_helper'
 
 describe MultipleTableInheritance::Child do
-  context 'retrieving records' do
-    before do
-      programmer = Programmer.create!(:first_name => 'Bob', :last_name => 'Smith', :salary => 50000)
-      @programmer_id = programmer.id
-      @programmer = Programmer.find(@programmer_id)
+  context 'non-namespaced classes with default subtype' do
+    context 'retrieving records' do
+      before do
+        programmer = Programmer.create!(:first_name => 'Bob', :last_name => 'Smith', :salary => 50000)
+        @programmer_id = programmer.id
+        @programmer = Programmer.find(@programmer_id)
+      end
+      
+      it 'should retrieve child records' do
+        @programmer.should be_instance_of(Programmer)
+        @programmer.id.should be(@programmer_id)
+      end
+      
+      it 'should allow access to parent record' do
+        @programmer.employee.should be_instance_of(Employee)
+        @programmer.employee.id.should be(@programmer_id)
+      end
     end
     
-    it 'should retrieve child records' do
-      @programmer.should be_instance_of(Programmer)
-      @programmer.id.should be(@programmer_id)
+    context 'creating records' do
+      context 'with mass assignment security' do
+        context 'on just child' do
+          context 'without assigning all attributes' do
+            before(:each) do
+              @shirt = Shirt.create(:color => 'Red')
+            end
+            
+            it 'should have errors' do
+              @shirt.errors.messages.should_not be_empty
+              @shirt.errors.messages.keys.should include(:size)
+            end
+            
+            it 'should not have been saved' do
+              @shirt.should be_new_record
+            end
+          end
+          
+          context 'with all attributes assigned' do
+            before(:each) do
+              @shirt = Shirt.create(:color => 'Red', :size => 'XL')
+            end
+            
+            it 'should not have errors' do
+              @shirt.errors.messages.should be_empty
+            end
+            
+            it 'should have been saved' do
+              @shirt.should_not be_new_record
+            end
+          end
+        end
+        
+        context 'on just parent' do
+          context 'without assigning all attributes' do
+            before(:each) do
+              @janitor = Janitor.create(:first_name => 'Billy', :last_name => 'McGee')
+            end
+            
+            it 'should have errors' do
+              @janitor.errors.messages.should_not be_empty
+              @janitor.errors.messages.keys.should include(:salary)
+            end
+            
+            it 'should not have been saved' do
+              @janitor.should be_new_record
+            end
+          end
+          
+          context 'with all attributes assigned' do
+            before(:each) do
+              @janitor = Janitor.create(:first_name => 'Billy', :last_name => 'McGee', :salary => 40000, :favorite_cleaner => 'Swiffer')
+            end
+            
+            it 'should not have errors' do
+              @janitor.errors.messages.should be_empty
+            end
+            
+            it 'should have been saved' do
+              @janitor.should_not be_new_record
+            end
+          end
+        end
+        
+        context 'on child and parent' do
+          context 'with attributes set on instance' do
+            before(:each) do
+              @programmer = Programmer.create(:first_name => 'Joe', :last_name => 'Schmoe') do |programmer|
+                programmer.team = Team.first
+                programmer.salary = 45000
+              end
+            end
+            
+            it 'should not have errors' do
+              @programmer.errors.messages.should be_empty
+            end
+            
+            it 'should have been saved' do
+              @programmer.should_not be_new_record
+            end
+          end
+          
+          context 'with attributes specified in hash' do
+            before(:each) do
+              @programmer = Programmer.create(:first_name => 'Joe', :last_name => 'Schmoe', :salary => 45000)
+            end
+            
+            it 'should not have errors' do
+              @programmer.errors.messages.should be_empty
+            end
+            
+            it 'should have been saved' do
+              @programmer.should_not be_new_record
+            end
+          end
+        end
+      end
+      
+      context 'without mass assignment security' do
+        context 'without assigning all attributes' do
+          before(:each) do
+            @pants = Pants.create(:color => 'Blue', :waist_size => 32)
+          end
+          
+          it 'should have errors' do
+            @pants.errors.messages.should_not be_empty
+            @pants.errors.messages.keys.should include(:length)
+          end
+          
+          it 'should not have been saved' do
+            @pants.should be_new_record
+          end
+        end
+        
+        context 'with all attributes assigned' do
+          before(:each) do
+            @pants = Pants.create(:color => 'Blue', :waist_size => 32, :length => 34)
+          end
+          
+          it 'should not have errors' do
+            @pants.errors.messages.should be_empty
+          end
+          
+          it 'should have been saved' do
+            @pants.should_not be_new_record
+          end
+        end
+      end
     end
     
-    it 'should allow access to parent record' do
-      @programmer.employee.should be_instance_of(Employee)
-      @programmer.employee.id.should be(@programmer_id)
+    context 'updating records' do
+      pending "todo"
+    end
+    
+    context 'deleting records' do
+      before do
+        mock_employees!
+        @programmer = Programmer.first
+        @programmer_id = @programmer.id
+      end
+      
+      it 'should delete the parent record' do
+        @programmer.destroy
+        Employee.find_by_id(@programmer_id).should be_nil
+      end
+      
+      it 'should delete the child record' do
+        @programmer.destroy.should be_true
+        Programmer.find_by_id(@programmer_id).should be_nil
+      end
     end
   end
   
-  context 'creating records' do
-    context 'with mass assignment security' do
-      context 'specifying fields that are accessible' do
-        it 'should assign accessible fields' do
-          pending "create a model that allows for proper testing"
+  context 'namespaced classes with custom subtype' do
+    context 'retrieving records' do
+      before do
+        mock_pets!
+        @dog = Pet::Dog.first
+        @dog_id = @dog.id
+      end
+      
+      it 'should retrieve child records' do
+        @dog.should be_instance_of(Pet::Dog)
+        @dog.id.should be(@dog_id)
+      end
+      
+      it 'should allow access to parent record' do
+        @dog.pet.should be_instance_of(Pet::Pet)
+        @dog.pet.id.should be(@dog_id)
+      end
+    end
+    
+    context 'creating records' do
+      before(:each) do
+        @owner = Pet::Owner.create!(:first_name => 'Bob', :last_name => 'Smith') { |owner| owner.ssn = '123456789' }
+      end
+      
+      context 'with mass assignment security' do
+        context 'on just child' do
+          context 'without assigning all attributes' do
+            before(:each) do
+              @table = Store::Table.create(:brand => 'Rio', :name => 'Corner Office')
+            end
+            
+            it 'should have errors' do
+              @table.errors.messages.should_not be_empty
+              @table.errors.messages.keys.should include(:color)
+              @table.errors.messages.keys.should include(:chairs)
+            end
+            
+            it 'should not have been saved' do
+              @table.should be_new_record
+            end
+          end
+          
+          context 'with all attributes assigned' do
+            before(:each) do
+              @table = Store::Table.create(:brand => 'Rio', :name => 'Corner Office', :color => 'Brown', :chairs => 1)
+            end
+            
+            it 'should not have errors' do
+              @table.errors.messages.should be_empty
+            end
+            
+            it 'should have been saved' do
+              @table.should_not be_new_record
+            end
+          end
         end
         
-        it 'should save child associations' do
-          pending "create a model that allows for proper testing"
+        context 'on just parent' do
+          context 'with attributes set on instance' do
+            before(:each) do
+              @dog = Pet::Dog.create(:name => 'Fido') do |dog|
+                dog.owner = @owner
+                dog.color = 'black'
+                dog.favorite_toy = 'Squeeky Ball'
+              end
+            end
+            
+            it 'should not have errors' do
+              @dog.errors.messages.should be_empty
+            end
+            
+            it 'should have been saved' do
+              @dog.should_not be_new_record
+            end
+          end
+          
+          context 'with attributes specified in hash' do
+            before(:each) do
+              owner = Pet::Owner.create!(:first_name => 'Bob', :last_name => 'Smith') { |owner| owner.ssn = '123456789' }
+              @dog = Pet::Dog.create(:name => 'Fido', :color => 'black', :owner => @owner, :favorite_toy => 'Squeeky Ball')
+            end
+            
+            it 'should assign accessible fields' do
+              @dog.name.should be_present
+            end
+            
+            it 'should not assign secure fields' do
+              @dog.color.should_not be_present
+              @dog.owner.should_not be_present
+              @dog.owner_id.should_not be_present
+              @dog.favorite_toy.should_not be_present
+            end
+            
+            it 'should have errors' do
+              @dog.errors.messages.should_not be_empty
+            end
+            
+            it 'should not have been saved' do
+              @dog.should be_new_record
+            end
+          end
         end
         
-        it 'should save parent associations' do
-          pending "create a model that allows for proper testing"
+        context 'on child and parent' do
+          context 'with attributes set on instance' do
+            before(:each) do
+              @cat = Pet::Cat.create(:name => 'Mittens', :longest_nap => 100) do |cat|
+                cat.owner = @owner
+                cat.color = 'orange'
+              end
+            end
+            
+            it 'should not have errors' do
+              @cat.errors.messages.should be_empty
+            end
+            
+            it 'should have been saved' do
+              @cat.should_not be_new_record
+            end
+          end
+          
+          context 'with attributes specified in hash' do
+            before(:each) do
+              @cat = Pet::Cat.create(:name => 'Fido', :color => 'black', :owner => @owner, :longest_nap => 50)
+            end
+            
+            it 'should assign accessible fields' do
+              @cat.name.should be_present
+              @cat.longest_nap.should be_present
+            end
+            
+            it 'should not assign secure fields' do
+              @cat.color.should_not be_present
+              @cat.owner.should_not be_present
+              @cat.owner_id.should_not be_present
+            end
+            
+            it 'should have errors' do
+              @cat.errors.messages.should_not be_empty
+            end
+            
+            it 'should not have been saved' do
+              @cat.should be_new_record
+            end
+          end
         end
       end
       
-      context 'specifying fields that are not accessible' do
-        it 'should not assign secure fields' do
-          pending "create a model that allows for proper testing"
-        end
-        
-        it 'should not save child associations' do
-          pending "create a model that allows for proper testing"
+      context 'without mass assignment security' do
+        context 'without assigning all attributes' do
+          before(:each) do
+            @bed = Store::Bed.create(:brand => 'Sealy', :size => 'Queen')
+          end
+          
+          it 'should have errors' do
+            @bed.errors.messages.should_not be_empty
+            @bed.errors.messages.keys.should include(:name)
+          end
+          
+          it 'should not have been saved' do
+            @bed.should be_new_record
+          end
         end
         
-        it 'should not save parent associations' do
-          pending "create a model that allows for proper testing"
+        context 'with all attributes assigned' do
+          before(:each) do
+            @bed = Store::Bed.create(:brand => 'Sealy', :name => 'Feathertop', :size => 'Queen')
+          end
+          
+          it 'should not have errors' do
+            @bed.errors.messages.should be_empty
+          end
+          
+          it 'should have been saved' do
+            @bed.should_not be_new_record
+          end
         end
       end
     end
-  end
-  
-  context 'updating records' do
-    pending "todo"
-  end
-  
-  context 'deleting records' do
-    before do
-      mock_employees!
-      @programmer = Programmer.first
-      @programmer_id = @programmer.id
-    end
     
-    it 'should delete the parent record' do
-      @programmer.destroy
-      Employee.find_by_id(@programmer_id).should be_nil
+    context 'updating records' do
+      pending "todo"
     end
     
-    it 'should delete the child record' do
-      @programmer.destroy.should be_true
-      Programmer.find_by_id(@programmer_id).should be_nil
-    end
-  end
-  
-  context 'when instructed to inherit parent methods' do
-    it 'should inherit parent methods' do
-      pending "todo"
+    context 'deleting records' do
+      before do
+        mock_employees!
+        @programmer = Programmer.first
+        @programmer_id = @programmer.id
+      end
+      
+      it 'should delete the parent record' do
+        @programmer.destroy
+        Employee.find_by_id(@programmer_id).should be_nil
+      end
+      
+      it 'should delete the child record' do
+        @programmer.destroy.should be_true
+        Programmer.find_by_id(@programmer_id).should be_nil
+      end
     end
   end
   
   context 'methods' do
-    before do
-      mock_employees!
+    context 'accessing parent methods' do
+      context 'on models that allow methods to be inherited' do
+        before do
+          mock_employees!
+          @programmer = Programmer.first
+        end
+        
+        it 'should allow parent methods to be called through child' do
+          pending "infinite recursion must be addressed"
+          # @programmer.should respond_to(:give_raise!)
+        end
+      end
+      
+      context 'on models that do not allow methods to be inherited' do
+        before do
+          mock_pets!
+          @cat = Pet::Cat.first
+        end
+        
+        it 'should not allow parent methods to be called through child' do
+          @cat.should_not respond_to(:rename!)
+        end
+      end
     end
     
     context 'accessing parent records' do
       before do
-        @programmer = Programmer.create!(:first_name => 'Bob', :last_name => 'Smith', :salary => 50000)
+        @salary = 50000
+        @programmer = Programmer.create!(:first_name => 'Bob', :last_name => 'Smith', :salary => @salary)
+      end
+      
+      it 'should allow access to parent attribute methods' do
+        @programmer.salary.should == @salary
       end
       
       it 'should allow access to parent records' do
@@ -97,6 +420,10 @@ describe MultipleTableInheritance::Child do
     end
     
     context 'searching by id' do
+      before do
+        mock_employees!
+      end
+      
       context 'at the class level' do
         before do
           @employee_id = Employee.first.id