acts_as_relatable 0.0.1

data/Gemfile

@@ -0,0 +1,7 @@
+source "http://rubygems.org"
+
+gem "sqlite3"
+gem "rails", "~> 3.0.9"
+gem "shoulda", "~> 2.11.0"
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Malamitsas
+
+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.rdoc

@@ -0,0 +1,85 @@
+= acts_as_relatable
+
+== Installation
+
+(This gem has only been tested with Rails 3 for the moment, compatibility with Rails 3.1 is coming soon)
+
+Gem installation :
+
+  gem install acts_as_relatable
+
+Or you can put it in your Gemfile :
+
+  gem "acts_as_relatable"
+
+and then run :
+
+  bundle install
+
+You'll then need to run the migration generator for the Relationship model :
+
+  r generate acts_as_relatable:migration
+
+Followed by :
+
+  rake db:migrate
+
+== Usage
+
+    class Recipe < ActiveRecord::Base
+      acts_as_relatable :product
+    end
+
+    class Product < ActiveRecord::Base
+      acts_as_relatable :recipe
+    end
+
+    @bread = Product.create(:name => "Bread")
+    @butter = Product.create(:name => "Butter")
+    @pancake = Recipe.create(:name => "Pancakes")
+
+    #Creating relationships
+    @butter.relates_to!(@pancake)   # #<ActsAsRelatable::Relationship id: 2, relator_id: 1, relator_type: "Recipe", related_id: 2, related_type: "Product">
+    @bread.relates_to!(@butter)     # #<ActsAsRelatable::Relationship id: 4, relator_id: 2, relator_type: "Product", related_id: 1, related_type: "Product">
+
+    #By default, relationships are both-sided, it means that on the first line above, @butter is related to @pancake, but @pancake is also related to @butter.
+    #If you don't want/need this behaviour, you can pass false as a second argument to the relates_to! instance method :
+
+    @butter.relates_to!(@pancake, false)
+
+
+    #Fetching relationships
+    @butter.related_recipes         # [#<Recipe id: 1, name: "Pancakes">]
+    @butter.related_products        # [#<Product id: 1, name: "Bread"]
+
+    @butter.relateds                # {:recipes=>[#<Recipe id: 1, name: "Pancakes">], :products=>[#<Product id: 1, name: "Bread">]}
+
+    #Testing relationships
+    @butter.related_to? @bread      # true
+    @bread.related_to? @pancake     # false
+
+    #Destroying relationships (This instance method destroys both relationships if it's a both-sided one)
+    @butter.destroy_relation_with @pancake
+
+
+== Contributing to acts_as_relatable
+
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== TODOS
+
+* Rails 3.1 compatibility
+* Add a make_between method in Relationship model
+* Improve README
+
+== Copyright
+
+Copyright (c) 2011 Malamitsas. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,11 @@
+# encoding: utf-8
+require 'rubygems'
+require 'rake'
+require 'rspec/core/rake_task'
+
+desc "Run RSpec"
+RSpec::Core::RakeTask.new do |t|
+  t.verbose = false
+end
+
+task :default => :spec

data/init.rb

@@ -0,0 +1 @@
+require "acts_as_relatable"

data/lib/acts_as_relatable.rb

@@ -0,0 +1,11 @@
+require "active_record"
+require "active_record/version"
+
+require "acts_as_relatable/relationship"
+require "acts_as_relatable/relatable"
+
+if defined?(ActiveRecord::Base)
+  ActiveRecord::Base.send :include, ActsAsRelatable::Relatable
+end
+
+require 'rails/generators'

data/lib/acts_as_relatable/relatable.rb

