acts_as_relation 0.0.5 → 0.1

data/.gitignore

@@ -3,4 +3,7 @@
 .rvmrc
 Gemfile.lock
 pkg/*
-
+tmp/*
+doc/*
+*.sqlite3
+*.log

data/.rspec

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

data/README.rdoc

@@ -0,0 +1,98 @@
+= ActsAsRelation
+
+A +acts_as+ relationship sets up a one-to-one connection with another model,
+such that declaring model inherits from other model (with separate database
+tabels). For example in a shop all products have common attributes (+name+,
++price+, +image+ ...), while each type of them has their specific attributes,
++pen+ has +color+, +book+ has +author+ and +publisher+ and so on.
+
+ActiveRecord only supports singletable inheritance, but with single table inheritance
+number of attributes on parent model (product in this example) grow exponentially,
+and must of them will always stay +NULL+.
+
++acts_as+ use a polymorphic +has_one+
+association to simulate a multi-table inheritance. For the shop example you'd
+declare the product as a +supermodel+ and all types of it as +acts_as+ +:product+
+(if you prefer you can use their aliases +is_a+ and +is_a_superclass+)
+
+  class Product < ActiveRecord::Base
+    acts_as_superclass
+  end
+
+  class Pen < ActiveRecord::Base
+    acts_as :product
+  end
+
+  class Book < ActiveRecord::Base
+    acts_as :product
+  end
+
+To make this work, you need to declare both a foreign key column and a type column
+in the model that declares superclass. To do this you can set +:as_relation_superclass+
+option to +true+ on +products+ +create_table+ (or pass it name of the association):
+
+  create_table :products, :as_relation_superclass => true do |t|
+    # ...
+  end
+
+Or declare them as you do on a +polymorphic+ +belongs_to+ association, it this case
+you must pass name to +acts_as+ in +:as+ option:
+
+  change_table :products do |t|
+    t.integer :producible_id
+    t.string  :producible_type
+  end
+
+  class Pen < ActiveRecord::Base
+    acts_as :product, :as => :producible
+  end
+
+Now +Pen+ and +Book+ *act* *as* +Product+. This means that they inherit +Product+
+_attributes_, _associations_, _validations_ and _methods_.
+
+To see its functionality lets add some stuff to product:
+
+  class Product
+    validates_presence_of :name, :price
+
+    def to_s
+      "#{name} $#{price}"
+    end
+  end
+
+now we can to things like this:
+
+  Pen.create :name => "Nice Pen", :price => 1.3, :color => "Red"
+  Pen.where "name = ?", "Some Pen"
+  pen = Pen.new
+  pen.valid?      # => false
+  pen.errors.keys # => [:name, :price]
+  Pen.first.to_s  # => "Nice Pen $1.3"
+
+When you declare an +acts_as+ relation, the declaring class automatically gains parent
+methods (includeing accessors) so you can access them directly.
+
+On the other hand you can always access a specific object from its parent by calling +specific+ method on it:
+
+    Product.first.specific # will return a specific product, a pen for example
+
+== Options
+The +acts_as+ relation support these options:
+
+* +:as+
+* +:auto_join+
+* +:class_name+
+* +:conditions+
+* +:dependent+
+* +:include+
+
+when +:auto_join+ option set to +true+ (wich is by default), every query on child
+will automatically joins with paren. For example:
+
+    Pen.where("name = ?", "somename")
+
+will result in the following SQL:
+
+    SELECT "pens".* FROM "pens" INNER JOIN "products" ON "products"."as_product_id" = "pens"."id" AND "products"."as_product_type" = 'Pen' WHERE (name = 'somename')
+
+All other options are same as +has_one+ options.

data/Rakefile

@@ -1,12 +1,7 @@
 require 'rake'
-require 'rake/testtask'
+require 'rspec/core/rake_task'
 
-task :default => :test
+task :default => :spec
 
-desc 'Test the acts_as_relation plugin.'
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib'
-  t.libs << 'test'
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = true
-end
+desc 'Run specs'
+RSpec::Core::RakeTask.new

data/acts_as_relation.gemspec

@@ -6,7 +6,7 @@ Gem::Specification.new do |s|
 
   # Description Meta...
   s.name        = 'acts_as_relation'
-  s.version     = ActiveRecord::Acts::AsRelation::VERSION
+  s.version     = ActiveRecord::ActsAsRelation::VERSION
   s.platform    = Gem::Platform::RUBY
   s.author      = 'Hassan Zamani'
   s.email       = 'hsn.zamani@gmail.com'
@@ -23,8 +23,9 @@ Gem::Specification.new do |s|
 
 
   # Dependencies (installed via 'bundle install')...
-  s.add_development_dependency("bundler")
-  s.add_development_dependency("rake")
-  s.add_development_dependency("sqlite3")
-  s.add_development_dependency("activerecord")
+  s.add_development_dependency "rake"
+  s.add_development_dependency "bundler"
+  s.add_development_dependency "sqlite3"
+  s.add_development_dependency "rspec"
+  s.add_dependency "activerecord"
 end

data/lib/active_record/acts_as_relation.rb

@@ -0,0 +1,137 @@
+module ActiveRecord
+
+  module ActsAsModules end
+
+  module ActsAsRelation
+    extend ActiveSupport::Concern
+
+    module AccessMethods
+      protected
+      def define_acts_as_accessors(attribs, model_name)
+        attribs.each do |attrib|
+          class_eval <<-EndEval
+            def #{attrib}
+              #{model_name}.#{attrib}
+            end
+
+            def #{attrib}=(value)
+              #{model_name}.#{attrib} = value
+            end
+
+            def #{attrib}?
+              #{model_name}.#{attrib}?
+            end
+          EndEval
+        end
+      end
+    end
+
+    module ClassMethods
+      def acts_as(model_name, options={})
+        name             = model_name.to_s.underscore.singularize
+        class_name       = options[:class_name] || name.camelcase
+        association_name = options[:as] || acts_as_association_name(name)
+        module_name      = "ActsAs#{name.camelcase}"
+
+        unless ActiveRecord::ActsAsModules.const_defined? module_name
+          # Create ActsAsModel module
+          acts_as_model = Module.new
+          ActiveRecord::ActsAsModules.const_set(module_name, acts_as_model)
+
+          has_one_options = {
+            :as         => association_name,
+            :class_name => class_name,
+            :autosave   => true,
+            :validate   => false,
+            :dependent  => options.fetch(:dependent, :destroy),
+            :include    => options[:include],
+            :conditions => options[:conditions]
+          }
+
+          acts_as_model.module_eval <<-EndEval
+            def self.included(base)
+              base.has_one :#{name}, #{has_one_options}
+              base.validate :#{name}_must_be_valid
+              base.alias_method_chain :#{name}, :autobuild
+
+              base.extend ActiveRecord::ActsAsRelation::AccessMethods
+              all_attributes = #{class_name}.content_columns.map(&:name)
+              ignored_attributes = ["created_at", "updated_at", "#{association_name}_id", "#{association_name}_type"]
+              associations = #{class_name}.reflect_on_all_associations.map! { |assoc| assoc.name } - ["#{association_name}"]
+              attributes_to_delegate = all_attributes - ignored_attributes + associations
+              base.send :define_acts_as_accessors, attributes_to_delegate, "#{name}"
+            end
+
+            def #{name}_with_autobuild
+              #{name}_without_autobuild || build_#{name}
+            end
+
+            def method_missing method, *arg, &block
+              raise NoMethodError if method.to_s == 'id' || method.to_s == '#{name}'
+
+              #{name}.send(method, *arg, &block)
+            rescue NoMethodError
+              super
+            end
+
+            def respond_to?(method, include_private_methods = false)
+              super || #{name}.respond_to?(method, include_private_methods)
+            end
+
+            protected
+
+            def #{name}_must_be_valid
+              unless #{name}.valid?
+                #{name}.errors.each do |att, message|
+                  errors.add(att, message)
+                end
+              end
+            end
+          EndEval
+        end
+
+        class_eval do
+          include "ActiveRecord::ActsAsModules::#{module_name}".constantize
+        end
+
+        if options.fetch :auto_join, true
+          class_eval "default_scope joins(:#{name})"
+        end
+
+        instance_eval <<-EndEval
+          def acts_as_other_model?
+            true
+          end
+
+          def acts_as_model_name
+            :#{name}
+          end
+        EndEval
+      end
+      alias :is_a :acts_as
+
+      def acts_as_superclass
+        association_name = acts_as_association_name
+
+        class_eval <<-EndEval
+          belongs_to :#{association_name}, :polymorphic => true
+
+          def specific
+            self.#{association_name}
+          end
+          alias :specific_class :specific
+        EndEval
+      end
+      alias :is_a_superclass :acts_as_superclass
+
+      def acts_as_association_name model_name=nil
+        model_name ||= self.name
+        "as_#{model_name.to_s.demodulize.singularize.underscore}"
+      end
+    end
+  end
+end
+
+class ActiveRecord::Base
+  include ActiveRecord::ActsAsRelation
+end

data/lib/active_record/acts_as_relation_superclass_migration.rb

@@ -0,0 +1,30 @@
+module ActiveRecord
+  module ActsAsRelationSuperclassMigration
+    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 |td|
+        if superclass = options[:as_relation_superclass]
+          association_name = if superclass.is_a? Symbol or superclass.is_a? String then
+                               superclass
+                             else
+                               ActiveRecord::Base.acts_as_association_name table_name
+                             end
+
+          td.integer "#{association_name}_id"
+          td.string  "#{association_name}_type"
+        end
+
+        yield td if block_given?
+      end
+    end
+  end
+end
+
+module ActiveRecord::ConnectionAdapters::SchemaStatements
+  include ActiveRecord::ActsAsRelationSuperclassMigration
+end

data/lib/acts_as_relation.rb

@@ -1,2 +1,2 @@
-require 'active_record/acts/as_relation'
-require 'active_record/acts/as_relation_superclass_migration'
+require 'active_record/acts_as_relation'
+require 'active_record/acts_as_relation_superclass_migration'

data/lib/version.rb

@@ -1,7 +1,5 @@
 module ActiveRecord
-  module Acts
-    module AsRelation
-      VERSION = "0.0.5"
-    end
+  module ActsAsRelation
+    VERSION = "0.1"
   end
 end

data/spec/acts_as_migration/acts_as_migratoin_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe "create_table acts_as_superclass" do
+  before :all do
+    ActsAsSuperclassSchema.migrate
+  end
+
+  it "creates foreign key and type columns on" do
+    name = Product.acts_as_association_name
+    Product.attribute_names.should include("#{name}_id")
+    Product.attribute_names.should include("#{name}_type")
+  end
+end
+
+describe "create_table acts_as_superclass option withname" do
+  before :all do
+    ActsAsSuperclassWithNameSchema.migrate
+  end
+
+  it "creates foreign key and type columns on" do
+    OtherProduct.attribute_names.should include("producible_id")
+    OtherProduct.attribute_names.should include("producible_type")
+  end
+end

data/spec/acts_as_migration/models.rb

@@ -0,0 +1,7 @@
+class Product < ActiveRecord::Base
+  acts_as_superclass
+end
+
+class OtherProduct < ActiveRecord::Base
+  acts_as_superclass
+end

data/spec/acts_as_migration/schema.rb

@@ -0,0 +1,33 @@
+module ActsAsSuperclassSchema
+  def self.migrate
+    ActiveRecord::Base.establish_connection(
+      :adapter  => "sqlite3",
+      :database => ":memory:"
+    )
+    ActiveRecord::Schema.define do
+      suppress_messages do
+        create_table :products, :as_relation_superclass => true do |t|
+        end
+      end
+    end
+
+    require Pathname(__FILE__).parent.join("models.rb")
+  end
+end
+
+module ActsAsSuperclassWithNameSchema
+  def self.migrate
+    ActiveRecord::Base.establish_connection(
+      :adapter  => "sqlite3",
+      :database => ":memory:"
+    )
+    ActiveRecord::Schema.define do
+      suppress_messages do
+        create_table :other_products, :as_relation_superclass => :producible do |t|
+        end
+      end
+    end
+
+    require Pathname(__FILE__).parent.join("models.rb")
+  end
+end

data/spec/acts_as_relation/acts_as_relation_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+describe "Submodel" do
+  before :all do
+    ActsAsRelationSchema.migrate
+  end
+
+  it "inherits 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)
+    end
+
+    pen = Pen.create :name => 'RedPen', :price => 0.8, :color => 'red'
+    pen.name.should  == 'RedPen'
+    pen.price.should == 0.8
+    pen.color.should == 'red'
+
+    pen.price = 0.9
+    pen.price_changed?.should be_true
+    pen.price_was.should == 0.8
+  end
+
+  it "inherits Supermodel associations" do
+    store = Store.new
+    pen = Pen.new
+    pen.store = store
+    pen.store.should == store
+    pen.product.store.should == store
+  end
+
+  it "inherits Supermodel validations" do
+    pen = Pen.new
+    pen.should be_invalid
+    pen.errors.keys.should include(:name, :price, :color)
+  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"
+  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)
+  end
+
+  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)
+  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
+    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
+    end
+  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)
+      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)
+      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
+    end
+  end
+end

data/spec/acts_as_relation/models.rb

@@ -0,0 +1,25 @@
+class Store < ActiveRecord::Base
+  has_many :products
+end
+
+class Product < ActiveRecord::Base
+  acts_as_superclass
+
+  belongs_to :store
+  validates_presence_of :name, :price
+
+  def parent_method
+    "#{name} - #{price}"
+  end
+end
+
+class Pen < ActiveRecord::Base
+  acts_as_superclass
+
+  acts_as :product
+  validates_presence_of :color
+end
+
+class Pencil < ActiveRecord::Base
+  acts_as :pen
+end

data/spec/acts_as_relation/schema.rb

@@ -0,0 +1,28 @@
+module ActsAsRelationSchema
+  def self.migrate
+    ActiveRecord::Base.establish_connection(
+      :adapter  => "sqlite3",
+      :database => ":memory:"
+    )
+    ActiveRecord::Schema.define do
+      suppress_messages do
+        create_table :stores do |t|
+          t.string :store_name
+        end
+
+        create_table :products, :as_relation_superclass => true do |t|
+          t.string  :name
+          t.float   :price
+        end
+
+        create_table :pens, :as_relation_superclass => true do |t|
+          t.string  :color
+        end
+
+        create_table :pencils
+      end
+    end
+
+    require Pathname(__FILE__).parent.join("models.rb")
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require 'active_record'
+require 'acts_as_relation'
+
+Dir[Pathname(__FILE__).parent.join "*/*schema.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: acts_as_relation
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: '0.1'
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-12-23 00:00:00.000000000 Z
+date: 2012-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: &10491360 !ruby/object:Gem::Requirement
+  name: rake
+  requirement: &17449100 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *10491360
+  version_requirements: *17449100
 - !ruby/object:Gem::Dependency
