/acts_as_relation

Multi table Inheritance for rails

Primary LanguageRubyMIT LicenseMIT

<img src=“https://badge.fury.io/rb/acts_as_relation.svg” alt=“Gem Version” /> <img src=“https://travis-ci.org/hzamani/acts_as_relation.svg?branch=master” alt=“Build Status” /> <img src=“https://coveralls.io/repos/hzamani/acts_as_relation/badge.png?branch=master” alt=“Coverage Status” /> <img src=“https://codeclimate.com/github/hzamani/acts_as_relation.png” />

Deprication

This gem is depricated, please use {active_record-acts_as}(github.com/hzamani/active_record-acts_as) which is a full refactor of this one.

ActsAsRelation

This gem helps implement multiple-table-inheritance (MTI) methods to your ActiveRecord models. By default, ActiveRecord only supports single-table inheritance (STI). MTI gives you the benefits of STI but without having to place dozens of empty fields into a single table.

Take a traditional e-commerce application for example… A product has common attributes (name, price, image …), while each type of product has its own attributes… pen has color, book has author and publisher and so on.

Installation

For Rails 4 installation add the following line to your Gemfile

gem 'acts_as_relation', '~> 1.0'

and

$ bundle install

If you are using Rails 3 you must use ‘~> 0.1’ version specifier in Gemfile.

Usage

acts_as_relation uses a polymorphic has_one association to simulate multiple-table inheritance. For the e-commerce example you would 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

class Store < ActiveRecord::Base
  has_many :products
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 and acts_as_superclass in :as option:

change_table :products do |t|
  t.integer :producible_id
  t.string  :producible_type
end

class Product < ActiveRecord::Base
  acts_as_superclass :as => :producible
end

class Pen < ActiveRecord::Base
  acts_as :product, :as => :producible
end

class Book < 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

In has_many case you can use subclasses:

store = Store.create
store.products << Pen.create
store.products.first # => <Pen: ...>

Options

The acts_as relation support these options:

  • :as

  • :auto_join

  • :class_name

  • :dependent

when :auto_join option set to true (which is by default), every query on child will automatically joins the parent table. 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.

Note that support for :conditions and :include has been removed. In their place, you can use +where()+ and +includes()+:

acts_as :product, -> { where(color: "yellow") }
acts_as :person, -> { includes(:friends) }