@@ -0,0 +1,101 @@
+module ActsAsRelatable
+
+
+  module Relatable
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+
+      def acts_as_relatable(*relatable_models)
+        # Create polymorphic associations
+        class_attribute :relatable_types
+
+        self.relatable_types = relatable_models.to_a.flatten.compact.map(&:to_sym) << self.to_s.underscore
+
+        has_many :relationships, :as => :relator, :order => "created_at desc", :class_name => "ActsAsRelatable::Relationship", :dependent => :destroy
+        has_many :incoming_relationships, :as => :related, :class_name => "ActsAsRelatable::Relationship", :dependent => :destroy
+
+        relatable_types.each do |rel|
+
+          has_many "related_#{rel.to_s.pluralize}",
+                                    :through => :relationships,
+                                    :source => "related_#{rel.to_s}",
+                                    :class_name => rel.to_s.classify,
+                                    :conditions => { 'relationships.related_type' => rel.to_s.classify }
+
+          has_many "relator_#{rel.to_s.pluralize}",
+                                  :through => :incoming_relationships,
+                                  :source => "relator_#{rel.to_s}",
+                                  :class_name => rel.to_s.classify,
+                                  :conditions => {'relationships.relator_type' => rel.to_s.classify}
+
+          ActsAsRelatable::Relationship.belongs_to "relator_#{rel.to_s}".to_sym, :class_name => rel.to_s.classify, :foreign_key => :relator_id
+          ActsAsRelatable::Relationship.belongs_to "related_#{rel.to_s}".to_sym, :class_name => rel.to_s.classify, :foreign_key => :related_id
+
+
+        end
+
+        include ActsAsRelatable::Relatable::InstanceMethods
+        extend ActsAsRelatable::Relatable::SingletonMethods
+      end
+    end
+
+    module SingletonMethods; end
+
+    module InstanceMethods
+
+      # This method creates relation between 2 objects.
+      # Returns the relationships in an array or false if the relation already exists.
+      # By default a bothsided relationship is created but this can be overiden by seting bothsided to false.
+      #
+      # Example :
+      #   user = User.find 1
+      #   place = Place.find 1
+      #   user.relate_to! place
+      def relates_to!(some_object, bothsided=true)
+        return false if (self.related_to?(some_object) || self.eql?(some_object))
+
+        ActsAsRelatable::Relationship.unscoped.create(:related => some_object, :relator => self)
+        ActsAsRelatable::Relationship.unscoped.create(:related => self, :relator => some_object) if bothsided == true
+      end
+
+      # This method returns true if self is already related with some_object
+      def related_to? some_object
+        !!relation(some_object)
+      end
+
+      # This method returns the relationship between self and another_object, or nil
+      def relation some_object
+        ActsAsRelatable::Relationship.unscoped.where(:relator_id => self.id,
+                                    :related_id => some_object.id,
+                                    :relator_type => self.class.base_class.to_s,
+                                    :related_type => some_object.class.base_class.to_s).first
+      end
+
+      # This method returns relatable objects from a given Array of models
+      # Exemple : @category.relateds(:classes => ['Place', 'Event']) will return
+      # {"Place" => [related_place1, related_place2], "Event" => [related_event1, related_event2]}
+      def relateds(options = {})
+         relateds = {}
+         classes = options.try(:[], :classes) ? options[:classes] : relatable_types
+         classes.each do |c|
+           pluralized_rel = c.to_s.underscore.pluralize
+           relations = self.send("related_#{pluralized_rel}").limit(options[:limit] || 10)
+           relateds = relateds.merge(pluralized_rel.to_sym => relations) if relations.any?
+         end
+         relateds
+      end
+
+      # This method destroy the relationship between self (as a relator object) and some_object (as a related object).
+      def destroy_relation_with some_object
+        relationships_to_destroy = [relation(some_object), some_object.relation(self)]
+        relationships_to_destroy.each { |r| r.destroy if r }
+        relationships.reload
+      end
+
+    end
+
+  end
+end

data/lib/acts_as_relatable/relationship.rb