-  name: rake
-  requirement: &10490800 !ruby/object:Gem::Requirement
+  name: bundler
+  requirement: &17448680 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *10490800
+  version_requirements: *17448680
 - !ruby/object:Gem::Dependency
   name: sqlite3
-  requirement: &10490200 !ruby/object:Gem::Requirement
+  requirement: &17448260 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *10490200
+  version_requirements: *17448260
 - !ruby/object:Gem::Dependency
-  name: activerecord
-  requirement: &10489620 !ruby/object:Gem::Requirement
+  name: rspec
+  requirement: &17447840 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,7 +54,18 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *10489620
+  version_requirements: *17447840
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &17447420 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *17447420
 description: This 'acts_as' extension provides multi-table inheritance for rails models.
 email: hsn.zamani@gmail.com
 executables: []
@@ -62,18 +73,22 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .rspec
 - Gemfile
-- README.markdown
+- README.rdoc
 - Rakefile
 - acts_as_relation.gemspec
-- init.rb
-- lib/active_record/acts/as_relation.rb
-- lib/active_record/acts/as_relation_superclass_migration.rb
+- lib/active_record/acts_as_relation.rb
+- lib/active_record/acts_as_relation_superclass_migration.rb
 - lib/acts_as_relation.rb
 - lib/version.rb
