acts_as_relation 1.0.0 → 1.1.2

data/lib/active_record/acts_as_relation/access_methods.rb

@@ -0,0 +1,63 @@
+module ActiveRecord
+  module ActsAsRelation
+    module AccessMethods
+      def define_acts_as_accessors(model_name)
+        # The weird order of the if-else branches is so that we query ourselves
+        # before we query our superclass.
+        class_eval <<-EndCode, __FILE__, __LINE__ + 1
+          def read_attribute(attr_name, *args, &proc)
+            if attribute_method?(attr_name)
+              super(attr_name, *args)
+            else
+              #{model_name}.read_attribute(attr_name, *args, &proc)
+            end
+          end
+
+          def attributes
+            if #{model_name}.changed? || changed?
+              @attributes = #{model_name}.attributes.merge(super)
+            else
+              @attributes ||= #{model_name}.attributes.merge(super)
+            end
+          end
+
+          def attributes=(new_attributes)
+            sub = new_attributes.select { |k,v| attribute_method?(k) }
+            sup = new_attributes.select { |k,v| !attribute_method?(k) }
+            super(sub)
+            #{model_name}.attributes = sup
+          end
+
+          def touch(name = nil, *args, &proc)
+            if attribute_method?(name.to_s)
+              super(name, *args, &proc)
+            else
+              super(nil, *args, &proc)
+              #{model_name}.touch(name, *args, &proc)
+            end
+          end
+
+          def save(*args)
+            super(*args) && #{model_name}.save(*args)
+          end
+
+          def save!(*args)
+            super(*args) && #{model_name}.save!(*args)
+          end
+
+          private
+
+          def write_attribute(attr_name, *args, &proc)
+            if attribute_method?(attr_name.to_s)
+              super(attr_name, *args)
+            else
+              #{model_name}.send(:write_attribute, attr_name, *args, &proc)
+            end
+          end
+        EndCode
+      end
+
+      protected :define_acts_as_accessors
+    end
+  end
+end

data/lib/active_record/acts_as_relation/acts_as.rb

@@ -0,0 +1,34 @@
+module ActiveRecord
+  module ActsAsRelation
+    class ActsAs
+      attr_accessor :module
+      attr_reader :name, :class_name, :model, :association_name, :module_name, :module_name, :scope, :options
+
+      def initialize(model_name, scope = nil, options = {})
+        @model_name = model_name
+        @options, @scope = scope.is_a?(Hash) ? [scope, nil] : [options, scope]
+
+        @name             = @model_name.to_s.underscore.singularize.to_sym
+        @class_name       = @options[:class_name] || @name.to_s.camelcase
+        @model            = @class_name.constantize
+        @association_name = @options[:as] || @model.acts_as_association_name
+        @module_name      = "ActsAs#{name.to_s.camelcase}"
+      end
+
+      def parent_relations
+        @parent_relations ||= (model.reflect_on_all_associations.map(&:name) - [association_name]).map { |a| a.to_s + '_id' }
+      end
+
+      def has_one_options
+        @has_one_options ||= {
+          as:         association_name,
+          class_name: class_name,
+          inverse_of: association_name.to_sym,
+          autosave:   true,
+          validate:   false,
+          dependent:  options.fetch(:dependent, :destroy)
+        }
+      end
+    end
+  end
+end

data/lib/active_record/acts_as_relation/acts_as_modules.rb