@@ -0,0 +1,11 @@
+module ActsAsRelatable
+  class Relationship < ::ActiveRecord::Base
+    belongs_to :relator, :polymorphic => true, :foreign_key => :relator_id, :touch => true
+    belongs_to :related, :polymorphic => true, :foreign_key => :related_id, :touch => true
+
+    validates :relator_id, :presence => true, :uniqueness => {:scope => [:relator_type, :related_id, :related_type]}
+    validates :relator_type, :presence => true
+    validates :related_id, :presence => true
+    validates :related_type, :presence => true
+  end
+end

data/lib/generators/acts_as_relatable/USAGE

@@ -0,0 +1,3 @@
+Description:
+  The acts_as_relatable:install generator creates a configuration file in config/initializer
+  directory. It creates a migration file for the Relationship model as well.

data/lib/generators/acts_as_relatable/config_generator.rb

@@ -0,0 +1,11 @@
+module ActsAsRelatable
+  module Generators
+    class ConfigGenerator < Rails::Generators::Base
+      source_root File.expand_path('../templates', __FILE__)
+
+      def generate_ability
+        copy_file "acts_as_relatable.rb", "config/initializers/acts_as_relatable.rb"
+      end
+    end
+  end
+end

data/lib/generators/acts_as_relatable/migration_generator.rb

@@ -0,0 +1,22 @@
+module ActsAsRelatable
+  class MigrationGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+
+    def self.source_root
+      @source_root ||= File.expand_path('../templates', __FILE__)
+    end
+
+    def self.next_migration_number(dirname)
+      if ActiveRecord::Base.timestamped_migrations
+        Time.now.utc.strftime("%Y%m%d%H%M%S")
+      else
+        "%.3d" % (current_migration_number(dirname) + 1)
+      end
+    end
+
+    def create_migration_file
+      migration_template 'migration.rb', 'db/migrate/acts_as_relatable_migration.rb'
+    end
+
+  end
+end

data/lib/generators/acts_as_relatable/templates/acts_as_relatable.rb

@@ -0,0 +1 @@
+# This config file is useless for the moment but should be useful in a near future

data/lib/generators/acts_as_relatable/templates/migration.rb

@@ -0,0 +1,28 @@
+class ActsAsRelatableMigration < ActiveRecord::Migration
+  def self.up
+    # Relationship table
+    create_table :relationships do |t|
+      t.integer  :relator_id
+      t.string   :relator_type
+      t.integer  :related_id
+      t.string   :related_type
+      t.timestamps
+    end
+
+    # Relationship indexes
+    add_index :relationships, ["related_id"], :name => "index_relationships_on_related_id"
+    add_index :relationships, ["related_type", "related_id"], :name => "poly_relationships_related"
+    add_index :relationships, ["relator_id"], :name => "index_relationships_on_relator_id"
+    add_index :relationships, ["relator_type", "relator_id"], :name => "poly_relationships_relator"
+  end
+
+
+  def self.down
+    drop_table :relationships
+
+    remove_index :relationships, :name => "index_relationships_on_related_id"
+    remove_index :relationships, :name => "poly_relationships_related"
+    remove_index :relationships, :name => "index_relationships_on_relator_id"
+    remove_index :relationships, :name => "poly_relationships_relator"
+  end
+end

data/spec/acts_as_relatable/generators/config_generator_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+# describe ActsAsRelatable::Generators::ConfigGenerator do
+#
+#   context "generates config file" do
+#
+#     before { setup }
+#     after { teardown }
+#
+#     it "copy it in config/initializers" do
+#       Rails::Generators::Scripts::Generate.new.run([""], :destination => fake_rails_root)
+#       new_file = (file_list - @original_files).first
+#       assert_equal "definition.txt", File.basename(new_file)
+#     end
+#
+#     def setup
+#       FileUtils.mkdir_p(fake_rails_root)
+#       @original_files = file_list
+#     end
+#
+#     def teardown
+#       FileUtils.rm_r(fake_rails_root)
+#     end
+#
+#     def fake_rails_root
+#       File.join(File.dirname(__FILE__), 'rails_root')
+#     end
+#
+#     def file_list
+#       Dir.glob(File.join(fake_rails_root, "*"))
+#     end
+#
+#   end
+#
+# end