-- test/acts_as_relation_test.rb
-- test/schema.rb
-- test/test_helper.rb
+- spec/acts_as_migration/acts_as_migratoin_spec.rb
+- spec/acts_as_migration/models.rb
+- spec/acts_as_migration/schema.rb
+- spec/acts_as_relation/acts_as_relation_spec.rb
+- spec/acts_as_relation/models.rb
+- spec/acts_as_relation/schema.rb
+- spec/spec_helper.rb
 homepage: http://github.com/hzamani/acts_as_relation
 licenses: []
 post_install_message: 
@@ -99,6 +114,10 @@ signing_key:
 specification_version: 3
 summary: Easy multi-table inheritance for rails
 test_files:
-- test/acts_as_relation_test.rb
-- test/schema.rb
-- test/test_helper.rb
+- spec/acts_as_migration/acts_as_migratoin_spec.rb
+- spec/acts_as_migration/models.rb
+- spec/acts_as_migration/schema.rb
+- spec/acts_as_relation/acts_as_relation_spec.rb
+- spec/acts_as_relation/models.rb
+- spec/acts_as_relation/schema.rb
+- spec/spec_helper.rb

data/README.markdown

@@ -1,85 +0,0 @@
-Acts As Realation
-=================
-
-Easy multi-table inheritance for rails.
-With `acts_as_relation` models inherit parent model:
-
- * columns
- * validations
- * methods
-
-Multi-table inheritance
------------------------
-
-Multi-table inheritance happens when each model in the hierarchy is a model all by itself
-that corresponds to its own database table and can be queried and created individually.
-The inheritance relationship introduces links between the child model and each of its
-parents (via an automatically-created `has_one` associations).
-
-Example
--------
-
-generate models
-
-    $ rails g model product name:string price:float
-    $ rails g model pen color:string
-
-Add next option to Product Migration:
-
-    create_table :products, :as_relation_superclass => true
-
-add some validations and instance methods
-
-    class Product < ActiveRecord::Base
-      validates_presence_of :name, :price
-
-      def hello
-        puts "Hello, My name is '#{name}', my price is $#{price}."
-      end
-    end
-
-product is superclass for all kind of products:
-
-    class Product < ActiveRecord::Base
-      acts_as_superclass
-    end
-
-pen inherits from product
-
-    class Pen < ActiveRecord::Base
-      acts_as :product
-    end
-
-to get some specific class(as example: specific product - Pen) from superclass can be used method specific_class:
-
-    Pen.create :name => 'Pen A', :color=> 'black', :price => 0.42
-    product = Product.first
-    product.specific_class # will be instance of Pen class
-
-to get name of association used between superclass and children can be used method acts_as_association_name:
-
-    Product.acts_as_association_name # 'Productable'
-
-after deleting specific object will be removed linked superobject:
-
-    Pen.first.destroy # delete as Pen row as linked Product row
-
-pen inherits products validations and columns
-
-    p = Pen.new
-    p.valid? => false
-    p.errors => {:name=>["can't be blank"], :price=>["can't be blank"]}
-
-pen inherits product methods
-
-    pen = Pen.new(:name=>"Red Pen", :color=>:red, :price=>0.99)
-    pen.hello => Hello, My name is 'Red Pen', my price is $0.99.
-
-we can make queries on both models
-
-    Product.where("price <= 1")
-    Pen.where("color = ?", color)
-
----
-
-Copyright (c) 2011 Hassan Zamani, released under the MIT license.