@@ -0,0 +1,109 @@
+module ActiveRecord
+  module ActsAsRelation
+    module ActsAsModules
+      class << self
+        def [](acts_as)
+          if const_defined? acts_as.module_name
+            const_get acts_as.module_name
+          else
+            acts_as_module = Module.new
+            const_set acts_as.module_name, acts_as_module
+            acts_as.module = acts_as_module
+            create_assocication(acts_as)
+            autobuild_superclass(acts_as)
+            validate_superclass(acts_as)
+            make_superclass_methods_accessible(acts_as)
+            make_superclass_attributes_accessible(acts_as)
+            fix_is_a(acts_as)
+          end
+        end
+
+        def create_assocication(acts_as)
+          acts_as.module.extend ActiveSupport::Concern
+          acts_as.module.included do
+            has_one acts_as.name, acts_as.scope, acts_as.has_one_options
+            alias_method_chain acts_as.name, :autobuild
+
+            validate "#{acts_as.name}_must_be_valid".to_sym
+
+            extend ActiveRecord::ActsAsRelation::AccessMethods
+            define_acts_as_accessors(acts_as.name)
+
+            if defined?(::ProtectedAttributes)
+              attr_accessible.update(acts_as.model.attr_accessible)
+            end
+          end
+        end
+
+        def autobuild_superclass(acts_as)
+          acts_as.module.module_eval do
+            define_method "#{acts_as.name}_with_autobuild" do
+              send("#{acts_as.name}_without_autobuild") || send("build_#{acts_as.name}")
+            end
+          end
+        end
+
+        def make_superclass_methods_accessible(acts_as)
+          acts_as.module.module_eval do
+            define_method :method_missing do |method, *arg, &block|
+              if (method.to_s == 'id' || method.to_s == acts_as.name) || !send(acts_as.name).respond_to?(method)
+                super(method, *arg, &block)
+              else
+                class_eval do
+                  delegate method, to: acts_as.name
+                end
+                send(acts_as.name).send(method, *arg, &block)
+              end
+            end
+
+            define_method :respond_to? do |method, include_private_methods = false|
+              super(method, include_private_methods) || send(acts_as.name).respond_to?(method, include_private_methods)
+            end
+          end
+        end
+
+        def fix_is_a(acts_as)
+          acts_as.module.module_eval do
+            define_method :is_a? do |klass|
+              klass.name == acts_as.class_name ? true : super(klass)
+            end
+            alias_method :acts_as?, :is_a?
+          end
+        end
+
+        def make_superclass_attributes_accessible(acts_as)
+          acts_as.module.module_eval do
+            define_method :[] do |key|
+              if acts_as.parent_relations.include?(key.to_s)
+                send(acts_as.name)[key]
+              else
+                super(key)
+              end
+            end
+
+            define_method :[]= do |key, value|
+              if acts_as.parent_relations.include?(key.to_s)
+                send(acts_as.name)[key] = value
+              else
+                super(key, value)
+              end
+            end
+          end
+        end
+
+        def validate_superclass(acts_as)
+          acts_as.module.module_eval do
+            define_method "#{acts_as.name}_must_be_valid" do
+              unless send(acts_as.name).valid?
+                send(acts_as.name).errors.each do |att, message|
+                  errors.add(att, message)
+                end
+              end
+            end
+            protected "#{acts_as.name}_must_be_valid".to_sym
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/acts_as_relation/superclass_migration.rb

@@ -0,0 +1,32 @@
+module ActiveRecord
+  module ActsAsRelation
+    module SuperclassMigration
+      def self.included(base)
+        base.class_eval do
+          alias_method_chain :create_table, :as_relation_superclass
+        end
+      end
+
+      def create_table_with_as_relation_superclass(table_name, options = {})
+        create_table_without_as_relation_superclass(table_name, options) do |t|
+          if options.key? :as_relation_superclass
+            name = options[:as_relation_superclass]
+            if name == true
+              name = ActiveRecord::Base.acts_as_association_name table_name
+            end
+
+            t.integer "#{name}_id"
+            t.string "#{name}_type"
+            t.index ["#{name}_id", "#{name}_type"], name: "#{table_name}_#{name}_index"
+          end
+
+          yield t if block_given?
+        end
+      end
+    end
+  end
+
+  module ConnectionAdapters::SchemaStatements
+    include ActsAsRelation::SuperclassMigration
+  end
+end

data/lib/acts_as_relation.rb

@@ -1,2 +1,5 @@
 require 'active_record/acts_as_relation'
-require 'active_record/acts_as_relation_superclass_migration'
+require 'active_record/acts_as_relation/acts_as'
+require 'active_record/acts_as_relation/access_methods'
+require 'active_record/acts_as_relation/acts_as_modules'
+require 'active_record/acts_as_relation/superclass_migration'

data/lib/version.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
   module ActsAsRelation
-    VERSION = "1.0.0"
+    VERSION = '1.1.2'
   end
 end

data/spec/acts_as_relation_spec.rb

@@ -1,43 +1,62 @@
 require 'spec_helper'
 
-describe "Submodel" do
-  it "inherits Supermodel attributes" do
+describe 'Submodel' do
+  it 'respond to supermodel attributes' do
     pen = Pen.new
-    ['name', 'name=', 'name_changed?', 'name_was',
-     'price', 'price=', 'price_changed?', 'price_was'].each do |m|
-    pen = Pen.create :name => 'RedPen', :price => 0.8, :color => 'red'
-      pen.should respond_to(m)
+    %w(name name= name_changed? name_was price price= price_changed? price_was).each do |at|
+      expect(pen).to respond_to(at)
     end
+  end
+
+  it 'returns supermodel attributes with #attributes' do
+    pen = Pen.new
+    expect(pen.attributes.keys).to include(*%w(name price))
+  end
+
+  it 'makes supermodel attributes assingeable through #attributes=' do
+    pen = Pen.new
+    pen.attributes = {name: 'test', price: 10, color: 'black'}
+    expect(pen.name).to eq('test')
+    expect(pen.price).to eq(10)
+    expect(pen.color).to eq('black')
+  end
 