data/spec/acts_as_relatable/relatable_spec.rb

@@ -0,0 +1,146 @@
+require "spec_helper"
+
+describe ActsAsRelatable::Relatable do
+
+  before { @tag = Tag.create(:name => "tag1") }
+
+  context :associations do
+    context :without_content do
+      subject { @tag.relationships }
+      it { should be_empty }
+
+      subject { @tag.incoming_relationships }
+      it { should be_empty }
+
+      subject { @tag.related_products }
+      it { should be_empty }
+
+      subject { @tag.related_shops }
+      it { should be_empty}
+    end
+  end
+
+  context :methods do
+    before {
+      @products = {
+        :product1 => Product.create(:name => 'product1'),
+        :product2 => Product.create(:name => 'product2'),
+        :product3 => Product.create(:name => 'product3')
+      }
+      @shops = {
+        :shop1 => Shop.create(:name => 'shop1'),
+        :shop2 => Shop.create(:name => 'shop2'),
+        :shop3 => Shop.create(:name => 'shop3')
+      }
+    }
+
+    context :relates_to! do
+
+      context :both_sided do
+        before { @products[:product1].relates_to!(@shops[:shop3]) }
+
+        it "relates the first side" do
+          @products[:product1].related_to?(@shops[:shop3]).should be_true
+        end
+
+        it "relates the other side" do
+          @shops[:shop3].related_to?(@products[:product1]).should be_true
+        end
+      end
+
+      context :one_sided do
+        before { @products[:product1].relates_to!(@shops[:shop3], :both_sided => false) }
+
+        it "relates the first side" do
+          @products[:product1].related_to?(@shops[:shop3]).should be_true
+        end
+
+        it "doesn't relate the other side" do
+          @shops[:shop3].related_to?(@products[:product1]).should be_false
+        end
+      end
+
+    end
+
+    context :related_to? do
+      context :returns do
+        before { @products[:product1].relates_to!(@shops[:shop1]) }
+
+        it "true if self is related to the passed object" do
+          @products[:product1].related_to?(@shops[:shop1]).should be_true
+        end
+
+        it "false if self is not related to the passed object" do
+          @products[:product1].related_to?(@shops[:shop2]).should be_false
+        end
+      end
+    end
+
+    context :relateds do
+      context :returns do
+        before {
+          @products[:product1].relates_to!(@products[:product3])
+          @products[:product1].relates_to!(@shops[:shop1])
+        }
+
+        it "elems of all classes if there is no class specified" do
+          @products[:product1].relateds.should == {:shops => [@shops[:shop1]], :products => [@products[:product3]]}
+        end
+
+        it "objects from the specified classes only" do
+          @products[:product1].relateds(:classes => ['Product']).should == {:products => [@products[:product3]]}
+        end
+
+        it "same results as related_products" do
+          @products[:product1].relateds(:classes => ['Product'])[:products].should.eql?(@products[:product1].related_products)
+        end
+
+        it "nil if the specified class doesn't have content" do
+          @products[:product1].relateds(:classes => ['Tag']).should == {}
+        end
+      end
+    end
+
+    context :relation do
+      before { @products[:product1].relates_to!(@shops[:shop1]) }
+
+      context :returns do
+        it "an instance of ActsAsRelatable::Relationship" do
+          @products[:product1].relation(@shops[:shop1]).should be_an_instance_of ActsAsRelatable::Relationship
+        end
+
+        it "the related" do
+          @products[:product1].relation(@shops[:shop1]).related.should == @shops[:shop1]
+        end
+
+        it "the relator" do
+          @products[:product1].relation(@shops[:shop1]).relator.should == @products[:product1]
+        end
+
+        it "nil if there is no relation between self and the passed object" do
+          @products[:product1].relation(@shops[:shop3]).should be_nil
+        end
+      end
+    end
+
+    context :destroy_relation_with do
+      before {
+        @products[:product1].relates_to!(@products[:product3])
+        @products[:product1].relates_to!(@shops[:shop1])
+      }
+
+      context :after_destroy do
+        before { @products[:product1].destroy_relation_with(@products[:product3]) }
+
+        it "destroys the relationship containing the specified object" do
+          @products[:product1].related_to?(@products[:product3]).should be_false
+        end
+
+        it "keeps the other relationship" do
+          @products[:product1].related_to?(@shops[:shop1]).should be_true
+        end
+      end
+    end
+  end
+
+end