data/init.rb

@@ -1 +0,0 @@
-require 'acts_as_relation'

data/lib/active_record/acts/as_relation.rb

@@ -1,114 +0,0 @@
-module ActiveRecord
-  module Acts
-    module AsRelation
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-
-      module AccessMethods
-        def define_acts_as_accessors(attribs, model_name)
-          attribs.each do |attrib|
-            class_eval <<-EndClass
-              def #{attrib}
-                #{model_name}.#{attrib}
-              end
-
-              def #{attrib}=(value)
-                self.#{model_name}.#{attrib} = value
-              end
-
-              def #{attrib}?
-                self.#{model_name}.#{attrib}?
-              end
-            EndClass
-          end
-        end
-      end
-
-      module ClassMethods
-        def acts_as_association_name model_name = nil
-          suffix = 'able'
-          model_name = self.name unless model_name
-
-          name = model_name.to_s.demodulize.singularize
-          if name[-1].chr =~ /[^aeiou]/ || name[-2..-1] =~ /ge|ce/
-            name = name + suffix
-          elsif name[-7..-1] == 'ability'
-            name = name[0..-8] + suffix
-          else
-            name = name[0..-2] + suffix
-          end
-
-          name.underscore
-        end
-
-        def acts_as(model_name)
-          name = model_name.to_s.underscore.singularize
-          association_name = acts_as_association_name name
-
-          # Create A AsModel module
-          as_model = Module.new
-          Object.const_set("As#{name.camelcase}", as_model)
-
-          as_model.module_eval <<-EndModule
-            def self.included(base)
-              base.has_one :#{name}, :as => :#{association_name}, :autosave => true, :validate => false, :dependent => :destroy
-              base.validate :#{name}_must_be_valid
-              base.alias_method_chain :#{name}, :autobuild
-
-              base.extend ActiveRecord::Acts::AsRelation::AccessMethods
-              all_attributes = #{name.camelcase.constantize}.content_columns.map(&:name)
-              ignored_attributes = ["created_at", "updated_at", "#{association_name}_type"]
-              associations = #{name.camelcase.constantize}.reflect_on_all_associations(:belongs_to).map! { |assoc| assoc.name }
-              attributes_to_delegate = all_attributes - ignored_attributes + associations
-              base.define_acts_as_accessors(attributes_to_delegate, "#{name}")
-            end
-
-            def #{name}_with_autobuild
-              #{name}_without_autobuild || build_#{name}
-            end
-
-            def method_missing method, *arg, &block
-              #{name}.send method, *arg, &block
-            rescue NoMethodError
-              super
-            end
-
-            def respond_to?(method, include_private_methods = false)
-              super || self.#{name}.respond_to?(method, include_private_methods)
-            end
-
-            protected
-
-            def #{name}_must_be_valid
-              unless #{name}.valid?
-                #{name}.errors.each do |att, message|
-                  errors.add(att, message)
-                end
-              end
-            end
-          EndModule
-
-          class_eval do
-            include "As#{name.camelcase}".constantize
-          end
-        end
-
-        def acts_as_superclass
-          association_name = acts_as_association_name
-
-          class_eval <<-CLASS
-            belongs_to :#{association_name}, :polymorphic => true
-
-            def specific_class
-              self.#{association_name}
-            end
-          CLASS
-        end
-
-      end
-    end
-  end
-end
-
-ActiveRecord::Base.send :include, ActiveRecord::Acts::AsRelation