-    pen = Pen.create :name => 'RedPen', :price => 0.8, :color => 'red'
-    pen.name.should  == 'RedPen'
-    pen.price.should == 0.8
-    pen.color.should == 'red'
+  it 'accept supermodel attributes on create' do
+    pen = Pen.create name: 'RedPen', price: 0.8, color: 'red'
+    expect(pen.name).to eq('RedPen')
+    expect(pen.price).to eq(0.8)
+    expect(pen.color).to eq('red')
 
     pen.price = 0.9
-    pen.price_changed?.should be_true
-    pen.price_was.should == 0.8
+    expect(pen.price_changed?).to be true
+    expect(pen.price_was).to eq(0.8)
   end
 
-  it "inherits Supermodel associations" do
-    store = Store.create :name => 'Big Store'
-    pen = Pen.create :name => 'RedPen', :price => 0.8, :color => 'red'
+  it 'inherits Supermodel associations' do
+    store = Store.create name: 'Big Store'
+    pen = Pen.create name: 'RedPen', price: 0.8, color: 'red'
     pen.store = store
     pen.save
-    Pen.find(pen.id).store.should == store
-    Pen.find(pen.id).product.store.should == store
+    expect(Pen.find(pen.id).store).to eq(store)
+    expect(Pen.find(pen.id).product.store).to eq(store)
   end
 
-  it "inherits Supermodel validations" do
+  it 'inherits Supermodel validations' do
     pen = Pen.new
-    pen.should be_invalid
-    pen.errors.keys.should include(:name, :price, :color)
+    expect(pen).to be_invalid
+    expect(pen.errors.keys).to include(:name, :price, :color)
+  end
+
+  it 'inherits Supermodel methods' do
+    pen = Pen.create name: 'RedPen', price: 0.8, color: 'red'
+    expect(pen).to respond_to('parent_method')
+    expect(pen.parent_method).to eq('RedPen - 0.8')
   end
 