data/spec/acts_as_relatable/relationship_spec.rb

@@ -0,0 +1,31 @@
+require "spec_helper"
+
+describe ActsAsRelatable::Relationship do
+
+  it { should validate_presence_of :relator_id }
+  it { should validate_presence_of :relator_type }
+  it { should validate_presence_of :related_id }
+  it { should validate_presence_of :related_type }
+
+  context :associations do
+    before {
+      @product = Product.create(:name => 'product1')
+      @shop = Shop.create(:name => 'shop1')
+
+      @product.relates_to! @shop
+    }
+
+    context :relator do
+      it "returns the object that made the relation" do
+        @product.relationships.first.relator.should == @product
+      end
+    end
+
+    context :related do
+      it "returns the object that has been related" do
+        @product.relationships.first.related.should == @shop
+      end
+    end
+  end
+
+end

data/spec/database.yml

@@ -0,0 +1,19 @@
+sqlite3:
+  adapter: sqlite3
+  database: acts_as_relatable.sqlite3
+
+mysql:
+  adapter: mysql2
+  hostname: localhost
+  username: root
+  password:
+  database: acts_as_relatable
+  charset: utf8
+
+postgresql:
+  adapter: postgresql
+  hostname: localhost
+  username: postgres
+  password:
+  database: acts_as_relatable
+  encoding: utf8

data/spec/database.yml.sample

@@ -0,0 +1,19 @@
+sqlite3:
+  adapter: sqlite3
+  database: acts_as_relatable.sqlite3
+
+mysql:
+  adapter: mysql2
+  hostname: localhost
+  username: root
+  password:
+  database: acts_as_relatable
+  charset: utf8
+
+postgresql:
+  adapter: postgresql
+  hostname: localhost
+  username: postgres
+  password:
+  database: acts_as_relatable
+  encoding: utf8

data/spec/models.rb

@@ -0,0 +1,11 @@
+class Product < ActiveRecord::Base
+  acts_as_relatable :shop, :tag
+end
+
+class Tag < ActiveRecord::Base
+  acts_as_relatable :product, :shop
+end
+
+class Shop < ActiveRecord::Base
+  acts_as_relatable :tag, :product
+end

data/spec/schema.rb

@@ -0,0 +1,23 @@
+ActiveRecord::Schema.define :version => 0 do
+  create_table :products, :force => true do |t|
+    t.string :name
+    t.integer :price
+  end
+
+  create_table :tags, :force => true do |t|
+    t.string :name
+  end
+
+  create_table :shops, :force => true do |t|
+    t.string :name
+    t.integer :size
+  end
+
+  create_table :relationships, :force => true do |t|
+    t.integer  :relator_id
+    t.string   :relator_type
+    t.integer  :related_id
+    t.string   :related_type
+    t.timestamps
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,2 @@
+--color
+--backtrace

data/spec/spec_helper.rb