data/lib/active_record/acts/as_relation_superclass_migration.rb

@@ -1,27 +0,0 @@
-module ActiveRecord
-  module Acts
-    module AsRelationSuperclassMigration
-
-      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 = {})
-        association_name = ActiveRecord::Base.acts_as_association_name table_name
-
-        create_table_without_as_relation_superclass(table_name, options) do |td|
-          if options[:as_relation_superclass]
-            td.integer "#{association_name}_id"
-            td.string "#{association_name}_type"
-          end
-
-          yield td if block_given?
-        end
-      end
-    end
-  end
-end
-
-ActiveRecord::ConnectionAdapters::SchemaStatements.send :include, ActiveRecord::Acts::AsRelationSuperclassMigration

data/test/acts_as_relation_test.rb

@@ -1,121 +0,0 @@
-require 'test_helper'
-
-class ActsAsRelationTest < ActiveSupport::TestCase
-
-  test "acts as validation" do
-    pen = Pen.new
-    assert !pen.valid?
-    assert_equal pen.errors.keys, [:name, :price, :color]
-
-    pen.name = "TestPen"
-    assert !pen.valid?
-    assert_equal pen.errors.keys, [:price, :color]
-
-    pencil = Pencil.new
-    assert !pencil.valid?
-    assert_equal pencil.errors.keys, [:name, :price, :color]
-
-    pencil.color = "red"
-    assert !pencil.valid?
-    assert_equal pencil.errors.keys, [:name, :price]
-  end
-
-  test "save model" do
-    assert Pen.new(:name=>"FOO", :color=>"black", :price=>0.89).save
-    pen = Pen.new
-    pen.name = "BAR"
-    pen.color = "red"
-    pen.price = 0.99
-    assert pen.save
-  end
-
-  test "access methods" do
-    assert_nothing_raised(ActiveRecord::UnknownAttributeError) do
-      Pen.new(:name=>"RedPen", :price=>0.59, :color=>"red")
-      Pencil.new(:name=>"RedPencil", :price=>0.59, :color=>"red")
-    end
-  end
-
-  test "acts as method missing" do
-    assert_nothing_raised(NoMethodError) do
-      pen = Pen.new
-      pen.name_changed?
-      pen.price_changed?
-      pen.name_was
-
-      pencil = Pencil.new
-      pencil.name_changed?
-      pencil.price_changed?
-      pencil.name_was
-      pencil.color_was
-    end
-  end
-
-  test "acts as respond to?" do
-    pen = Pen.new
-    assert(pen.respond_to? :name_changed?)
-    assert(pen.respond_to? :name_was)
-    assert(pen.respond_to? :price_will_change!)
-
-    pencil = Pencil.new
-    assert(pencil.respond_to? :name_changed?)
-    assert(pencil.respond_to? :name_was)
-    assert(pencil.respond_to? :price_will_change!)
-    assert(pencil.respond_to? :color_changed?)
-    assert(pencil.respond_to? :color_was)
-  end
-
-  test "association reflections" do
-    store = Store.new
-    pen = Pen.new
-    pen.store = store
-
-    assert_equal store, pen.product.store
-    assert_equal store, pen.store
-  end
-
-  test "call parent methods" do
-    pen = Pen.new(:name=>"RedPen", :price=>0.59, :color=>"red")
-    assert_equal pen.parent_method, "RedPen - 0.59"
-  end
-
-  test "call unexisted method" do
-    assert_raise NoMethodError do
-      pen = Pen.new
-      pen.unexisted_method
-    end
-
-  end
-
-  test "acts as association name" do
-    assert_equal Pencil.acts_as_association_name, 'pencilable'
-    assert_equal Pencil.acts_as_association_name( Pen ), 'penable'
-  end
-
-  test "acts as superclass" do
-    pen = Pen.create(:name => "RedPen", :price => 0.59, :color => "red")
-    product = pen.product
-
-    assert_equal product.specific_class.class, Pen
-  end
-
-  test "destroy action" do
-    pen = Pen.create(:name => "RedPen", :price => 0.59, :color => "red")
-    product = pen.product
-
-    pen.destroy
-
-    assert_raise ActiveRecord::RecordNotFound do
-      Product.find product.id
-    end
-    assert_raise ActiveRecord::RecordNotFound do
-      Pen.find pen.id
-    end
-  end
-
-end
-
-#ActiveRecord::Base.connection.tables.each do |table|
-#  ActiveRecord::Base.connection.drop_table(table)
-#end
-