-  it "inherits Supermodel methods" do
-    pen = Pen.create :name => 'RedPen', :price => 0.8, :color => 'red'
-    pen.should respond_to('parent_method')
-    pen.parent_method.should == "RedPen - 0.8"
+  it 'raise NoMethodError correctly for Supermodel methods' do
+    pen = Pen.create name: 'RedPen', price: 0.8, color: 'red'
+    expect(pen).to respond_to('dummy_raise_method')
+    expect { pen.dummy_raise_method(nil) }.to raise_error(NoMethodError, /undefined method `dummy' for nil:NilClass/)
   end
 
   # it "inherits Supermodel dynamic finders" do
@@ -47,72 +66,130 @@ describe "Submodel" do
   #   Product.find_by_name('SomeProduct').should == product
   # end
 
-  it "should raise NoMethodEror on unexisting method calls" do
-    pen = Pen.create :name => 'RedPen', :price => 0.8, :color => 'red'
-    lambda { pen.unexisted_method }.should raise_error(NoMethodError)
+  it 'should raise NoMethodEror on unexisting method calls' do
+    pen = Pen.create name: 'RedPen', price: 0.8, color: 'red'
+    expect { pen.unexisted_method }.to raise_error(NoMethodError)
   end
 
-  it "destroies Supermodel on destroy" do
-    pen = Pen.create :name => 'RedPen', :price => 0.8, :color => 'red'
+  it 'destroies Supermodel on destroy' do
+    pen = Pen.create name: 'RedPen', price: 0.8, color: 'red'
     product_id = pen.product.id
     pen.destroy
-    lambda { Product.find product_id }.should raise_error(ActiveRecord::RecordNotFound)
+    expect { Product.find product_id }.to raise_error(ActiveRecord::RecordNotFound)
+  end
+
+  describe '#acts_as_other_model?' do
+    it 'return true on models wich acts_as other ones' do
+      expect(Pen.acts_as_other_model?).to be true
+    end
   end
 
-  describe "#acts_as_other_model?" do
-    it "return true on models wich acts_as other ones" do
-      Pen.acts_as_other_model?.should be_true
+  describe '#acts_as_model_name' do
+    it 'returns name of model wich it acts as' do
+      expect(Pen.acts_as_model_name).to eq(:product)
     end
   end
 
-  describe "#acts_as_model_name" do
-    it "returns name of model wich it acts as" do
-      Pen.acts_as_model_name.should == :product
+  describe '#is_a?' do
+    it 'should return true when the supermodel is passed' do
+      product = Product.new
+      expect(product.is_a?(Product)).to be true
+      expect(product.instance_of?(Product)).to be true
+      expect(product.is_a?(Product)).to be true
+      expect(product.acts_as?(Product)).to be true
+      expect(product.acts_as?(String)).to be false
+
+      pen = Pen.new
+      expect(pen.is_a?(Product)).to be true
+      expect(pen.instance_of?(Product)).to be true
+      expect(pen.is_a?(Product)).to be true
+      expect(pen.acts_as?(Product)).to be true
+      expect(pen.acts_as?(Store)).to be false
+    end
+
+    it 'should return true when the supermodel is passed to model' do
+      expect(Pen.acts_as? Product).to be true
+      expect(Pen.acts_as? String).to be false
+    end
+  end
+
+  context 'in a has_many relation' do
+    it 'should be appendable using << operator' do
+      store = Store.create(name: 'Big Store')
+      pen = Pen.create(name: 'RedPen', price: 0.8, color: 'red')
+      store.products << pen
+      expect(pen.store).to eq(store)
+    end
+
+    it 'should access child attributes' do
+      store = Store.create(name: 'Big Store')
+      pen = Pen.create(name: 'RedPen', price: 0.8, color: 'red')
+      store.products << pen
+      store.reload
+      expect(store.products.first.is_a?(Pen)).to be true
+      expect(store.products.first).to eq(pen)
+    end
+
+    it 'associate relation on saving superclass object' do
+      store = Store.new(name: 'Big Store')
+      pen = Pen.new(name: 'RedPen', price: 0.8, color: 'red')
+      store.products << pen
+      store.save
+      store.reload
+      expect(store.products.first).to eq(pen)
     end
   end
 
-  it "have supermodel attr_accessibles as attr_accessibles" do
+  it 'have supermodel attr_accessibles as attr_accessibles' do
     if defined?(::ProtectedAttributes)
       Pen.attr_accessible[:default].each do |a|
-        Pencil.attr_accessible[:default].should include(a)
+        expect(Pencil.attr_accessible[:default]).to include(a)
       end
     end
   end
 
-  it "should be findable" do
-    pen = Pen.create :name => 'RedPen', :price => 0.8, :color => 'red'
+  it 'should be findable' do
+    pen = Pen.create name: 'RedPen', price: 0.8, color: 'red'
     pen = Pen.find(pen.id)
-    pen.should be_valid
+    expect(pen).to be_valid
   end
 
-  it "should be saveable" do
-    pen = Pen.create :name => 'RedPen', :price => 0.8, :color => 'red'
+  it 'should be saveable' do
+    pen = Pen.create name: 'RedPen', price: 0.8, color: 'red'
     pen = Pen.find(pen.id)
-    lambda { pen.save }.should_not raise_error
+    expect { pen.save }.not_to raise_error
   end
 
-  describe "Query Interface" do
-    describe "auto_join" do
-      it "automaticaly joins Supermodel on Submodel queries" do
-        pen = Pen.create :name => 'RedPen',  :price => 0.8, :color => 'red'
-        Pen.create :name => 'RedPen2', :price => 1.2, :color => 'red'
-        Pen.create :name => 'BluePen', :price => 1.2, :color => 'blue'
-        lambda { Pen.where("price > 1").to_a }.should_not raise_error(ActiveRecord::StatementInvalid)
-        Pen.where("name = ?", "RedPen").should include(pen)
+  describe 'Query Interface' do
+    describe 'auto_join' do
+      it 'automaticaly joins Supermodel on Submodel queries' do
+        pen = Pen.create name: 'RedPen',  price: 0.8, color: 'red'
+        Pen.create name: 'RedPen2', price: 1.2, color: 'red'
+        Pen.create name: 'BluePen', price: 1.2, color: 'blue'
+        expect { Pen.where('price > 1').to_a }.not_to raise_error
+        expect(Pen.where('name = ?', 'RedPen')).to include(pen)
       end
 
-      it "can be disabled by setting auto_join option to false" do
-        lambda { Pencil.where("name = 1").to_a }.should raise_error(ActiveRecord::StatementInvalid)
+      it 'can be disabled by setting auto_join option to false' do
+        expect { Pencil.where('name = 1').to_a }.to raise_error(ActiveRecord::StatementInvalid)
       end
     end
   end
 end
 
-describe "Supermodel" do
-  describe "#specific" do
-    it "returns the specific subclass object" do
-      pen = Pen.create :name => 'RedPen', :price => 0.8, :color => 'red'
-      pen.product.specific.should == pen
+describe 'Supermodel' do
+  describe '#specific' do
+    it 'returns the specific subclass object' do
+      pen = Pen.create name: 'RedPen', price: 0.8, color: 'red'
+      expect(pen.product.specific).to eq(pen)
+    end
+  end
+
+  context 'on destroy' do
+    it 'deletes specific subclass' do
+      pen = Pen.create name: 'RedPen', price: 0.8, color: 'red'
+      pen.product.destroy
+      expect { pen.reload }.to raise_error(ActiveRecord::RecordNotFound)
     end
   end
 end