@@ -0,0 +1,60 @@
+require "rubygems"
+require "bundler"
+
+Bundler.require(:default)
+
+require 'active_support/all'
+
+Dir[File.join(File.dirname(__FILE__), 'support/**/*.rb')].each {|f| require f}
+
+require File.expand_path(File.join(File.dirname(__FILE__), '../lib/acts_as_relatable'))
+
+db_name = ENV['DB'] || 'sqlite3'
+database_yml = File.expand_path('../database.yml', __FILE__)
+
+if File.exists?(database_yml)
+  ar_configuration = YAML.load_file(database_yml)
+  ActiveRecord::Base.configurations = ar_configuration
+  config = ActiveRecord::Base.configurations[db_name]
+
+  begin
+    ActiveRecord::Base.establish_connection(db_name)
+    ActiveRecord::Base.connection
+  rescue
+    case db_name
+    when /mysql/
+      ActiveRecord::Base.establish_connection(config.merge('database' => nil))
+      ActiveRecord::Base.connection.create_database(config['database'], {:charset => 'utf8', :collection => 'utf8_unicode_ci'})
+    when /postgresql/
+      ActiveRecord::Base.establish_connection(config.merge('database' => 'postgres', 'schema_search_path' => 'public'))
+      ActiveRecord::Base.connection.create_database(config['database'], config.merge('encoding' => 'utf8'))
+    end
+    ActiveRecord::Base.establish_connection(config)
+  end
+
+  ActiveRecord::Base.logger = Logger.new(File.join(File.dirname(__FILE__), "../tmp/debug.log"))
+  ActiveRecord::Base.default_timezone = :utc
+
+  ActiveRecord::Base.silence do
+    ActiveRecord::Migration.verbose = false
+    load(File.dirname(__FILE__) + '/schema.rb')
+    load(File.dirname(__FILE__) + '/models.rb')
+  end
+
+else
+  raise "Please create #{database_yml} first to configure your database. Take a look at: #{database_yml}.sample"
+end
+
+#For generators
+require File.expand_path(File.join(File.dirname(__FILE__), '../lib/generators/acts_as_relatable/config_generator.rb'))
+require File.expand_path(File.join(File.dirname(__FILE__), '../lib/generators/acts_as_relatable/migration_generator.rb'))
+
+def clean_database!
+  models = [Product, Shop, Tag]
+  models.each do |model|
+    ActiveRecord::Base.connection.execute "DELETE FROM #{model.table_name}"
+  end
+end
+
+clean_database!
+

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification 
+name: acts_as_relatable
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- "Fr\xC3\xA9d\xC3\xA9ric Malamitsas"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-16 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 3.0.9
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "3.0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "2.5"
+  type: :development
+  version_requirements: *id003
+description: Acts_as_relatable gem allows you to link/relate AR objects together easily with polymorphic associations.
+email: fmalamitsas@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/acts_as_relatable/relatable.rb
+- lib/acts_as_relatable/relationship.rb
+- lib/acts_as_relatable.rb
+- lib/generators/acts_as_relatable/config_generator.rb
+- lib/generators/acts_as_relatable/migration_generator.rb
+- lib/generators/acts_as_relatable/templates/acts_as_relatable.rb
+- lib/generators/acts_as_relatable/templates/migration.rb
+- lib/generators/acts_as_relatable/USAGE
+- spec/acts_as_relatable/generators/config_generator_spec.rb
+- spec/acts_as_relatable/generators/migration_generator_spec.rb
+- spec/acts_as_relatable/relatable_spec.rb
+- spec/acts_as_relatable/relationship_spec.rb
+- spec/database.yml
+- spec/database.yml.sample
+- spec/models.rb
+- spec/schema.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- Gemfile
+- LICENSE.txt
+- Rakefile
+- README.rdoc
+- init.rb
+homepage: http://github.com/fmalamitsas/acts_as_relatable
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.3.4
+requirements: []
+
+rubyforge_project: acts_as_relatable
+rubygems_version: 1.8.7
+signing_key: 
+specification_version: 3
+summary: Link AR objects easily with polymorphic associations
+test_files: []
+