data/test/schema.rb

@@ -1,52 +0,0 @@
-require 'rubygems'
-require 'active_record'
-require 'acts_as_relation'
-
-ActiveRecord::Base.establish_connection(
-  :adapter => "sqlite3",
-  :database => ":memory:"
-)
-
-ActiveRecord::Schema.define(:version => 1) do
-
-  create_table :stores do |t|
-    t.string :store_name
-  end
-
-  create_table :products, :as_relation_superclass => true do |t|
-    t.string  :name
-    t.float   :price
-  end
-
-  create_table :pens, :as_relation_superclass => true do |t|
-    t.string  :color
-  end
-
-  create_table :pencils
-end
-
-class Store < ActiveRecord::Base
-  has_many :products
-end
-
-class Product < ActiveRecord::Base
-  acts_as_superclass
-
-  belongs_to :store
-  validates_presence_of :name, :price
-
-  def parent_method
-    "#{name} - #{price}"
-  end
-end
-
-class Pen < ActiveRecord::Base
-  acts_as_superclass
-
-  acts_as :product
-  validates_presence_of :color
-end
-
-class Pencil < ActiveRecord::Base
-  acts_as :pen
-end

data/test/test_helper.rb

@@ -1,4 +0,0 @@
-require 'rubygems'
-require 'test/unit'
-require 'active_support'
-require 'schema'