active_record-acts_as 1.0.0.pre

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0e30b0cf3d5bebc22c5d3e9a63f81bced680e579
+  data.tar.gz: 11a3af36ca6331fe13cf84a962e6ba1728f9572a
+SHA512:
+  metadata.gz: 64f7cc31a9033eb4954981f24b6ae5edd5ac8c73ca05de836d2a01d62b5f8c59c41983caa91cf0e76b365a35e7d32ed96f5e02567ad125ef2d23be046ee0f496
+  data.tar.gz: 97c3f506fa35cfb4fa391b16f5ca3636db662b1f6963b8fc74d4f9e4fe02f8b50585f31142efe1c6f99b9aa7f06aafc222b8ebedc55f2e0b28f4f085cb21d82e

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,4 @@
+--color
+--warnings
+--format progress
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 2.1.1
+  - 2.0.0
+  - 1.9.3

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in active_record-acts_as.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Hassan Zamani
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,159 @@
+[![Build Status](https://travis-ci.org/hzamani/active_record-acts_as.svg)](https://travis-ci.org/hzamani/active_record-acts_as)
+[![Code Climate](https://codeclimate.com/github/hzamani/active_record-acts_as.png)](https://codeclimate.com/github/hzamani/active_record-acts_as)
+
+# ActiveRecord::ActsAs
+
+This is a refactor of [`acts_as_relation`](https://github.com/hzamani/acts_as_relation)
+
+Simulates multiple-table-inheritance (MTI) for 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:
+for example a `pen` has `color`, a `book` has `author` and `publisher` and so on.
+With multiple-table-inheritance you can have a `products` table with common columns and
+a seprate table for each product type, i.e. a `pens` table with `color` column.
+
+## Requirements
+
+`AciveRecord ~> 4`
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'active_record-acts_as'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install active_record-acts_as
+
+## Usage
+
+Back to example above, all you have to do is to mark `Product` as `actable` and all product type models as `acts_as :product`:
+
+```Ruby
+class Product < ActiveRecord::Base
+  actable
+
+  validates_presence_of :name, :price
+
+  def display
+    "#{name} $#{price}"
+  end
+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
+```
+
+and add foreign key and type columns to products table as in a polymorphic relation.
+You may prefere using a migration:
+
+```Ruby
+change_table :products do |t|
+  t.integer :actable_id
+  t.string  :actable_type
+end
+```
+
+or use shortcut `actable`
+
+```Ruby
+change_table :products do |t|
+  t.actable
+end
+```
+
+Now `Pen` and `Book` *acts as* `Product`, i.e. they inherit `Product`s *attributes*,
+*methods* and *validations*. Now you can do things like these:
+
+```Ruby
+Pen.create name: 'Penie!', price: 0.8, color: 'red'
+  # => #<Pen id: 1, color: "red">
+Pen.where price: 0.8
+  # => [#<Pen id: 1, color: "red">]
+Product.where price: 0.8
+  # => [#<Product id: 1, name: "Penie!", price: 0.8, store_id: nil, actable_id: 1, actable_type: "Pen">]
+pen = Pen.new
+pen.valid?
+  # => false
+pen.errors.full_messages
+  # => ["Name can't be blank", "Price can't be blank", "Color can't be blank"]
+Pen.first.display
+  # => "Penie! $0.8"
+```
+
+On the other hand you can always access a specific object from its parent by calling `specific` method on it:
+
+```Ruby
+Product.first.specific
+  # => #<Pen ...>
+```
+
+In +has_many+ case you can use subclasses:
+
+```Ruby
+store = Store.create
+store.products << Pen.create
+store.products.first
+  # => #<Product: ...>
+```
+
+You can give a name to all methods in `:as` option:
+
+```Ruby
+class Product < ActiveRecord::Base
+  actable as: producible
+end
+
+class Pen < ActiveRecord::Base
+  acts_as :product, as: :producible
+end
+
+change_table :products do |t|
+  t.actable as: :producible
+end
+```
+
+`acts_as` support all `has_one` options, where defauls are there:
+`as: :actable, dependent: :destroy, validate: false, autosave: true`
+
+Make sure you know what you are doing when ovrewriting `validate` or `autodave` options.
+
+You can pass scope to `acts_as` as in `has_one`:
+
+```Ruby
+acts_as :person, -> { includes(:friends) }
+```
+
+`actable` support all `belongs_to` options, where defaults are these:
+`polymorphic: true, dependent: :delete, autosave: true`
+
+Make sure you know what you are doing when ovrewriting `polymorphic` option.
+
+
+## Contributing
+
+1. Fork it ( https://github.com/hzamani/active_record-acts_as/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Test changes don't breake anything (`rspec`)
+4. Add specs for your new feature
+5. Commit your changes (`git commit -am 'Add some feature'`)
+6. Push to the branch (`git push origin my-new-feature`)
+7. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+task default: :spec
+
+desc 'Run specs'
+RSpec::Core::RakeTask.new

data/active_record-acts_as.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'active_record/acts_as/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "active_record-acts_as"
+  spec.version       = ActiveRecord::ActsAs::VERSION
+  spec.authors       = ["Hassan Zamani"]
+  spec.email         = ["hsn.zamani@gmail.com"]
+  spec.summary       = %q{Simulate multi-table inheritance for activerecord models}
+  spec.description   = %q{Simulate multi-table inheritance for activerecord models using a plymorphic association}
+  spec.homepage      = "http://github.com/hzamani/active_record-acts_as"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = ">= 1.9"
+
+  spec.add_development_dependency "sqlite3", "~> 1.3"
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rspec", "~> 3"
+  spec.add_development_dependency "rake", "~> 10"
+
+  spec.add_dependency "activesupport", "~> 4"
+  spec.add_dependency "activerecord", "~> 4"
+end

data/lib/active_record/acts_as/instance_methods.rb

@@ -0,0 +1,56 @@
+
+module ActiveRecord
+  module ActsAs
+    module InstanceMethods
+      def acting_as?(other = nil)
+        self.class.acting_as? other
+      end
+
+      def is_a?(klass)
+        super || acting_as?(klass)
+      end
+
+      def actable_must_be_valid
+        unless acting_as.valid?
+          acting_as.errors.each do |att, message|
+            errors.add(att, message)
+          end
+        end
+      end
+      protected :actable_must_be_valid
+
+      def read_attribute(attr_name, *args, &block)
+        if attribute_method?(attr_name)
+          super
+        else
+          acting_as.read_attribute(attr_name, *args, &block)
+        end
+      end
+
+      def write_attribute(attr_name, value, *args, &block)
+        if attribute_method?(attr_name)
+          super
+        else
+          acting_as.send(:write_attribute, attr_name, value, *args, &block)
+        end
+      end
+      private :write_attribute
+
+      def attributes
+        acting_as.attributes.except(acting_as_reflection.type, acting_as_reflection.foreign_key).merge(super)
+      end
+
+      def respond_to?(name, include_private = false)
+        super || acting_as.respond_to?(name)
+      end
+
+      def method_missing(method, *args, &block)
+        if acting_as.respond_to?(method)
+          acting_as.send(method, *args, &block)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/active_record/acts_as/migration.rb

@@ -0,0 +1,24 @@
+
+module ActiveRecord
+  module ActsAs
+    module Migration
+      module TableDefinition
+        def actable(options = {})
+          name = options.delete(:as) || :actable
+          options[:polymorphic] = true
+          references(name, options)
+        end
+      end
+
+      module Table
+        include TableDefinition
+
+        def remove_actable(options = {})
+          name = options.delete(:as) || :actable
+          options[:polymorphic] = true
+          @base.remove_reference(@table_name, name, options)
+        end
+      end
+    end
+  end
+end

data/lib/active_record/acts_as/querying.rb

@@ -0,0 +1,23 @@
+
+module ActiveRecord
+  module ActsAs
+    module Querying
+      def where(opts = :chain, *rest)
+        if opts.is_a? Hash
+          opts, acts_as_opts = opts.partition { |k,v| attribute_names.include?(k.to_s) }
+          opts, acts_as_opts = Hash[opts], Hash[acts_as_opts]
+          opts[acting_as_model.table_name] = acts_as_opts
+        end
+        super(opts, *rest)
+      end
+
+      def find_by(*args)
+        where(*args).take
+      end
+
+      def find_by!(*args)
+        where(*args).take!
+      end
+    end
+  end
+end

data/lib/active_record/acts_as/relation.rb

@@ -0,0 +1,47 @@
+
+module ActiveRecord
+  module ActsAs
+    module Relation
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def acts_as(name, scope = nil, options = {})
+          options, scope = scope, nil if Hash === scope
+          options = {as: :actable, dependent: :destroy, validate: false, autosave: true}.merge options
+
+          reflections = has_one name, scope, options
+          default_scope -> { eager_load(name) }
+          validate :actable_must_be_valid
+
+          cattr_reader(:acting_as_reflection) { reflections[name.to_sym] }
+          cattr_reader(:acting_as_name) { name.to_s }
+          cattr_reader(:acting_as_model) { name.to_s.camelize.constantize }
+          class_eval "def acting_as() #{name} || build_#{name} end"
+
+          include ActsAs::InstanceMethods
+          extend  ActsAs::Querying
+        end
+
+        def acting_as?(other = nil)
+          if respond_to? :acting_as_name
+            other.nil? || acting_as_name == other.to_s.underscore
+          else
+            false
+          end
+        end
+
+        def is_a?(klass)
+          super || acting_as?(klass)
+        end
+
+        def actable(options = {})
+          name = options.delete(:as) || :actable
+
+          belongs_to name, {polymorphic: true, dependent: :delete, autosave: true}.merge(options)
+
+          alias_method :specific, name
+        end
+      end
+    end
+  end
+end

data/lib/active_record/acts_as/version.rb

@@ -0,0 +1,6 @@
+
+module ActiveRecord
+  module ActsAs
+    VERSION = "1.0.0.pre"
+  end
+end

data/lib/active_record/acts_as.rb

@@ -0,0 +1,24 @@
+require 'active_record/acts_as/version'
+require 'active_record/acts_as/relation'
+require 'active_record/acts_as/migration'
+require 'active_record/acts_as/instance_methods'
+require 'active_record/acts_as/querying'
+
+module ActiveRecord
+  class Base
+    include ActsAs::Relation
+  end
+
+  module ConnectionAdapters
+    class TableDefinition
+      include ActsAs::Migration::TableDefinition
+    end
+  end
+
+  module ConnectionAdapters
+    class Table
+      include ActsAs::Migration::Table
+    end
+  end
+end
+

data/spec/actable_spec.rb

@@ -0,0 +1,37 @@
+require 'models'
+
+RSpec.describe "ActiveRecord::Base subclass with #actable" do
+  subject { Product }
+
+  let(:pen_attributes) { {name: 'pen', price: 0.8, color: 'red'} }
+  let(:pen) { Pen.new pen_attributes }
+
+  it "has a polymorphic belongs_to :actable relation" do
+    association = subject.reflect_on_all_associations.find { |r| r.name == :actable }
+    expect(association).to_not be_nil
+    expect(association.macro).to eq(:belongs_to)
+    expect(association).to be_polymorphic
+  end
+
+  describe ".specific" do
+    it "return specific submodel" do
+      pen.save
+      expect(Product.find(pen.acting_as.id).specific).to eq(pen)
+    end
+  end
+
+  it "deletes specific subclass on destroy" do
+    pen.save
+    pen.product.destroy
+    expect { pen.reload }.to raise_error(ActiveRecord::RecordNotFound)
+  end
+
+  it "saves submodel on save" do
+    pen.save
+    product = pen.acting_as
+    product.specific.color = 'blue'
+    product.save
+    pen.reload
+    expect(pen.color).to eq('blue')
+  end
+end

data/spec/active_record_spec.rb

@@ -0,0 +1,21 @@
+require 'active_record'
+require 'active_record/acts_as'
+
+class Model < ActiveRecord::Base
+end
+
+RSpec.describe ActiveRecord, "Model" do
+  subject { Model }
+
+  it { is_expected.to respond_to(:acts_as) }
+  it { is_expected.to respond_to(:actable) }
+  it { is_expected.to respond_to(:acting_as?) }
+
+  describe "#acting_as?" do
+    it "returns false with any arg" do
+      expect(subject.acting_as?).to be false
+      expect(subject.acting_as?(String)).to be false
+      expect(subject.acting_as?(:product)).to be false
+    end
+  end
+end

data/spec/acts_as_spec.rb

@@ -0,0 +1,162 @@
+require 'models'
+
+RSpec.describe "ActiveRecord::Base model with #acts_as called" do
+  subject { Pen }
+
+  let(:pen_attributes) { {name: 'pen', price: 0.8, color: 'red'} }
+  let(:pen) { Pen.new pen_attributes }
+  let(:store) { Store.new name: 'biggerman' }
+
+  it "has a has_one relation" do
+    association = subject.reflect_on_all_associations.find { |r| r.name == :product }
+    expect(association).to_not be_nil
+    expect(association.macro).to eq(:has_one)
+    expect(association.options).to have_key(:as)
+  end
+
+  describe "#acting_as?" do
+    it "returns true for supermodel class and name" do
+      expect(Pen.acting_as? :product).to be true
+      expect(Pen.acting_as? Product).to be true
+    end
+
+    it "returns false for anything other than supermodel" do
+      expect(Pen.acting_as? :model).to be false
+      expect(Pen.acting_as? String).to be false
+    end
+  end
+
+  describe ".acting_as?" do
+    it "returns true for supermodel class and name" do
+      expect(pen.acting_as? :product).to be true
+      expect(pen.acting_as? Product).to be true
+    end
+
+    it "returns false for anything other than supermodel" do
+      expect(pen.acting_as? :model).to be false
+      expect(pen.acting_as? String).to be false
+    end
+  end
+
+  describe "#is_a?" do
+    it "responds true when supermodel passed to" do
+      expect(Pen.is_a? Product).to be true
+      expect(Pen.is_a? Object).to be true
+      expect(Pen.is_a? String).to be false
+    end
+  end
+
+  describe ".is_a?" do
+    it "responds true when supermodel passed to" do
+      expect(pen.is_a? Product).to be true
+      expect(pen.is_a? Object).to be true
+      expect(pen.is_a? String).to be false
+    end
+  end
+
+  describe "#acting_as_name" do
+    it "return acts_as model name" do
+      expect(pen.acting_as_name).to eq('product')
+    end
+  end
+
+  describe "#acting_as" do
+    it "returns autobuilded acts_as model" do
+      expect(pen.acting_as).to_not be_nil
+      expect(pen.acting_as).to be_instance_of(Product)
+    end
+  end
+
+  it "have supermodel attributes accessible on creation" do
+    expect{Pen.create(pen_attributes)}.to_not raise_error
+  end
+
+  context "instance" do
+    it "responds to supermodel methods" do
+      %w(name name= name? name_change name_changed? name_was name_will_change! price color).each do |name|
+        expect(pen).to respond_to(name)
+      end
+      expect(pen.present).to eq("pen - $0.8")
+    end
+
+    it "saves supermodel attributes on save" do
+      pen.save
+      pen.reload
+      expect(pen.name).to eq('pen')
+      expect(pen.price).to eq(0.8)
+      expect(pen.color).to eq('red')
+    end
+
+    it "raises NoMethodEror on unexisting method call" do
+      expect { pen.unexisted_method }.to raise_error(NoMethodError)
+    end
+
+    it "destroies Supermodel on destroy" do
+      pen.save
+      product_id = pen.product.id
+      pen.destroy
+      expect { Product.find(product_id) }.to raise_error(ActiveRecord::RecordNotFound)
+    end
+
+    it "validates supermodel attribures upon validation" do
+      p = Pen.new
+      expect(p).to be_invalid
+      expect(p.errors.keys).to include(:name, :price, :color)
+      p.name = 'testing'
+      expect(p).to be_invalid
+      p.color = 'red'
+      expect(p).to be_invalid
+      p.price = 0.8
+      expect(p).to be_valid
+    end
+
+    it "can set assosications defined in supermodel" do
+      store.save
+      pen.store = store
+      pen.save
+      pen.reload
+      expect(pen.store).to eq(store)
+      expect(pen.product.store).to eq(store)
+    end
+
+    it "should be appendable in an has_many relation using << operator" do
+      store.save
+      store.products << pen
+      expect(pen.store).to eq(store)
+    end
+
+    it "includes supermodel attributes in .to_json responce" do
+      expect(pen.to_json).to eq('{"id":null,"name":"pen","price":0.8,"store_id":null,"color":"red"}')
+    end
+  end
+
+  context "Querying" do
+    before(:each) { clear_database }
+
+    it ".where works with supermodel attributes" do
+      red_pen = Pen.create(name: 'red pen', price: 0.8, color: 'red')
+      blue_pen = Pen.create(name: 'blue pen', price: 0.8, color: 'blue')
+      black_pen = Pen.create(name: 'black pen', price: 0.9, color: 'black')
+
+      expect{Pen.where(price: 0.8)}.to_not raise_error
+      expect(Pen.where(price: 0.8)).to include(red_pen, blue_pen)
+      expect(Pen.where(price: 0.8)).to_not include(black_pen)
+    end
+
+    it "find_by works with supermodel attributes" do
+      red_pen = Pen.create(name: 'red pen', price: 0.8, color: 'red')
+      blue_pen = Pen.create(name: 'blue pen', price: 0.8, color: 'blue')
+      black_pen = Pen.create(name: 'black pen', price: 0.9, color: 'black')
+
+      expect(Pen.find_by(name: 'red pen')).to eq(red_pen)
+      expect(Pen.find_by(name: 'blue pen')).to eq(blue_pen)
+      expect(Pen.find_by(name: 'black pen')).to eq(black_pen)
+    end
+
+    it "includes supermodel attributes in Relation.scope_for_create" do
+      relation = Pen.where(name: 'new name')
+      expect(relation.scope_for_create.keys).to include(:name)
+      expect(relation.scope_for_create[:name]).to eq('new name')
+    end
+  end
+end

data/spec/database_helper.rb

@@ -0,0 +1,26 @@
+require 'active_record'
+
+def connect_to_databse
+  ActiveRecord::Base.establish_connection adapter: 'sqlite3', database: ':memory:'
+end
+
+def clear_database
+  ActiveRecord::Base.descendants.each do |model|
+    model.delete_all if model.table_exists?
+  end
+end
+
+def reset_database
+  ActiveRecord::Base.descendants.map(&:reset_column_information)
+  ActiveRecord::Base.connection.disconnect!
+  connect_to_databse
+end
+
+def initialize_database(&block)
+  reset_database
+  ActiveRecord::Schema.define(&block)
+end
+
+I18n.enforce_available_locales = false
+ActiveRecord::Migration.verbose = false
+connect_to_databse

data/spec/migrations_spec.rb

@@ -0,0 +1,25 @@
+require 'database_helper'
+require 'active_record/acts_as'
+
+
+class Product < ActiveRecord::Base
+end
+
+
+RSpec.describe ".actable" do
+  context "in .create_table block" do
+    context "with :as options" do
+      it "creates plymorphic reference columns with given name" do
+        initialize_database { create_table(:products) { |t| t.actable(as: :produceable) } }
+        expect(Product.column_names).to include('produceable_id', 'produceable_type')
+      end
+    end
+
+    context "with no args" do
+      it "creates plymorphic reference columns" do
+        initialize_database { create_table(:products) { |t| t.actable } }
+        expect(Product.column_names).to include('actable_id', 'actable_type')
+      end
+    end
+  end
+end

data/spec/models.rb

@@ -0,0 +1,39 @@
+require 'database_helper'
+require 'active_record/acts_as'
+
+class Product < ActiveRecord::Base
+  actable
+  belongs_to :store
+  validates_presence_of :name, :price
+
+  def present
+    "#{name} - $#{price}"
+  end
+end
+
+class Pen < ActiveRecord::Base
+  acts_as :product
+
+  validates_presence_of :color
+end
+
+class Store < ActiveRecord::Base
+  has_many :products
+end
+
+initialize_database do
+  create_table :pens do |t|
+    t.string :color
+  end
+
+  create_table :products do |t|
+    t.string :name
+    t.float :price
+    t.integer :store_id
+    t.actable
+  end
+
+  create_table :stores do |t|
+    t.string :name
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+
+RSpec.configure do |config|
+  config.disable_monkey_patching!
+end

metadata

@@ -0,0 +1,157 @@
+--- !ruby/object:Gem::Specification
+name: active_record-acts_as
+version: !ruby/object:Gem::Version
+  version: 1.0.0.pre
+platform: ruby
+authors:
+- Hassan Zamani
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+description: Simulate multi-table inheritance for activerecord models using a plymorphic
+  association
+email:
+- hsn.zamani@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- active_record-acts_as.gemspec
+- lib/active_record/acts_as.rb
+- lib/active_record/acts_as/instance_methods.rb
+- lib/active_record/acts_as/migration.rb
+- lib/active_record/acts_as/querying.rb
+- lib/active_record/acts_as/relation.rb
+- lib/active_record/acts_as/version.rb
+- spec/actable_spec.rb
+- spec/active_record_spec.rb
+- spec/acts_as_spec.rb
+- spec/database_helper.rb
+- spec/migrations_spec.rb
+- spec/models.rb
+- spec/spec_helper.rb
+homepage: http://github.com/hzamani/active_record-acts_as
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '1.9'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Simulate multi-table inheritance for activerecord models
+test_files:
+- spec/actable_spec.rb
+- spec/active_record_spec.rb
+- spec/acts_as_spec.rb
+- spec/database_helper.rb
+- spec/migrations_spec.rb
+- spec/models.rb
+- spec/spec_helper.rb